Internationalization Tag Set (ITS)

1.1.1 Potential Users of ITS

The ITS specification aims to provide different types of users with information about what markup should be supported to enable worldwide use and effective localization of content. The following paragraphs sketch these different types of users, and their usage of ITS.

• Schema developers who start a schema from ground up

  This type of user will find proposals for attribute and element names to be included in their new schema (aka “host vocabularyâ€). Using the attribute and element names proposed in the ITS specification may be helpful because it leads to easier recognition of the concepts represented by both schema users and processors. It is perfectly possible, however, for a schema developer to develop his own set of attribute and element names. The specification sets out, first and foremost, to ensure the required markup is available, and that the behaviour of that markup meets established needs.

• Schema developers who work with an existing schema

  This type of user will be working with schemas such as DocBook, DITA, or perhaps a proprietary schema.

  The ITS Working Group has sought input from experts developing widely used formats such as the ones mentioned, and the ITS specification provides examples of how those formats (aka “host vocabularyâ€) could be used with ITS.

  Note:

  The Working Group intends to cover the question “How use ITS with existing popular markup schemes?†in more detail in a separate document/note on “Modularizations for ITSâ€.

  Developers working on existing schemas should check whether their schemas support the markup proposed in this specification, and, where appropriate, add the markup proposed here to their schema.

  In some cases, an existing schema may already contain markup equivalent to that recommended in ITS. In this case it is not necessary to add duplicate markup since ITS provides mechanisms for relating ITS markup with markup in the host vocabulary which serves a similar purpose (see Section 5.4: Mapping of ITS Data Categories to Existing Markup). The developer should, however, check that the behaviour associated with the markup in their own schema is fully compatible with the expectations described in this specification.

• Vendors of content-related tools

  This type of users encompasses companies which provide tools for authoring, translation or other flavours of content-related software solutions. It is important to ensure that such tools enable worldwide use and effective localization of content. For example, translation tools should prevent content marked up as not for translation from being changed or translated. It is hoped that the ITS specification will make the job of vendors easier by standardising the format and processing expectations of certain relevant markup items, and allowing them to more effectively identify how content should be handled.

• Content producers

  This type of users comprises authors, translators and other types of content authors. The markup proposed in this specification may be used by them to mark up specific bits of content. Aside: The burden of inserting markup should be removed from content producers by relating the ITS information to relevant bits of content in a global manner (see global, rule-based approach) . This global work, however, may fall to information architects, rather than the content producers themselves.

In order to support all of these users, the information about what markup should be supported to enable worldwide use and effective localization of content is provided in this specification in two ways:

• abstract in the data category descriptions Section 6: Description of Data Categories

• concrete in the ITS schemas Appendix A: Schemas for ITS

1.1.2 Ways to Use ITS

The ITS specification proposes several mechanisms for supporting worldwide use and effective localization of content. We will sketch them below by looking at from the perspectives of certain user types. For the purpose of illustration, we will answer the question, how ITS can indicate that certain parts of content should or should not be translated.

• A content author uses an attribute on a particular element to say that the text in the element should not be translated

<book>
 <head>...</head> <body> ...  <p>And he said: you need a
 new <quote its:translate="no">T-Model</quote></p> ...
 </body> 
</book>

• A content author or information architect uses markup at the top of the document to identify a particular type of element or context in which the content should not be translated.

<text>
 <head>
 <its:rules xmlns:its="http://www.w3.org/2005/11/its">
  <its:translateRule its:translate="no" its:selector="//dt"/>
 <its:rules>
 </head>
 <body> ...
  <p> ... <dl><dt>...</dt><dd>...</dd></dl></p>
 </body>
</text>

• A processor may inject markup at the top of the document which links to ITS information outside of the document.

<text>
 <head>
 <its:rules xmlns:its="http://www.w3.org/2005/11/its"
  xmlns:xlink="http://www.w3.org/1999/xlink"
  xlink:href="myRules.xml">
  </its:rules>
 </head>
 <body> ...
  <p> ... <dl><dt>...</dt><dd>...</dd></dl></p>
 </body>
</text>

• A schema developer integrates ITS markup declarations in his schema to allow users to indicate that specific parts of the content should not be translated (see Section 7: Modularizations of ITS with Existing Markup Schemes ).

The first two approaches above can be likened to the use of CSS in XHTML. Using a style attribute, an XHTML content author may assign a colour to a particular paragraph. That author could also have used the style element at the top of the page to say that all paragraphs of a particular class or in a particular context would be coloured red.

5.1.1 Schema Annotation

In Schemas, selection of ITS information is realized with schema annotation. The selection for a data category depends on the position of the schema annotation. Since schema annotation mechanisms are schema language specific, the following definitions are made:

• [Definition: selection of elements in XML Schema is expressed with an xs:appinfo element which is a direct child of the xs:element element and which contains a schemaRule element, which has one or more data category attributes.]

<xs:element name="p">
 <xs:annotation>
  <xs:appinfo>
   <its:schemaRule its:translate="yes"/>
  </xs:appinfo>
 </xs:annotation> ...
</xs:element>

• [Definition: selection of attributes in XML Schema is expressed with an xs:appinfo element which is a direct child of the xs:attribute element and which contains a schemaRule element, which has one or more data category attributes.]

<xs:attribute name="alt">
 <xs:annotation>
  <xs:appinfo>
   <its:schemaRule its:translate="yes"/>
  </xs:appinfo>
 </xs:annotation> ...
</xs:attribute>

• [Definition: selection of elements in RELAX NG is expressed with a schemaRule element which is a direct child of the rng:element element, and which has one or more data category attributes.]

<element name="p">
 <its:schemaRule its:translate="yes"/> ...
</element>

• [Definition: selection of attributes in RELAX NG is expressed with a schemaRule element which is a direct child of the rng:attribute element, and which has one or more data category attributes.]

<attribute name="p">
 <its:schemaRule its:translate="yes"/> ...
</attribute>

As for XML DTD, this specification defines no selection mechanism within the DTD.

Several data categories on the same element or attribute declaration should be expressed at the same schemaRule element.

<its:schemaRule its:translate="yes" its:locInfo="This has to be handled carefully"
its:locInfoType="alert"/>

5.1.2 Global, Rule-based Selection

Global, rule-based selection is implemented using the rules element. It contains one or more rule elements. Each rule element has a mandatory selector attribute.

Depending on the data category and its usage, there are additional attributes for adding information to the selected nodes, or for pointing to existing information in the document. For example, the data category localization information can be used for adding information to selected nodes, or for pointing to existing information in the document. For the former purpose, an locInfo element can be used. For the latter purpose, an locInfoPointer attribute can be used. element has one or more data category attributes, and for each data category attribute an selector attribute which expresses the selected information

The functionality of adding information to the selected nodes is available for each data category except language information. Pointing to existing information is not possible for data categories which express a closed set of values, that is: translatability, directionality and elements within text.

The functionalities of adding information and pointing to existing information are mutually exclusive. That is: markup for pointing and adding must not appear at the same rule element.

[Ed. note: The working group is looking for feedback on a proposal to group rule elements.]

The naming convention for the selector attributes is data category + Selector, e.g. translateSelector. In ITS rules selections, t The value of the selector attribute must be an XPath expression which starts with "/". That is, it must be an AbsoluteLocationPath as described in [XPath 1.0]. This ensures that the selection is not relative to a specific location.

As for data category specific attributes like locInfoPointer which point to existing information in the document, a RelativeLocationPath as described in [XPath 1.0] must be used. The XPath expression is evaluated relative to the nodes which are selected via the selector attribute.

If namespaces [XML Names] are used in XPath expressions in the selector attribute or the pointing attributes, the following rules must be applied while processing XPath:

1. For each prefix, there must be an ns element as a child of the rules element. The ns element has two attributes prefix (for the namespace prefix) and uri (for the namespace URI).

2. Element and attribute names without a prefix are interpreted as having no namespace.

3. To avoid a conflict with rule 2., default namespaces must not be used in the XPath expressions.

<!-- Definitions for TEI -->
<its:rules xmlns:its="http://www.w3.org/2005/11/its">
 <its:ns its:prefix="tei" its:uri="http://www.tei-c.org/ns/1.0"/>
 <termRule its:selector="//tei:term"/>
</its:rules>

<!-- Definitions for DocBook -->
<its:rules xmlns:its="http://www.w3.org/2005/11/its">
 <termRule its:selector="//qterm"/>
</its:rules>

Selection Global rules can appear in a schema (e.g. as content of the xs:appinfo element), in the XML document they will be applied to, or in a separate XML document. The precedence of their processing of the selection information depends on these variations. See also Section 5.3: Precedence between Selections.

<xs:schema>
 <xs:annotation>
  <xs:appinfo>
   <its:documentRules>
    <its:documentRule its:translate="no" its:translateSelector="//p[@editor='john']"/>
<!-- This rule holds for p elements which are edited by John. -->
   </its:documentRules>
  </xs:appinfo>
 </xs:annotation>
 <xs:element name="p">
  <xs:annotation>
   <xs:appinfo>
    <its:schemaRule its:translate="yes"/>
<!-- This rule holds for all p elements -->
    </xs:appinfo>
   </xs:annotation> ...
  </xs:element> ...
 </xs:schema>

Markup for global, rule-based selection is defined as follows.

Having its-global as the entry point of the schema serves as a wrapper schema for an external rules file.

rules

[1]	rules	::=	element its:rules { rules.content, rules.attributes }
[2]	rules.content	::=	ns*, ( translateRule | locInfoRule | termRule | dirRule | rubyRule | langRule | withinTextRule )+
[3]	rules.attributes	::=	att.xlink.attributes, empty

att.xlink

[4]	att.xlink.attributes	::=	att.xlink.attribute.href, empty
[5]	att.xlink.attribute.href	::=	attribute href { xsd:anyURI }?

ns

[6]	ns	::=	element its:ns { ns.content, ns.attributes }
[7]	ns.content	::=	empty
[8]	ns.attributes	::=	att.nsident.attributes, att.nsident.attributes, empty

att.nsident

[9]	att.nsident.attributes	::=	att.nsident.attribute.prefix, att.nsident.attribute.uri, empty
[10]	att.nsident.attribute.prefix	::=	attribute prefix { xsd:NCName }
[11]	att.nsident.attribute.uri	::=	attribute uri { xsd:anyURI }

att.selector

[12]	att.selector.attributes	::=	att.selector.attribute.selector, empty
[13]	att.selector.attribute.selector	::=	attribute selector { text }

5.1.3 Local Selection in an XML Document

Local selection of ITS information in XML documents is realized with local ITS attributes, the ruby element, or the span element. span serves just as a wrapper for the local ITS attributes and ruby.

It depends on the data category what is being selected. The necessary data category specific defaults are described in Section 6.1: Position and Default Selections of Data Categories.

<text>
 <head its:translate="no"> ... </head>
 <body its:translate="yes" its:dir="ltr"> ... </body>
</text>

Markup for local selection is defined as follows.

The span element can be used if a markup scheme has no element to which local ITS attributes can be attached. span contains these attributes and serves as a hook for using them in XML documents.

span

[14]	span	::=	element its:span { span.content, span.attributes }
[15]	span.content	::=	( text | ruby )*
[16]	span.attributes	::=	att.translate.attributes, att.locInfo.attributes, att.locInfoType.attributes, att.locInfoRef.attributes, att.term.attributes, att.termRef.attributes, att.dir.attributes, empty

6.2.1 Definition

The data category translatability expresses information about whether the content of an element or attribute should be translated or not. The values of this data category are "yes" (translatable) or "no" (not translatable).

6.2.2 Implementation

Translatability can be expressed in a schema, with global rules, or locally on an individual element.

In a schema, translatability is expressed with a schemaRule element with a translate attribute. The attribute has the values "yes" or "no".

<xs:element name="p">
 <xs:annotation>
  <xs:appinfo>
   <its:schemaRule its:translate="yes"/>
  </xs:appinfo>
 </xs:annotation> ...
</xs:element>

As for global rules, translatability is expressed with a translateRule element with a translate attribute. The attribute has the values "yes" or "no". In addition, a selector attribute is required.

<its:rules>
 <its:translateRule its:translate="yes" its:selector="//p"/>
<!-- All p elements should be translated-->
</its:rules>

Locally, translatability is expressed with a translate attribute with the values "yes" or "no" The selection is the textual content of the element, including child elements, but excluding attributes.

<book>
 <head>...</head> <body its:translate="yes"> ...  
  <p>And he said: you need a new 
  <quote its:translate="no">motherboard</quote> 
 </p> ...  </body>
</book>

6.2.3 Markup Declarations for Translatability

translateRule

[17]	translateRule	::=	element its:translateRule { translateRule.content, translateRule.attributes }
[18]	translateRule.content	::=	empty
[19]	translateRule.attributes	::=	att.selector.attributes, att.selector.attributes, att.translate.attributes, empty

att.translate

[20]	att.translate.attributes	::=	att.translate.attribute.translate, empty
[21]	att.translate.attribute.translate	::=	attribute translate { "yes" | "no" }?

6.3.1 Definition

The data category localization information is used to communicate information to localizers about a particular item of content.

This data category has several purposes:

• Tell the translator how to translate parts of the content

• Expand on the meaning or contextual usage of a specific element, such as what a variable refers to or how a string will be used on the user interface

• Clarify ambiguity and show relationships between items sufficiently to allow correct translation (e.g. in many languages it is impossible to translate the word "enabled" in isolation without knowing the gender, number and case of the thing it refers to.)

• Indicate why a piece of text is emphasized (important, sarcastic, etc.)

Two types of informative notes are needed:

• An alert contains information that the translator must read before translating a piece of text. Example: an instruction to the translator to leave parts of the text in the source language.

• A description provides useful background information that the translator will refer to only if they wish. Example: a clarification of ambiguity in the source text.

6.3.2 Implementation

Localization information can be expressed in a schema, with global rules, or locally on an individual element.

In a schema, localization information is expressed with a schemaRule element with a locInfo attribute. The type of the localization information is expressed with a locInfoType attribute with the values "alert" or "description".

<xs:element name="p">
 <xs:annotation>
  <xs:appinfo>
   <its:schemaRule
its:locInfo="This has to be handled carefully" its:locInfoType="alert"/>
  </xs:appinfo>
 </xs:annotation> ...
</xs:element>

As for global rules, adding localization information to selected nodes is realized with a locInfoRule element, which contains a locInfo element or a locInfoRef attribute. These two must not occur together. The attributes locInfoType and selector are mandatory.

<its:rules>
 <its:locInfoRule its:locInfoType="alert" its:selector="/body/p[1]">
  <its:locInfo>This p element has to be handled carefully"</its:locInfo>
 </its:locInfoRule>
</its:rules>

The functionality of pointing to existing localization information is realized via a locInfoRule element with a locInfoPointer attribute or a locInfoRefPointer attribute. These two must not occur together. The selector attribute is mandatory.

In an instance Locally in a document, localization information is expressed with the attributes locInfo or locInfoRef, and locInfoType. locInfo and locInfoRef must not occur together. If the locInfoType attribute is not present, the type of localization information will be assumed as description. The selection is the textual content of element, including child elements, but excluding attributes.

<book>
 <head>...</head>
 <body> ...
  <p its:locInfo="This p element has to be handled
   carefully" its:locInfoType="alert">And he said: you need a new
   <quote>motherboard</quote>
  </p> ...
 </body>
</book>

6.3.3 Identifying Existing Localization Information

To be able to identify globally existing localization information, the locInfoContent attribute can be used. It must be accompaigned by a locInfoType attribute.

To be able to differentiate the functionality of the locInfoContent attribute from locInfoSelector, these two attributes must not occur at the same documentRule element.

6.3.4 Markup Declarations for Localization Information

At the locInfoRule element, there must be either a locInfo element [not attribute] or a locInfoRef attribute. If neither is present, there must be either a locInfoPointer attribute or a locInfoRefPointer attribute. There is an optional locInfoType attribute.

locInfoRule

[22]	locInfoRule	::=	element its:locInfoRule { locInfoRule.content, locInfoRule.attributes }
[23]	locInfoRule.content	::=	locInfo?
[24]	locInfoRule.attributes	::=	att.selector.attributes, att.selector.attributes, att.locInfoPointer.attributes, att.locInfoRef.attributes, att.locInfoRefPointer.attributes, att.locInfoType.attributes, empty

locInfo

[25]	locInfo	::=	element its:locInfo { locInfo.content, locInfo.attributes }
[26]	locInfo.content	::=	text
[27]	locInfo.attributes	::=	att.translate.attributes, att.locInfo.attributes, att.locInfoType.attributes, att.locInfoRef.attributes, att.term.attributes, att.termRef.attributes, att.dir.attributes, empty

About locInfoLocal: There must be either a a locInfo attribute or a locInfoRef attribute. There is an optional locInfoType attribute.

att.locInfo

[28]	att.locInfo.attributes	::=	att.locInfo.attribute.locInfo, empty
[29]	att.locInfo.attribute.locInfo	::=	attribute locInfo { text }?

att.locInfoPointer

[30]	att.locInfoPointer.attributes	::=	att.locInfoPointer.attribute.locInfoPointer, empty
[31]	att.locInfoPointer.attribute.locInfoPointer	::=	attribute locInfoPointer { text }?

att.locInfoType

[32]	att.locInfoType.attributes	::=	att.locInfoType.attribute.locInfoType, empty
[33]	att.locInfoType.attribute.locInfoType	::=	attribute locInfoType { "alert" | "description" }?

att.locInfoRef

[34]	att.locInfoRef.attributes	::=	att.locInfoRef.attribute.locInfoRef, empty
[35]	att.locInfoRef.attribute.locInfoRef	::=	attribute locInfoRef { xsd:anyURI }?

att.locInfoRefPointer

[36]	att.locInfoRefPointer.attributes	::=	att.locInfoRefPointer.attribute.locInfoRefPointer, empty
[37]	att.locInfoRefPointer.attribute.locInfoRefPointer	::=	attribute locInfoRefPointer { text }?

6.4.1 Definition

The terminology data category is used to mark terms. This helps to increase consistency across different parts of the documentation. It is also helpful for translation.

6.4.2 Implementation

The terminology data category can be expressed in a schema, with global rules, or locally on an individual element.

In a schema, the terminology data category is expressed with a schemaRule element with a term attribute, which has the value "yes".

<xs:element name="span">
 <xs:annotation>
  <xs:appinfo>
   <its:schemaRule its:term="yes"/>
<!-- All span elements are used to mark up terms-->
  </xs:appinfo>
 </xs:annotation> ...
</xs:element>

As for global rules, identifying terminology information at selected nodes is realized with a termRule element with a mandatory selector attribute. In addition, an optional termRef attribute can be used to refer to external information about the term. The datatype of termRef is xs:anyURI. To point to existing term references, a termRefPointer attribute can be used. termRef and termRefPointer must not be used together.

<its:rules>
 <its:termRule its:selector="/body/p[1]/span"
its:termRef="http://example.com/termdatabase/#x142539"/>
</its:rules>

In an instance Locally in a document, the terminology data category is expressed with a term attribute, which has the value "yes", and an optional termRef attribute. The selection is the textual content of the element, including content of child elements, but excluding attributes.

<book>
 <head>...</head> <body> ...  <p>And he said: you need a
 new <quote its:term="yes">motherboard</quote></p> ...
 </body> 
</book>

6.4.3 Markup Declarations for Terminology

In an instance document, an attribute term="yes" is used to indicate a term. In the global rule, "being" a term is expressed via the name of the element termRule, hence the attribute term="yes" is not necessary any more. The attributes termRef and termRefPointer are alternatives. It is an error if they occur at the same termRule element.

termRule

[38]	termRule	::=	element its:termRule { termRule.content, termRule.attributes }
[39]	termRule.content	::=	empty
[40]	termRule.attributes	::=	att.selector.attributes, att.selector.attributes, att.termRef.attributes, att.termRefPointer.attributes, empty

att.termRef

[41]	att.termRef.attributes	::=	att.termRef.attribute.termRef, empty
[42]	att.termRef.attribute.termRef	::=	attribute termRef { xsd:anyURI }?

att.termRefPointer

[43]	att.termRefPointer.attributes	::=	att.termRefPointer.attribute.termRefPointer, empty
[44]	att.termRefPointer.attribute.termRefPointer	::=	attribute termRefPointer { text }?

About term: the attribute term is mandatory, the attribute termRef is optional.

att.term

[45]	att.term.attributes	::=	att.term.attribute.term, empty
[46]	att.term.attribute.term	::=	attribute term { "yes" }?

6.5.1 Definition

This data category expresses the directionality of a piece of text. Its values are "ltr", "rtl", "lro" or "rlo". This definition is compliant with the dir attribute in [XHTML 2.0], except that [XHTML 2.0] does not allow for rule-based, global selection.

6.5.2 Implementation

The dir attribute is used for the implementation of the directionality data category. It has the four values "ltr", "rtl", "lro" or "rlo".

Directionality can be expressed with global rules or locally on an individual element.

As for global rules, directionality is expressed in rules using a dirRule element with the dir attribute. In addition, a selector attribute is required.

<its:rules>
 <its:dirRule its:dir="rtl" its:selector="/body/p[1]/quote[xml:lang='he']"/>
<!-- Some Hebrew quotation -->
</its:rules>

In an instance Locally in a document, directionality is expressed with a dir attribute. The selection is the textual content of the element, including all child elements and attributes.

<book>
 <head>...</head> 
 <body> ...  <p>And he said: <quote
 its:dir="rtl"> ... a Hebrew quotation ... </quote></p>
 ...  </body> 
</book>

6.5.3 Markup Declarations for Directionality

TODO: comment?

dirRule

[47]	dirRule	::=	element its:dirRule { dirRule.content, dirRule.attributes }
[48]	dirRule.content	::=	empty
[49]	dirRule.attributes	::=	att.selector.attributes, att.selector.attributes, att.dir.attributes, empty

att.dir

[50]	att.dir.attributes	::=	att.dir.attribute.dir, empty
[51]	att.dir.attribute.dir	::=	attribute dir { "ltr" | "rtl" | "lro" | "rlo" }?

6.6.1 Definition

The data category ruby is used for a run of text that is associated with another run of text, referred to as the base text. Ruby text is used to provide a short annotation of the associated base text. It is most often used to provide a reading (pronunciation) guide.

6.6.2 Implementation

Ruby can be expressed locally in a n instance document or with global rules.

In an instance Locally in a document, Ruby locally in an instance document is realized with a ruby element.

<text>
 <head> ... </head>
 <body>
  <p>This is about the
    <its:ruby>
     <its:rb>W3C</its:rubyBase>
     <its:rt>World Wide Web Consortium</its:rubyText>
    </its:ruby>.
  </p>
 </body>
</text>

The structure of the content model for the ruby element is identical with the structure of ruby markup as defined in [Ruby-TR].

The functionality of pointing to existing ruby markup is realized with various pointer attributes for ruby. There is a pointer attribute for the ruby element and each element within its content model.

6.6.3 Handling Legacy Content

In legacy situations, where one cannot change the element markup and there one wants to apply ruby text to an attribute or existing element content, then the following approach can be used.

A rubyRule element can be used with two attributes:

• A rubyText attribute contains the ruby text (corresponding to the rt element in the case of no selections)

• A selector attribute contains the selector. It selects the ruby base text, corresponding to the rb element in the case of no selection.

<text ...>
 <head> ... </head>
  <its:rules>
   <its:rubyRule its:rubyText="World Wide Web Consortium"
    its:selector="/body/img[1]/@alt"/>
  </its:rules>
 <body>
  <img src="w3c_home.png" alt="W3C"/> ...
 </body>
</text>

6.6.4 Markup Declarations for Ruby

The element rubyRule is used (1) to map existing ruby "markup to ITS ruby, which itself is defind in terms of the W3C ruby specification, or (2) to add ruby text to attribute values. Example for (1): <its:rubyRule its:selector="//span[class='ruby']" its:rbPointer="span[class='rubyBase']" its:rtPointer="span[class='rubyText']"/> . Example for (2): <its:rubyRule its:selector="/body/img[1]/@alt" its:rbPointer="." its:rt="World Wide Web Consortium"/> . It is an error if both an its:rt attribute and an its:rtPointer attribute occur at the same <its:rubyRule> element.

rubyRule

[52]	rubyRule	::=	element its:rubyRule { rubyRule.content, rubyRule.attributes }
[53]	rubyRule.content	::=	empty
[54]	rubyRule.attributes	::=	att.selector.attributes, att.selector.attributes, att.rubyPointers.attributes, att.rubyText.attributes, empty

rubyLocal is defined in terms of http://www.w3.org/TR/ruby/\#definition. The (rbc, rtc, rtc?) alternative of the content model for the ruby element corresponds to complex ruby markup. The minimal content model for the ruby element is (rb, (rt | (rp, rt, rp))).

att.rubyPointers

[55]	att.rubyPointers.attributes	::=	att.rubyPointers.attribute.rubyPointer, att.rubyPointers.attribute.rbPointer, att.rubyPointers.attribute.rtPointer, att.rubyPointers.attribute.rpPointer, att.rubyPointers.attribute.rbcPointer, att.rubyPointers.attribute.rtcPointer, empty
[56]	att.rubyPointers.attribute.rubyPointer	::=	attribute rubyPointer { text }?
[57]	att.rubyPointers.attribute.rbPointer	::=	attribute rbPointer { text }?
[58]	att.rubyPointers.attribute.rtPointer	::=	attribute rtPointer { text }?
[59]	att.rubyPointers.attribute.rpPointer	::=	attribute rpPointer { text }?
[60]	att.rubyPointers.attribute.rbcPointer	::=	attribute rbcPointer { text }?
[61]	att.rubyPointers.attribute.rtcPointer	::=	attribute rtcPointer { text }?

att.rubyText

[62]	att.rubyText.attributes	::=	att.rubyText.attribute.rubyText, empty
[63]	att.rubyText.attribute.rubyText	::=	attribute rubyText { text }?

ruby

[64]	ruby	::=	element its:ruby { ruby.content, ruby.attributes }
[65]	ruby.content	::=	( rb, ( rt | ( rp, rt, rp ) ) ) | ( rbc, rtc, rtc? )
[66]	ruby.attributes	::=	att.translate.attributes, att.locInfo.attributes, att.locInfoType.attributes, att.locInfoRef.attributes, att.term.attributes, att.termRef.attributes, att.dir.attributes, empty

rb

[67]	rb	::=	element its:rb { rb.content, rb.attributes }
[68]	rb.content	::=	text
[69]	rb.attributes	::=	att.translate.attributes, att.locInfo.attributes, att.locInfoType.attributes, att.locInfoRef.attributes, att.term.attributes, att.termRef.attributes, att.dir.attributes, empty

rt

[70]	rt	::=	element its:rt { rt.content, rt.attributes }
[71]	rt.content	::=	attribute rbspan { text }, text
[72]	rt.attributes	::=	att.translate.attributes, att.locInfo.attributes, att.locInfoType.attributes, att.locInfoRef.attributes, att.term.attributes, att.termRef.attributes, att.dir.attributes, empty

rbc

[73]	rbc	::=	element its:rbc { rbc.content, rbc.attributes }
[74]	rbc.content	::=	rb+
[75]	rbc.attributes	::=	att.translate.attributes, att.locInfo.attributes, att.locInfoType.attributes, att.locInfoRef.attributes, att.term.attributes, att.termRef.attributes, att.dir.attributes, empty

rtc

[76]	rtc	::=	element its:rtc { rtc.content, rtc.attributes }
[77]	rtc.content	::=	rt+
[78]	rtc.attributes	::=	att.translate.attributes, att.locInfo.attributes, att.locInfoType.attributes, att.locInfoRef.attributes, att.term.attributes, att.termRef.attributes, att.dir.attributes, empty

rp

[79]	rp	::=	element its:rp { rp.content, rp.attributes }
[80]	rp.content	::=	text
[81]	rp.attributes	::=	att.translate.attributes, att.locInfo.attributes, att.locInfoType.attributes, att.locInfoRef.attributes, att.term.attributes, att.termRef.attributes, att.dir.attributes, empty

6.7.1 Definition

The element langRule is used to express that a given piece of content (selected by the attribute langPointer) is used to express language information as defined by [RFC 3066bis].

    <its:langRule its:selector="//p" its:langPointer="@mylangattribute"/>

6.7.2 Markup Declarations for Language Information

langRule

[82]	langRule	::=	element its:langRule { langRule.content, langRule.attributes }
[83]	langRule.content	::=	empty
[84]	langRule.attributes	::=	att.selector.attributes, att.selector.attributes, att.langPointer.attributes, empty

att.langPointer

[85]	att.langPointer.attributes	::=	att.langPointer.attribute.langPointer, empty
[86]	att.langPointer.attribute.langPointer	::=	attribute langPointer { text }

6.8.1 Definition

The data category elements within text expresses information about whether an element is part of its parent text unit. The values of this data category are "yes" (the element and its immediate child text nodes are part of the text unit of its parent element) or "no" (the element is not within text or holds an independent text unit within a parent text unit). Elements not listed are considered to be not within text.

6.8.2 Implementation

This data category can be expressed only in a set of rules. It cannot be expressed as local markup on an individual element.

Element within text is expressed with a withinTextRule element with a withinText attribute. The attribute has the values "yes" or "no". In addition, a selector attribute is required.

<its:rules>
 <its:withinTextRule its:withinText="yes" its:selector="//b | //em | //i"/>
</its:rules>

6.8.3 Markup Declarations for Elements within Text

withinTextRule

[87]	withinTextRule	::=	element its:withinTextRule { withinTextRule.content, withinTextRule.attributes }
[88]	withinTextRule.content	::=	empty
[89]	withinTextRule.attributes	::=	att.selector.attributes, att.selector.attributes, att.withinText.attributes, empty

att.withinText

[90]	att.withinText.attributes	::=	att.withinText.attribute.withinText, empty
[91]	att.withinText.attribute.withinText	::=	attribute withinText { "yes" | "no" }

7.1.1 Integration of ITS into XHTML

In XHTML 1.0, the XHTML namespace may be used with other XML namespaces as per [XML Names], but such documents are not strictly conforming XHTML 1.0 documents in the sense of XHTML 1.0.

An example of such a non-conformant XHTML 1.0 document is as follow.

<html xmlns="http://www.w3.org/1999/xhtml"
 xmlns:its="http://www.w3.org/2005/11/its" lang="en" xml:lang="en">
 <head>
  <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
  <meta name="keywords" content="ITS example, XHTML translation" />
  <its:rules>
   <its:ns prefix="h" uri="http://www.w3.org/1999/xhtml" />
   <its:translateRule its:selector="//h:meta[@name='keywords']/@content"
    its:translate="yes" />
   <its:termRule its:selector="//h:span[@class='term']" />
  </its:rules>
  <title>ITS Working Group</title>
 </head>
 <body>
 <h1>Test of ITS on <span class="term">XHTML</span></h1>
 <p>Some text to translate.</p>
 <p its:translate="no">Some text not to translate.</p>
 </body>
</html>

The way to use ITS with XHTML and keep the XHTML document conformant is to use external ITS global rules. Even local information within the document that would be handled by ITS attributes can be set indirectly.

<its:rules xmlns:its="http://www.w3.org/2005/11/its">
 <its:ns prefix="h" uri="http://www.w3.org/1999/xhtml" />
 <its:translateRule its:selector="//h:meta[@name='keywords']/@content"
  its:translate="yes" />
 <its:translateRule its:selector="//h:p[@class='notrans']"
  its:translate="no" />
 <its:termRule its:selector="//h:span[@class='term']" />
</its:rules>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
 "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" lang="en" xml:lang="en">
 <head>
  <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
  <meta name="keywords" content="ITS example, XHTML translation" />
  <title>ITS Working Group</title>
 </head>
 <body>
 <h1>Test of ITS on <span class="term">XHTML</span></h1>
 <p>Some text to translate.</p>
 <p class="notrans">Some text not to translate.</p>
 </body>
</html>

7.1.2 Relating ITS to Existing Markup in XHTML

A number of XHTML constructs implement the same semantic as some of the ITS data categories. In addition, some of the attributes in XHTML are translatable which is not the default for XML documents according ITS defaults settings. These attributes need to be identified as translatable.

An external ITS rules element can summarize these relations. Because XHTML use is widespread and covers a large amount of legacy material the rules defined here may not be optimal for everyone.

<its:rules xmlns:its="http://www.w3.org/2005/11/its">
 <its:ns its:prefix="h" its:uri="http://www.w3.org/1999/xhtml"/>
 <!-- special content. (See note 1) -->
 <its:translateRule its:selector="//h:script" its:translate="no"/>
 <its:translateRule its:selector="//h:style" its:translate="no"/>

 <!-- Normal translatable attributes -->
 <its:translateRule its:selector="//h:*/@abbr" its:translate="yes"/>
 <its:translateRule its:selector="//h:*/@accesskey" its:translate="yes"/>
 <its:translateRule its:selector="//h:*/@alt" its:translate="yes"/>
 <its:translateRule its:selector="//h:*/@prompt" its:translate="yes"/>
 <its:translateRule its:selector="//h:*/@standby" its:translate="yes"/>
 <its:translateRule its:selector="//h:*/@summary" its:translate="yes"/>
 <its:translateRule its:selector="//h:*/@title" its:translate="yes"/>

 <!-- The input element (Important: See note 2) -->
 <its:translateRule its:selector="//h:input/@value" its:translate="yes"/>
 <its:translateRule its:selector="//h:input[@type='hidden']/@value" its:translate="no"/>

 <!-- Non-translatable element (See note 3) -->
 <its:translateRule its:selector="//h:del" its:translate="no"/>
 <its:translateRule its:selector="//h:del/descendant-or-self::*/@*" its:translate="no"/>

 <!-- Often-used translatable meta content. -->
 <its:translateRule its:selector="//h:meta[@name='keywords']/@content"
 its:translate="yes"/>
 <its:translateRule its:selector="//h:meta[@name='description']/@content"
 its:translate="yes"/>

 <!-- Possible term (Important: See note 4) -->
 <its:termRule its:selector="//h:dt" its:term="yes"/>

 <!-- Bidirectional information -->
 <its:dirRule its:selector="//h:*[@dir='ltr']" its:dir="ltr"/>
 <its:dirRule its:selector="//h:*[@dir='rtl']" its:dir="rtl"/>
 <its:dirRule its:selector="//h:bdo[@dir='ltr']" its:dir="lro"/>
 <its:dirRule its:selector="//h:bdo[@dir='rtl']" its:dir="rlo"/>

 <!-- Elements within text -->
 <its:withinTextRule its:withinText="yes"
  its:selector="//h:abbr | //h:acronym | //h:br | //h:cite | //h:code | //h:dfn
  | //h:kbd | //h:q | //h:samp | //h:span | //h:strong | //h:var | //h:b | //h:em
  | //h:big | //h:hr | //h:i | //h:small | //h:sub | //h:sup | //h:tt | //h:del
  | //h:ins | //h:bdo | //h:img | //h:a | //h:font | //h:center | //h:s | //h:strike
  | //h:u | //h:isindex" />

</its:rules>

Additional notes on these rules:

• Note 1: The script and style elements may have translatable text, but their content needs to be parsed with respectively a script filter and a CSS filter. Depending on the capability of your translation tools you may want to leave these elements translatable.

• Note 2: The value attribute of the input element may or may not be translatable depending on the way the element is used. Selecting value as translatable or not needs to be decided depending on your own use.

• Note 3: The del element indicates removed text and therefore, most often, would not be translatable. Because this element may contain elements with translatable attributes such as img with alt, and because the scope of translatability does not include attributes, you need to: a) define this rule after the definition of the translatable attributes, and b) use the rules with its:selector="//h:del/descendant-or-self::*/@*" to overwrite any possible translatable attribute within a del element or any of its descendants.

• Note 4: The dt element is defined by HTML as a "definition term" and can therefore be seen as a candidate to be associated with the ITS Terminology data category. However, for historical reasons, this element has been used for many other purposes. Selecting dt as a term or not needs to be decided depending on your own use.

7.5.1 Integration of ITS into TEI

The TEI is maintained as a single ODD document, and customizations of it are also written as ODD documents. These are processed using XSLT stylesheets to make a tailored user-level schema in XML DTD, XML Schema or RELAX NG.

The ITS additions involve two changes to TEI:

1. Allowing rules to appear in the TEI metadata section (the teiHeader).

2. Adding the ITS local attributes to the TEI global attribute set.

Both of these can be easily achieved using standard techniques in ODD.

The body of a TEI/ITS customization consists of a schemaSpec which lists the modules to be included (this example includes six common ones):

<schemaSpec ident="tei-its" start="TEI">
 <moduleRef key="header"/>
 <moduleRef key="core"/>
 <moduleRef key="tei"/>
 <moduleRef key="textstructure"/>
 <moduleRef key="namesdates"/>
 <moduleRef key="msdescription"/> ...

In addition, we load the ITS schema (in its RELAX NG XML format, the language used by the TEI for expressing content models), and overload the definition of the TEI content class model.headerPart to include the ITS rules:

<moduleRef url="its.rng">
 <content>
 <rng:define name="model.headerPart" combine="choice">
  <rng:ref name="rules"/>
 </rng:define>
 </content>
</moduleRef>

The content class determines which elements are allowed as children of teiHeader. Lastly, we change the definition of the global attribute class att.global to reference the ITS local attributes (available from the ITS schema we loaded earlier):

<classSpec ident="att.global" type="atts" mode="change">
  <attList>
   <attRef name="span.attributes"/>
  </attList>
 </classSpec>
... </schemaSpec>

When processing, this customization produces a schema which permits markup like this:

<TEI
 xmlns:its="http://www.w3.org/2005/11/its"
 xmlns="http://www.tei-c.org/ns/1.0">
 <teiHeader>
  <fileDesc>
<!-- details of the file -->
  </fileDesc>
  <rules xmlns="http://www.w3.org/2005/11/its">
   <ns its:prefix="t" its:uri="http://www.tei-c.org/ns/1.0"/>
   <translateRule its:translate="no"
     its:selector="//t:body/t:p/@*"/>
   <translateRule its:translate="yes"
     its:selector="//t:body/t:p"/>
  </rules>
 </teiHeader>
 <text>
  <body>
   <p rend="normal">Hello  <hi>world</hi></p>
   <p rend="special">Goodbye</p>
   <p its:translate="no">This must not be translated</p>
  </body>
 </text>
</TEI>

In this example, a set of rule elements are provided in the header to provide rules, and the body of the text performs a specific override.

7.6.1 Integration of ITS into XML Spec

ITS has been integrated into xmlspec-i18n.dtd. This is a version of the XML DTD version 2.9 of XML Spec which already supplies various internationalization and localization related features. For example, there is an attribute translate in xmlspec-i18n.dtd, which can be used for the same purposes as the ITS translate attribute. To be able to separate them from original XML Spec declarations, all additions are stored in two separate files i18n-extensions.mod and i18n-elements.mod. Xmlspec-i18n.dtd is used within the W3C Internationalization Activity for the creation of technical reports.

For the integration of ITS, the following modifications to the xmlspec-i18n.dtd have been made:

1. A new entity <!ENTITY % its SYSTEM "its.dtd"> and the entity call %its; have been added to xmlspec-i18n.dtd.

2. The existing XML Spec entity %common.att; has been modified . The ITS entities %att.translate.attributes;, %att.locInfo.attributes;, %att.locInfoType.attributes;, %att.locInfoRef.attributes;, %att.term.attributes;, %att.termRef.attributes; and %att.dir.attributes; have been added to %common.att;. In this way, the local attributes can be used at any element defined in the XML Spec DTD.

3. The XML Spec entity %header.mdl; contains the content model of the header element. The ITS element rules has been added as the last element to this content model. In this way, rules can be used inside an XML Spec document. The header element of the XML Spec DTD has been chosen as the place for rules, to avoid the impact of ITS markup on XML Spec markup.

4. The ITS element ruby has been added to the XML Spec entity %p.pcd.mix;. In this way it is possible to use ruby as an inline element.

7.6.2 Relating ITS to Existing Markup in XML Spec

As mentioned before, xmlspec-i18n.dtd has its own existing markup declarations for various internationalization and localization related purposes. In the original XML Spec 2.9 DTD, there is a term element which fulfills the same purpose as the ITS term attribute.

To relate such existing XML Spec and xmlspec-i18n.dtd related markup to ITS markup (see Section 5.4: Mapping of ITS Data Categories to Existing Markup), the following rules element has been created. [Ed. note: This is not an exhaustive list of mappings yet, but only a first attempt].

<its:rules xmlns:its="http://www.w3.org/2005/11/its">
 <!--The following rules are for xmlspec-i18n.dtd-->
 <its:termRule its:term="yes" its:selector="//qterm"/>
 <its:dirRule its:dir="ltr" its:selector="//*[@dir='ltr']"/>
 <its:dirRule its:dir="rtl" its:selector="//*[@dir='rtl']"/>
 <its:dirRule its:dir="lro" its:selector="//*[@dir='lro']"/>
 <its:dirRule its:dir="rlo" its:selector="//*[@dir='rlo']"/>
 <its:locInfoRule its:locInfoType="alert"
   its:locInfoPointer="@locn-alert" its:selector="//*"/>
 <its:locInfoRule its:locInfoType="description"
   its:locInfoPointer="//@locn-note" its:selector="//*"/>
 <its:translateRule its:translate="yes" 
   its:selector="//*[@translate='yes']"/>
 <its:translateRule its:translate="no" 
   its:selector="//*[@translate='no']"/>
 <!--This rule is for the original XML Spec DTD-->
 <its:termRule its:selector="//term"/>
</its:rules>

Since both XML Spec and xmlspec-i18n.dtd do not define a namespace, the mappings use XPath expressions with unqualified element and attribute names.

8.1.1 The ITS Span Element

The span element can be used if a markup scheme has no element to which data category attributes can be attached. span contains these attributes and serves as a hook for using them in XML documents.

<text>
 <head>[...]</head>
 <body> ...
  <its:span its:translate="no"> ... </its:span>
 </body>
</text>

The span element contains the data category attributes.

span

[92]	span	::=	element its:span { span.content, span.attributes }
[93]	span.content	::=	text
[94]	span.attributes	::=	att.datacats.attributes, empty