Timed Text (TT) Authoring Format 1.0 – Distribution Format Exchange Profile (DFXP)

3.2.1 Generic Processor Conformance

A TT AF processor conforms to this specification if the following generic processor criteria are satisfied:

1. The processor provides at least one mechanism for notionally instantiating a Reduced XML Infoset representation of a conformant TT AF document instance.

2. If a process does or can perform validation of a candidate TT AF document instance, then it provides at least one mechanism to implicitly or explicitly associate the Reduced XML Infoset representation of a conformant TT AF document instance with one of the TT AF Abstract Document Types defined by 4 Document Types .

3. The processor does not a priori reject or abort the processing of a conformant TT AF document instance unless the processor does not support some required (mandatory) feature specified or implied by a TT AF content profile declared to apply to the document instance.

4. The processor supports all mandatory processing semantics defined by this specification.

5. If the processor supports some optional processing semantics defined by this specification, then it does so in a manner consistent with the defined semantics.

3.2.2 Transformation Processor Conformance

A TT AF processor is a conformant TT AF transformation processor if the following criteria are satisfied:

1. The processor satisfies all requirements specified by 3.2.1 Generic Processor Conformance .

2. The processor supports the DFXP Transformation profile as specified by G.2 G.1 DFXP Transformation Profile .

3.2.3 Presentation Processor Conformance

1. The processor satisfies all requirements specified by 3.2.1 Generic Processor Conformance .

2. The processor implements support for the region and line layout semantics defined by 9.3 Region Layout and Presentation and 9.4 Line Layout , respectively. In addition, the processor should satisfy the user agent accessibility guidelines specified by [UAAG] . The processor supports the DFXP Presentation profile as specified by G.1 G.2 DFXP Presentation Profile .

5.3.1 Core Catalog

The core vocabulary catalog is intended to satisfy the needs of DFXP while providing a baseline vocabulary for future profiles. This vocabulary is divided into distinct categories, specified in detail in the following sections:

• 6 Parameters

• 7 Content

• 8 Styling

• 9 Layout

• 10 Timing

• 11 Animation

• 12 Metadata

The core element vocabulary specified for use with a TT AF document instance is enumerated in Table 3 – Element Vocabulary .

Element vocabulary groups that are used in defining content models for TT AF element types are enumerated in Table 4 – Element Vocabulary Groups .

The attribute vocabulary specified for use with the core vocabulary catalog is enumerated in Table 5 – Attribute Vocabulary .

5.3.2 Extension Catalog

The extension vocabulary catalog is intended for use by future profiles of the TT AF. In AF, and is not further defined by this version of this specification, no standardized extension vocabulary is defined. The following namespaces are specifically reserved by Table 1 – Namespaces for extension vocabulary: TT Metadata Extension TT Parameter Extension TT Style Extension specification.

In addition to standardized extension vocabulary, a conforming TT AF document instance may contain arbitrary namespace qualified elements that reside in any namespace other than those namespaces defined for use with this specification. Furthermore, a conforming TT AF document instance may contain arbitrary namespace qualified attributes on TT AF defined vocabulary where such attributes reside in any namespace other than those defined for use with this specification.

6.1.1 ttp:profile

The ttp:profile element is used to specify a collection of used (mandatory and enabled), required (mandatory) (mandatory), and optional (voluntary) features and extensions that must or may be supported by a TT AF content processor in order to process a TT AF document that makes use (or may make use) of such features and extensions.

This specification defines two distinct uses of the ttp:profile element:

• as a child of the head element within a TT AF document instance;

• as the root element of a TT AF Profile Definition document instance;

When a tt:profile element appears within a TT AF document instance, its purpose is to express authorial intentions about which featueres features and extensions must or may be supported by a recipient content processor. In addition, the element indirectly expresses information about the set of features or extensions that are (or may expected to be) used by the document instance.

When a tt:profile element is used by a TT AF Profile Definition document instance, it serves to publish a machine readable specification of a specific TT AF content profile, of which this specification defines two four such Profile Definition Documents in G Profiles .

The ttp:profile element accepts as its children zero or more elements in the Metadata.class element group, followed by zero or more ttp:features elements, followed by zero or more ttp:extensions elements.

<ttp:profile
  use = string
  xml:id = ID
  {}>

  {any attribute not in default or any TT namespace}>

  Content: Metadata.class*, ttp:features*, ttp:extensions*
</ttp:profile>

If specified, the use attribute must adhere to the xsd:anyURI data type defined by [XML Schema Part 2] , §3.2.17, and, furthermore, must denote a profile designator in accordance with 5.2 Profiles . In this case, the profile designator must refer to (1) a standard, predefined TT AF Profile Definition Document as defined by G Profiles , or (2) a dereferenceable resource representing a valid TT AF Profile Definition document instance. In either case, the referenced profile serves as the baseline profile of the specifying ttp:profile element.

If the use attribute is not specified, then the baseline profile of the ttp:profile element must be considered to be the empty (null) profile, i.e., a profile definition containing no feature or extension specifications.

The collection of features and extensions of a profile are determined according to the following ordered rules:

1. initialize the features and extensions of the profile to the empty set;

2. if a use attribute is present, then augment the profile with the set of features and extensions specified by the referenced baseline profile;

3. for each ttp:feature and ttp:extension element descendant of the ttp:profile element, using a post-order traversal, merge the specified feature or extension with the features and extensions of the profile, where merging a feature or extension entails replacing an existing feature or extension specification, if it already exists, or adding a new feature or extension specification, if it does not yet exist in the profile;

A conformant TT AF processor is not required to be able to dereference a TT AF Profile Definition Document that is not one of the standard, predefined profiles defined by G Profiles . A conformant TT AF processor may make use of a built-in, static form of each standard, predefined profile so as not to require dereferencing a network resource.

If a TT AF processor is unable to dereference a non-standard TT AF Profile Definition Document, then it must not further process the document without the presence of an explicit override from an end-user or some implementation specific parameter traceable to an end-user or to a user or system configuration setting. If a TT AF processor aborts processing of a TT AF document instance due to the inability to reference a non-standard TT AF Profile Definition Document, then some end-user notification should be given unless the end-user or system has disabled such a notification, or if the processor does not permit or entail the intervention of an end-user.

If more than one ttp:profile element appears in a TT AF document instance, then all specified profiles apply simultaneously. In such a case, if some feature or some extension is specified by one profile to be required (mandatory) and by another profile to be optional (voluntary), then that feature or extension must be considered to be required (mandatory). The ttp:profile element is illustrated by the following example.

<ttp:profile use="dfxp-presentation">
  <ttp:features>

  <ttp:features xml:base="http://www.w3.org/2006/10/ttaf1/feature">

    <ttp:feature>#rollUp</ttp:feature>
  </ttp:features>
</ttp:profile>

6.1.2 ttp:features

The ttp:features element is a container element used to group infomation about feature support requirements.

The ttp:features element accepts as its children zero or more elements in the Metadata.class element group, followed by zero or more ttp:feature elements.

<ttp:features
  base = string : 

  xml:base = string : TT Feature Namespace

  xml:id = ID
  {}>

  {any attribute not in default or any TT namespace}>

  Content: Metadata.class*, ttp:feature*
</ttp:features>

If specified, the base xml:base attribute must (1) adhere to the xsd:anyURI data type defined by [XML Schema Part 2] , §3.2.17, (2) express an absolute URI that adheres to [XML Base] and, furthermore, must (3) express a feature namespace as defined by E.1 Feature Designations . If not specified, the base xml:base attribute's default value applies, which is the TT Feature Namespace.

The base xml:base attribute is used to permit the abbreviation of feature designation URIs expressed by child ttp:feature elements.

6.1.3 ttp:feature

The ttp:feature element is used to specify infomation about support requirements for a particular feature.

The children of the ttp:feature element must express a non-empty sequence of character information items that adheres to the xsd:anyURI data type defined by [XML Schema Part 2] , §3.2.17.

<ttp:feature
  value = (required|optional) : required

  value = (optional|required|use) : required

  xml:id = ID
  {}>

  {any attribute not in default or any TT namespace}>

  Content: #PCDATA
</ttp:feature>

If the URI expressed by the content of the ttp:feature element is a relative URI, then, when combined with the feature namespace value of expressed by the base xml:base attribute of the nearest ancestor ttp:features element, it must express an absolute URI. In either case (original absolute URI or resulting absolutized URI), the URI expressed by the ttp:feature element must further adhere to the syntax of a feature designation as defined by E.1 Feature Designations .

If the URI expressed by the content of the ttp:feature element is a relative URI, then an xml:base attribute should be specified on the nearest ancestor ttp:features element.

The value attribute specifies whether a conforming TT AF processor must or may implement the designated feature in order to process the document. If the value of the value attribute is required optional , then the processor must need not implement or otherwise support the feature in order to process the document; however, if the value is optional required , then the processor need not must implement or otherwise support the feature in order to process the document. document; if the value is use ,then the processor must both (1) implement or otherwise support the feature and (2) enable (activate) use of the feature.

If the value of the value attribute is required or use , and if the TT AF processor implementation does not support the feature, then it must not further process the document without the presence of an explicit override from an end-user or some implementation specific parameter traceable to an end-user or to a user or system configuration setting. If a TT AF processor aborts processing of a TT AF document instance due to the specification of a required, but unsupported feature by this element, then some end-user notification should be given unless the end-user or system has disabled such a notification, or if the processor does not permit or entail the intervention of an end-user.

If the value of the value attribute is optional , and if the TT AF processor implementation does not support the feature, then it may further process the document even in the case that some use of the feature is present in the document. In the case of actual use of a feature designated as optional, the default semantics associated with that feature apply; that is, the processor may behave as if the feature were not actually used or referenced by the document. Notwithstanding the above, the syntactic presence or reference to an optional feature by a document must not be considered to be a violation of document validity or a barrier to further processing if the syntactic expression is well-formed and valid.

The ttp:feature element is illustrated by the following example.

<ttp:profile use="http://www.w3.org/2006/10/ttaf1/profile/dfxp-presentation">
  <ttp:features>

  <ttp:features xml:base="http://www.w3.org/2006/10/ttaf1/feature">
    <ttp:feature value="required">#fontStyle-italic</ttp:feature>
    <ttp:feature value="required">#textDecoration-under</ttp:feature>
    

  </ttp:features>
</ttp:profile>

6.1.4 ttp:extensions

The ttp:extensions element is a container element used to group infomation about extension support requirements.

The ttp:extensions element accepts as its children zero or more elements in the Metadata.class element group, followed by zero or more ttp:extension elements.

<ttp:extensions
  base = string : 

  xml:base = string : TT Extension Namespace

  xml:id = ID
  {}>

  {any attribute not in default or any TT namespace}>

  Content: Metadata.class*, ttp:extension*
</ttp:extensions>

If specified, the base xml:base attribute must (1) adhere to the xsd:anyURI data type defined by [XML Schema Part 2] , §3.2.17, (2) express an absolute URI that adheres to [XML Base] and, furthermore, must (3) express an extension namespace as defined by F.1 Extension Designations . If not specified, the base xml:base attribute's default value applies, which is the TT Extension Namespace.

The base xml:base attribute is used to permit the abbreviation of extension feature designation URIs expressed by child ttp:extension elements.

6.1.5 ttp:extension

The ttp:extension element is used to specify infomation about support requirements for a particular extension.

The children of the ttp:extension element must express a non-empty sequence of character information items that adheres to the xsd:anyURI data type defined by [XML Schema Part 2] , §3.2.17.

<ttp:extension
  value = (required|optional) : required

  value = (optional|required|use) : required

  xml:id = ID
  {}>

  {any attribute not in default or any TT namespace}>

  Content: #PCDATA
</ttp:extension>

If the URI expressed by the content of the ttp:extension element is a relative URI, then, when combined with the extension namespace value of expressed by the base xml:base attribute of the nearest ancestor ttp:extensions element, it must express an absolute URI. In either case (original absolute URI or resulting absolutized URI), the URI expressed by the ttp:extension element must further adhere to the syntax of an extension designation as defined by F.1 Extension Designations .

If the URI expressed by the content of the ttp:feature element is a relative URI, then an xml:base attribute should be specified on the nearest ancestor ttp:extensions element.

The value attribute specifies whether a conforming TT AF processor must or may implement the designated extension in order to process the document. If the value of the value attribute is required optional , then the processor must need not implement or otherwise support the extension in order to process the document; however, if the value is optional required , then the processor need not must implement or otherwise support the extension in order to process the document. document; if the value is use ,then the processor must both (1) implement or otherwise support the extension and (2) enable (activate) use of the extension.

If the value of the value attribute is required or use , and if the TT AF processor implementation does not support the extension, then it must not further process the document without the presence of an explicit override from an end-user or some implementation specific parameter traceable to an end-user or to a user or system configuration setting. If a TT AF processor aborts processing of a TT AF document instance due to the specification of a required, but unsupported extension by this element, then some end-user notification should be given unless the end-user or system has disabled such a notification, or if the processor does not permit or entail the intervention of an end-user.

If the value of the value attribute is optional , and if the TT AF processor implementation does not support the extension, then it may further process the document even in the case that some use of the extension is present in the document. In the case of actual use of an extension designated as optional, the default semantics associated with that extension apply; that is, the processor may behave as if the extension were not actually used or referenced by the document. Notwithstanding the above, the syntactic presence or reference to an optional extension by a document must not be considered to be a violation of document validity or a barrier to further processing if the syntactic expression is well-formed and valid.

The ttp:extension element is illustrated by the following example.

<ttp:profile use="http://www.w3.org/2006/10/ttaf1/profile/dfxp-transformation">
  <ttp:extensions>
    
  </ttp:extensions>
  <ttp:extensions base="http://foo.bar.example.org/ttaf1/extension">
    

  <ttp:extensions xml:base="http://foo.bar.example.org/ttaf1/extension">
    <ttp:extension value="use">#prefilter-by-language</ttp:extension>
  </ttp:extensions>
</ttp:profile>

6.2.1 ttp:cellResolution

The ttp:cellResolution attribute may be used by an author to express the number of horizontal and vertical cells into which the root container region area is divided for the purpose of expressing presentation semantics in terms of a uniform grid.

If specified, the value of this attribute must adhere to the following syntax:

ttp:cellResolution
  : columns rows                            // columns != 0; rows != 0
columns | rows
  : <digit>+

If not specified, the number of columns and rows must be considered to be 32 and 15, respectively. If specified, then columns or rows must not be zero (0).

A ttp:cellResolution attribute is considered to be significant only when specified on the tt element.

6.2.2 ttp:clockMode

The ttp:clockMode attribute is used to specify the interpretation of time expressions as real-time time coordinates when operating with time base of clock as defined by 6.2.11 ttp:timeBase .

If specified, the value of this attribute must adhere to the following syntax:

ttp:clockMode
  : "local"
  | "gps"
  | "utc"

If the time base, defined by 6.2.11 ttp:timeBase , is designated as clock , then this parameter applies as follows: if the parameter's value is local , then time expressions are interpreted as local wall-clock time coordinates; if utc , then time expressions are interpreted as UTC time coordinates [UTC] ; if gps , then time expressions are interpreted as GPS time coordinates [GPS] .

If not specified, the value of this parameter must be considered to be utc .

A ttp:clockMode attribute is considered to be significant only when specified on the tt element.

6.2.3 ttp:frameRate

The ttp:frameRate attribute is used to specify the frame rate of a related media object or the intrinsic frame rate of a document instance in case it is intended to function as an independent media object.

If specified, the value of this attribute must adhere to the following syntax:

ttp:frameRate
  : <digit>+                                // value > 0

The frame rate that applies to a document instance is used to interpret time expressions that are expressed in frames as defined by 10.3.1 <timeExpression> .

A frame is interpreted as a division of a second of media time, such that if the frame rate is specified as F , then a second of media time is divided into F intervals of equal duration, where each interval is labeled as frame f , with f ∈ [0… F−1 ].

If not specified, the frame rate must be considered to be equal to some application defined frame rate, or if no application defined frame rate applies, then thirty (30) frames per second. If specified, then the frame rate must be greater than zero (0).

A ttp:frameRate attribute is considered to be significant only when specified on the tt element.

6.2.4 ttp:frameRateMultiplier

The ttp:frameRateMultiplier attribute is used to specify a multiplier to be applied to the frame rate specified by a ttp:frameRate attribute in order to compute the effective frame rate.

If specified, the value of this attribute must adhere to the following syntax:

ttp:frameRateMultiplier
  : numerator ( ":" denominator )?          // denominator != 0
numerator | denominator
  : <digit>+

A frame rate multiplier is used when the desired frame rate cannot be expressed as an integral number of frames per second.

If not specified, the frame rate multiplier must be considered to be equal to one (1:1). If a denominator is specified, then it must not be zero (0). If no denominator is specified, then a denominator of one (1) applies.

A ttp:frameRateMultiplier attribute is considered to be significant only when specified on the tt element.

6.2.5 ttp:markerMode

The ttp:markerMode attribute is used to specify constraints on the interpretation and use of time expressions that correspond with [SMPTE 12M] time coordinates when operating with time base of smpte as defined by 6.2.11 ttp:timeBase .

If specified, the value of this attribute must adhere to the following syntax:

ttp:markerMode
  : "continuous"
  | "discontinuous"

If the time base, defined by 6.2.11 ttp:timeBase , is designated as smpte , then this parameter applies as follows: if the parameter's value is continuous , then [SMPTE 12M] time coordinates may be assumed to be linear and either monotonically increasing or decreasing; however, if discontinuous , then any assumption must not be made regarding linearity or monotonicity of time coordinates.

If not specified, the value of this parameter must be considered to be continuous .

A ttp:markerMode attribute is considered to be significant only when specified on the tt element.

If a value of discontinuous applies, then time expressions must not be converted to either media time or real time coordinates, arithmetical operators (addition, multiplication) are not defined on time expressions, and, consequently, any expression of a duration must be ignored.

6.2.6 ttp:pixelAspectRatio

The ttp:pixelAspectRatio attribute may be used by a content author to express the aspect ratio of non-square pixels in the production of content that makes use of pixel coordinates.

If specified, the value of this attribute must adhere to the following syntax:

ttp:pixelAspectRatio
  : width ":" height                        // width != 0; height != 0
width | height
  : <digit>+

If not specified, then square pixels (i.e., aspect ratio 1:1) must be assumed to apply. If specified, then width or height must not be zero.

A ttp:pixelAspectRatio attribute is considered to be significant only when specified on the tt element.

6.2.7 ttp:profile

The ttp:profile attribute may be used by a content author to express the profile of the Timed Text Authoring Format (TT AF) used in a document instance.

If specified, the value of this attribute must adhere to the xsd:anyURI data type defined by [XML Schema Part 2] , §3.2.17, and, further, must specify a profile designator in accordance with 5.2 Profiles .

A ttp:profile attribute is considered to be significant only when specified on the tt element.

6.2.8 ttp:smpteMode

The ttp:smpteMode attribute is used to specify constraints on the interpretation and use of frame counts that correspond with [SMPTE 12M] time coordinates when operating with time base of smpte as defined by 6.2.11 ttp:timeBase .

If specified, the value of this attribute must adhere to the following syntax:

ttp:smpteMode
  : "dropNTSC"
  | "dropPAL"
  | "nonDrop"

If the time base, defined by 6.2.11 ttp:timeBase , is designated as smpte , then this parameter applies as follows: if the parameter's value is nonDrop , then, within any given second of a time expression, frames count from 0 to N−1 , where N is the value specified by the ttp:frameRate parameter, but while ignoring any value specified by the ttp:frameRateMultiplier parameter.

If this parameter's value is dropNTSC , then, within any given second of a time expression except the second 00 , frames count from 0 to N−1 , where N is the value specified by the ttp:frameRate parameter, but while ignoring any value specified by the ttp:frameRateMultiplier parameter. If the second of a time expression is 00 and the minute of the time expression is not 00 , 10 , 20 , 30 , 40 , or 50 , then frame codes 00 and 01 are dropped during that second; otherwise, these frame codes are not dropped.

If this parameter's value is dropPAL , then, within any given second of a time expression except the second 00 , frames count from 0 to N−1 , where N is the value specified by the ttp:frameRate parameter, but while ignoring any value specified by the ttp:frameRateMultiplier parameter. If the second of a time expression is 00 and the minute of the time expression is even but not 00 , 20 , or 40 , then frame codes 00 through 03 are dropped during that second; otherwise, these frame codes are not dropped.

If not specified, then nonDrop must be assumed to apply.

A ttp:smpteMode attribute is considered to be significant only when specified on the tt element.

6.2.9 ttp:subFrameRate

The ttp:subFrameRate attribute is used to specify the sub-frame rate of a related media object or the intrinsic sub-frame rate of a document instance in case it is intended to function as an independent media object.

If specified, the value of this attribute must adhere to the following syntax:

ttp:subFrameRate
  : <digit>+                                // value > 0

The sub-frame rate that applies to a document instance is used to interpret time expressions that are expressed in sub-frames as defined by 10.3.1 <timeExpression> .

A sub-frame is interpreted as a division of a frame of media time, such that if the sub-frame rate is specified as S , then a frame of media time is divided into S intervals of equal duration, where each interval is labeled as sub-frame s , with s ∈ [0… S−1 ].

If not specified, the sub-frame rate must be considered to be equal to one (1). If specified, then the sub-frame rate must be greater than zero (0).

A ttp:subFrameRate attribute is considered to be significant only when specified on the tt element.

6.2.10 ttp:tickRate

The ttp:tickRate attribute is used to specify the tick rate of a related media object or the intrinsic tick rate of content of a document instance in case it is intended to function as an independent media object.

If specified, the value of this attribute must adhere to the following syntax:

ttp:tickRate
  : <digit>+                                // value > 0

The tick rate that applies to a document instance is used to interpret time expressions that are expressed in ticks by using the t metric as defined by 10.3.1 <timeExpression> .

A tick is interpreted as an integral division of a second of media time, such that if the tick rate is specified as T , then a second of media time is divided into T intervals of equal duration, where each interval is labeled as tick t , with t ∈ [0… T−1 ].

If not specified, then if a frame rate is specified, the tick rate must be considered to be the effective frame rate multiplied by the sub-frame rate (i.e., ticks are interpreted as sub-frames); or, if no frame rate is specified, the tick rate must be considered to be one (1) tick per second of media time. If specified, then the tick rate must not be zero (0).

A ttp:tickRate attribute is considered to be significant only when specified on the tt element.

6.2.11 ttp:timeBase

The ttp:timeBase attribute is used to specify the temporal coordinate system by means of which time expressions are interpreted in a document instance.

If specified, the value of this attribute must adhere to the following syntax:

ttp:timeBase
  : "media"
  | "smpte"
  | "clock"

If the time base is designated as media , then a time expression denotes a coordinate in some media object's time line, where the media object may be an external media object with which the content of a document instance is to be synchronized, or it may be the content of a document instance itself in a case where the timed text content is intended to establish an independent time line.

If the time base is designated as smpte , then a time expression denotes a [SMPTE 12M] time coordinate with which the content of a document instance is to be synchronized. In this case, the value of the ttp:markerMode and ttp:smpteMode parameters apply, as defined by 6.2.5 ttp:markerMode and 6.2.8 ttp:smpteMode , respectively.

If the time base is designated as clock , then the time expression denotes a coordinate in some real-world time line as established by some real-time clock, such as the local wall-clock time or UTC (Coordinated Universal Time) or GPS (Global Positioning System) time lines.

If not specified, the default time base must be considered to be media .

A ttp:timeBase attribute is considered to be significant only when specified on the tt element.

When operating with either media or smpte time bases, a diachronic presentation of a document instance may be subject to transformations of the controlling time line, such as temporal reversal, dilation (expansion), or constriction (compression); however, when operating with the clock time base, no transformations are permitted, and diachronic presentation proceeds on a linear, monotonically increasing time line based on the passage of real time.

7.1.1 tt

The tt element serves as the root, document element of a document instance.

The tt element accepts as its children zero or one head element followed by zero or one body element.

<tt
  tts:extent = string
  xml:id = ID
  xml:lang = string
  xml:space = (default|preserve) : default
  {}
  {}>

  {any attribute in TT Parameter namespace}
  {any attribute not in default or any TT namespace}>

  Content: head?, body?
</tt>

The temporal beginning and ending of a document instance represented by a tt element is defined in relationship with some external application or presentation context. The temporal interval defined by these points is referred to subsequently as the external time interval .

A document instance has an implicit duration that is equal to the implicit duration of the body element of the document, if present, or zero, if not present.

If the tts:extent attribute is specified on the tt element, then it must adhere to 8.2.8 tts:extent , in which case it specifies the spatial extent of the root container region in which content regions are located and presented. If no tts:extent attribute is specified, then the spatial extent of the root container region is considered to be determined by the external authoring or presentation context.

An xml:lang attribute must be specified on the tt element. If the attribute value is empty, it signifies that there is no default language that applies to the text contained within the document instance.

If no xml:space attribute is specified upon the tt element, then it must be considered as if the attribute had been specified with a value of default .

7.1.2 head

The head element is a container element used to group header matter, including metadata, profile, styling, and layout information.

The head element accepts as its children zero or more elements in the Metadata.class element group, followed by zero or more elements in the Parameters.class element group, followed by zero or one styling element, followed by zero or one layout element.

Any metadata specified by children in the Metadata.class element group applies semantically to the document instance as a whole, and not just the head element.

Any parameters specified by children in the Parameters.class element group applies semantically to the document instance as a whole, and not just the head element.

A styling child element is used to specify style constructs that are referenced from other style constructs, by layout constructs, and by content elements.

A layout child element is used to specify layout constructs that are referenced by content elements.

<head
  xml:id = ID
  xml:lang = string
  )>

  xml:space = (default|preserve)
  {any attribute not in default or any TT namespace}>

  Content: Metadata.class*, Parameters.class*, styling?, layout?
</head>

To the extent that time semantics apply to the content of the head element, the implied time interval of this element is defined to be coterminous with the external time interval.

7.1.3 body

The body element functions as a logical container and a temporal structuring element for a sequence of textual content units represented as logical divisions.

The body element accepts as its children zero or more elements in the Metadata.class element group, followed by zero or more elements in the Animation.class element group, followed by zero or more div elements.

Any metadata specified by children in the Metadata.class element group applies semantically to the body element and its descendants as a whole.

Any animation elements specified by children in the Animation.class element group apply semantically to the body element.

<body
  begin = <timeExpression>
  dur = <timeExpression>
  end = <timeExpression>
  region = IDREF
  style = IDREFS
  timeContainer = (par|seq)
  xml:id = ID
  xml:lang = string
  xml:space = (default|preserve)
  {}
  {}
  {}
  {}
  {}>

  {any attribute in TT Metadata namespace}
  {any attribute in TT Style namespace}
  {any attribute not in default or any TT namespace}>

  Content: Metadata.class*, Animation.class*, div*
</body>

An author may specify a temporal interval for a body element using the begin , dur , and end attributes. If the begin point of this interval remains unspecified, then the begin point is interpreted as the begin point of the external time interval. Similarly, if the end point of this interval remains unspecified, then the end point is interpreted as the end point of the external time interval.

If relative begin or end times are specified on the body element, then these times are resolved by reference to the begin and end time of the external time interval.

If the external time interval is shorter than the computed duration of the body element, then the active time interval of a document instance is truncated to the active end point of the external time interval.

An author may associate a set of style properties with a body element by means of either the style attribute or inline style attributes or a combination thereof.

If no timeContainer attribute is specified on a body element, then it must be interpreted as having parallel time containment semantics.

7.1.4 div

The div element functions as a logical container and a temporal structuring element for a sequence of textual content units represented as logical sub-divisions or paragraphs.

The div element accepts as its children zero or more elements in the Metadata.class element group, followed by zero or more elements in the Animation.class element group, followed by zero or more div or p elements.

Any metadata specified by children in the Metadata.class element group applies semantically to the div element and its descendants as a whole.

Any animation elements specified by children in the Animation.class element group apply semantically to the div element.

<div
  begin = <timeExpression>
  dur = <timeExpression>
  end = <timeExpression>
  region = IDREF
  style = IDREFS
  timeContainer = (par|seq)
  xml:id = ID
  xml:lang = string
  xml:space = (default|preserve)
  {}
  {}
  {}
  {}
  {}>

  {any attribute in TT Metadata namespace}
  {any attribute in TT Style namespace}
  {any attribute not in default or any TT namespace}>

  Content: Metadata.class*, Animation.class*, Block.class*
</div>

An author may associate a set of style properties with a div element by means of either the style attribute or inline style attributes or a combination thereof.

If no timeContainer attribute is specified on a div element, then it must be interpreted as having parallel time containment semantics.

7.1.5 p

A p element represents a logical paragraph, serving as a transition between block level and inline level formatting semantics.

The p element accepts as its children zero or more elements in the Metadata.class element group, followed by zero or more elements in the Animation.class element group, followed by zero or more span element, br element, or text nodes interpreted as anonymous spans.

Any metadata specified by children in the Metadata.class element group applies semantically to the p element and its descendants as a whole.

Any animation elements specified by children in the Animation.class element group apply semantically to the p element.

<p
  begin = <timeExpression>
  dur = <timeExpression>
  end = <timeExpression>
  region = IDREF
  style = IDREFS
  timeContainer = (par|seq)
  xml:id = ID
  xml:lang = string
  xml:space = (default|preserve)
  {}
  {}
  {}
  {}
  {}>

  {any attribute in TT Metadata namespace}
  {any attribute in TT Style namespace}
  {any attribute not in default or any TT namespace}>

  Content: Metadata.class*, Animation.class*, Inline.class*
</p>

An author may associate a set of style properties with a p element by means of either the style attribute or inline style attributes or a combination thereof.

If no timeContainer attribute is specified on a p element, then it must be interpreted as having parallel time containment semantics.

If a sequence of children of a p element consists solely of character information items, then that sequence must be considered to be an anonymous span for the purpose of applying style properties that apply to span elements.

7.1.6 span

The span element functions as a logical container and a temporal structuring element for a sequence of textual content units having inline level formatting semantics.

When presented on a visual medium, a span element is intended to generate a sequence of inline areas, each containing one or more glyph areas.

The span element accepts as its children zero or more elements in the Metadata.class element group, followed by zero or more elements in the Animation.class element group, followed by zero or more span elements , elements, br elements, or text nodes interpreted as anonymous spans.

Any metadata specified by children in the Metadata.class element group applies semantically to the span element and its descendants as a whole.

Any animation elements specified by children in the Animation.class element group apply semantically to the span element.

<span
  begin = <timeExpression>
  dur = <timeExpression>
  end = <timeExpression>
  region = IDREF
  style = IDREFS
  timeContainer = (par|seq)
  xml:id = ID
  xml:lang = string
  xml:space = (default|preserve)
  {}
  {}
  {}
  {}
  {}>

  {any attribute in TT Metadata namespace}
  {any attribute in TT Style namespace}
  {any attribute not in default or any TT namespace}>

  Content: Metadata.class*, Animation.class*, Inline.class*
</span>

An author may associate a set of style properties with a span element by means of either the style attribute or inline style attributes or a combination thereof.

If no timeContainer attribute is specified on a span element, then it must be interpreted as having parallel time containment semantics.

7.1.7 br

The br element denotes an explicit line break.

<br
  style = IDREFS
  xml:id = ID
  xml:lang = string
  xml:space = (default|preserve)
  {}
  {}
  {}
  {}
  {}>

  {any attribute in TT Metadata namespace}
  {any attribute in TT Style namespace}
  {any attribute not in default or any TT namespace}>

  Content: Metadata.class*, Animation.class*
</br>

When presented on a visual medium, the presence of a br element must be interpreted as a forced line break.

7.2.1 xml:id

The xml:id attribute is used as defined by [XML ID] .

The xml:id attribute may be used with any element in the core vocabulary catalog.

7.2.2 xml:lang

The xml:lang attribute is used as defined by [XML 1.0] , §2.12, Language Identification .

The xml:lang attribute must be specified on the tt element and may be specified by an instance of any other element type in the core vocabulary catalog.

7.2.3 xml:space

The xml:space attribute is used as defined by [XML 1.0] , §2.10, White Space Handling .

The xml:space attribute may be used with any element in the core vocabulary catalog.

The semantics of the value default are fixed to mean that when performing presentation processing of a document instance as described by 9.3.3 Synchronic Flow Processing , processing must occur as if the following properties were specified on the affected elements of the intermediate XSL-FO document:

• suppress-at-line-break="auto"

• linefeed-treatment="treat-as-space"

• white-space-collapse="true"

• white-space-treatment="ignore-if-surrounding-linefeed"

Similarly, the semantics of the value preserve are fixed to mean that when performing presentation processing, processing must occur as if the following properties were specified on the affected elements of the intermediate XSL-FO document:

• suppress-at-line-break="retain"

• linefeed-treatment="preserve"

• white-space-collapse="false"

• white-space-treatment="preserve"

When performing other types of processing intended to eventually result in a visual presentation by means other than those described in this specification, the semantics of space collapsing and preservation as described above should be respected. For other types of processing, the treatment of the xml:space attribute is processor dependent, but should respect the semantics described above if possible.

8.1.1 styling

The styling element is a container element used to group styling matter, including metadata that applies to styling matter.

The styling element accepts as its children zero or more elements in the Metadata.class element group, followed by zero or more style elements.

<styling
  xml:id = ID
  xml:lang = string
  xml:space = (default|preserve)
  {}>

  {any attribute not in default or any TT namespace}>

  Content: Metadata.class*, style*
</styling>

To the extent that time semantics apply to the content of the styling element, the implied time interval of this element is defined to be coterminous with the external time interval.

8.1.2 style

The style element is used to define a set of style specifications expressed as a specified style set in accordance with 8.4.4.2 Specified Style Set Processing .

The style element accepts as its children zero or more metadata elements.

<style
  style = IDREFS
  xml:id = ID
  xml:lang = string
  xml:space = (default|preserve)
  {}
  {}
  {}>

  {any attribute in TT Style namespace}
  {any attribute not in default or any TT namespace}>

  Content: Metadata.class*
</style>

If a style element appears as a descendant of a region element, then the style element must be ignored for the purpose of computing referential styles as defined by 8.4.1.2 Referential Styling and 8.4.1.3 Chained Referential Styling .

8.2.1 style

The style attribute is used by referential style association to reference one or more style elements each of which define a specified style set.

The style attribute may be specified by an instance of the following element types:

• body

• div

• p

• region

• span

• style

8.2.2 tts:backgroundColor

The tts:backgroundColor attribute is used to specify a style property that defines the background color of a region or an area generated by content flowed into a region.

This attribute may be specified by any element type that permits use of attributes in the TT Style Namespace; however, this attribute applies as a style property only to those element types indicated in the following table.

For the purpose of determining applicability of this style property, each character child of a p element is considered to be enclosed in an anonymous span.

The tts:backgroundColor style is illustrated by the following example.

<region xml:id="r1">
  <style tts:extent="306px 114px"/>
  <style tts:backgroundColor="red"/>
  <style tts:color="white"/>
  <style tts:displayAlign="after"/>
  <style tts:padding="3px 40px"/>
</region>
...
<p region="r1" tts:backgroundColor="purple" tts:textAlign="center">
  Twinkle, twinkle, little bat!<br/>
  How <span tts:backgroundColor="green">I wonder</span> where you're at!
</p>

Example Rendition – Background Color

8.2.3 tts:color

The tts:color attribute is used to specify a style property that defines the foreground color of marks associated with an area generated by content flowed into a region.

This attribute may be specified by any element type that permits use of attributes in the TT Style Namespace; however, this attribute applies as a style property only to those element types indicated in the following table.

For the purpose of determining applicability of this style property, each character child of a p element is considered to be enclosed in an anonymous span.

The initial value of the tts:color property is considered to be implementation dependent. In the absence of end-user preference information, a conformant presentation processor should use an initial value that is highly contrastive to the background color of the root container region.

The tts:color style is illustrated by the following example.

<region xml:id="r1">
  <style tts:backgroundColor="black"/>
  <style tts:color="white"/>
  <style tts:displayAlign="after"/>
  <style tts:textAlign="center"/>
</region>
...
<p region="r1">
  In spring, when woods are <span tts:color="green">getting green</span>,<br/>
  I'll try and tell you what I mean.
</p>

Example Rendition – Color

8.2.4 tts:direction

The tts:direction attribute is used to specify a style property that defines the directionality of an embedding or override according to the Unicode bidirectional algorithm.

This attribute may be specified by any element type that permits use of attributes in the TT Style Namespace; however, this attribute applies as a style property only to those element types indicated in the following table.

For the purpose of determining applicability of this style property, each character child of a p element is considered to be enclosed in an anonymous span.

If a specified value of this attribute is not supported, then a presentation processor must ignore the attribute.

The tts:direction style is illustrated by the following example.

<region xml:id="r1">
  <style tts:extent="265px 84px"/>
  <style tts:padding="5px"/>
  <style tts:backgroundColor="black"/>
  <style tts:color="white"/>
  <style tts:displayAlign="after"/>
  <style tts:textAlign="center"/>
</region>
...
<p region="r1">
  Little birds are playing<br/>
  Bagpipes on the shore,<br/>
  <span tts:unicodeBidi="bidiOverride" tts:direction="rtl">where the tourists snore.</span>
</p>

Example Rendition – Direction

8.2.5 tts:display

The tts:display attribute is used to specify a style property that defines whether an element is a candidate for layout and composition in a region.

This attribute may be specified by any element type that permits use of attributes in the TT Style Namespace; however, this attribute applies as a style property only to those element types indicated in the following table.

For the purpose of determining applicability of this style property, each character child of a p element is considered to be enclosed in an anonymous span.

If the value of this attribute is auto , then the affected element is a candidate for region layout and presentation; however, if the value is none , then the affected element and its descendants must be considered ineligible for region layout and presentation.

The tts:display style is illustrated by the following example.

<region xml:id="r1">
  <style tts:extent="369px 119px"/>
  <style tts:backgroundColor="black"/>
  <style tts:color="white"/>
  <style tts:displayAlign="before"/>
  <style tts:textAlign="start"/>
</region>
...
<div region="r1">
  <p dur="5s">
    [[[
    <span tts:display="none">
      <set begin="1s" dur="1s" tts:display="auto"/>
      Beautiful soup,
    </span>
    <span tts:display="none">
      <set begin="2s" dur="1s" tts:display="auto"/>
      so rich and green,
    </span>
    <span tts:display="none">
      <set begin="3s" dur="1s" tts:display="auto"/>
      waiting in a hot tureen!
    </span>
    ]]]
  </p>
</div>

Example Rendition – Display

8.2.6 tts:displayAlign

The tts:displayAlign attribute is used to specify a style property that defines the alignment of block areas in the block progression direction.

This attribute may be specified by any element type that permits use of attributes in the TT Style Namespace; however, this attribute applies as a style property only to those element types indicated in the following table.

If a specified value of this attribute is not supported, then a presentation processor must interpret the attribute as if the value before were specified.

The tts:displayAlign style is illustrated by the following example.

<region xml:id="r1">
  <style tts:extent="128px 66px"/>
  <style tts:origin="0px 0px"/>
  <style tts:backgroundColor="black"/>
  <style tts:color="white"/>
  <style tts:displayAlign="before"/>
  <style tts:textAlign="start"/>
</region>
<region xml:id="r2">
  <style tts:extent="192px 66px"/>
  <style tts:origin="128px 66px"/>
  <style tts:backgroundColor="green"/>
  <style tts:color="white"/>
  <style tts:displayAlign="after"/>
  <style tts:textAlign="start"/>
</region>
<region xml:id="r3">
  <style tts:extent="128px 66px"/>
  <style tts:origin="0px 132px"/>
  <style tts:backgroundColor="black"/>
  <style tts:color="white"/>
  <style tts:displayAlign="before"/>
  <style tts:textAlign="start"/>
</region>
<region xml:id="r4">
  <style tts:extent="192px 66px"/>
  <style tts:origin="128px 198px"/>
  <style tts:backgroundColor="green"/>
  <style tts:color="white"/>
  <style tts:displayAlign="after"/>
  <style tts:textAlign="start"/>
</region>
...
<div>
  <p region="r1">I sent a message to the fish:</p>
  <p region="r2">I told them<br/> "This is what I wish."</p>
  <p region="r3">The little fishes of the sea,</p>
  <p region="r4">They sent an<br/> answer back to me.</p>
</div>

Example Rendition – Display Align

8.2.7 tts:dynamicFlow

The tts:dynamicFlow attribute is used to specify a style property that defines how to dynamically flow content into and out of a region over some time interval.

This style property applies only to a region when the tts:overflow property for that region has the value dynamic .

This attribute may be specified by any element type that permits use of attributes in the TT Style Namespace; however, this attribute applies as a style property only to those element types indicated in the following table.

If the value of this attribute is none , then no dynamic flow semantics apply.

If the value of this attribute is rollUp , then this value is interpreted as a shorthand value equivalent to out(line,smooth) inter(0.433s) clear(0.433s) .

If the value of this attribute contains a single <flowFunction> , then that flow function applies equally to fill into and clear from dynamic flow operations.

If either intra() fill() or inter() clear() <flowIntervalFunction> is not specified, then the auto value for the missing <flowIntervalFunction> applies. Multiple instances of the same <flowIntervalFunction> must not appear in the value of this attribute.

The normative processing model for dynamic flow behavior is specified in B Dynamic Flow Processing Model .

If a specified value of this attribute is not supported, then a presentation processor must interpret the attribute as if the value none were specified.

The tts:dynamicFlow style is illustrated by the following example, and depicted in an SVG Animation .

<region xml:id="r1">
  <style tts:extent="140px 70px"/>
  <style tts:displayAlign="after"/>
  <style tts:backgroundColor="transparent"/>
  <style tts:fontFamily="proportionalSansSerif"/>
  <style tts:fontSize="18px"/>
  <style tts:overflow="dynamic"/>
  <style />

  <style tts:dynamicFlow="in(word,jump) fill(1.0s) out(line,smooth) clear(0.3s)"/>

</region>
...
<p region="r1">
  <span tts:backgroundColor="black" tts:color="white">
    Five o'clock tea!<br/>
    Ever to thee,<br/>
    Faithful I'll be,<br/>
    Five o'clock tea!<br/>
    <br/>
    <br/>
    <br/>
  </span>
</p>

Example Rendition – Dynamic Flow – Discrete Frames

8.2.8 tts:extent

The tts:extent attribute is used to specify the width and height of a region area (which may be the root container region).

This attribute may be specified by any element type that permits use of attributes in the TT Style Namespace; however, this attribute applies as a style property only to those element types indicated in the following table.

If the value of this attribute consists of two <length> specifications, then they must be interpreted as width and height , where the first specification is the width , and the second specification is the height .

If the value of this attribute is auto , then the initial value of the style property must be considered to be the same as the root container extent.

The root container extent is determined either by a tts:extent specified on the tt element, if present, or by the external authoring context, if not present. If tts:extent is specified on the tt element, then the width and height must be expressed in terms of two <length> specifications, and these specifications must be expressed as non-percentage, definite lengths using pixel units.

If a specified value of this attribute is not supported, then a presentation processor must interpret the attribute as if the value auto were specified.

The tts:extent style is illustrated by the following example.

<region xml:id="r1">
  <style tts:extent="330px 122px"/>
  <style tts:backgroundColor="black"/>
  <style tts:color="white"/>
  <style tts:displayAlign="after"/>
  <style tts:textAlign="center"/>
</region>
...
<p region="r1">
  'Tis the voice of the Lobster:<br/>
  I heard him declare,<br/>
  "You have baked me too brown,<br/>
  I must sugar my hair."
</p>

Example Rendition – Extent

8.2.9 tts:fontFamily

The tts:fontFamily attribute is used to specify a style property that defines the font family from which glyphs are selected for glyph areas generated by content flowed into a region.

This attribute may be specified by any element type that permits use of attributes in the TT Style Namespace; however, this attribute applies as a style property only to those element types indicated in the following table.

For the purpose of determining applicability of this style property, each character child of a p element is considered to be enclosed in an anonymous span.

If a specified font family is not available, then a presentation processor must attempt to map the specified font family to an available font family that has similar typographic characteristics, or, in the absence of such a mapping, it must interpret the font family as if the value default were specified.

The tts:fontFamily style is illustrated by the following example.

<region xml:id="r1">
  <style tts:extent="474px 146px"/>
  <style tts:backgroundColor="black"/>
  <style tts:color="white"/>
  <style tts:displayAlign="center"/>
  <style tts:textAlign="start"/>
  <style tts:fontFamily="proportionalSansSerif"/>
</region>
...
<div region="r1">
  <p>
    "The time has come," the Walrus said,<br/>
    "to talk of many things:
  </p>
  <p tts:textAlign="end" tts:fontFamily="monospaceSerif">
    Of shoes, and ships, and sealing wax,<br/>
    Of cabbages and kings,
  </p>
  <p>
    And why the sea is boiling hot,<br/>
    and whether pigs have wings."
  </p>
</div>

Example Rendition – Font Family

8.2.10 tts:fontSize

The tts:fontSize attribute is used to specify a style property that defines the font size for glyphs that are selected for glyph areas generated by content flowed into a region, where font size is interpreted as a scaling transform to the font's design EM square.

This attribute may be specified by any element type that permits use of attributes in the TT Style Namespace; however, this attribute applies as a style property only to those element types indicated in the following table.

If a single <length> value is specified, then this length applies equally to horizontal and vertical scaling of a glyph's EM square; if two <length> values are specified, then the first expresses the horizontal scaling and the second expresses vertical scaling.

If horizontal and vertical sizes are expressed independently, then the metrics of the <length> values must be the same.

The <length> value(s) used to express font size must be non-negative.

For the purpose of determining applicability of this style property, each character child of a p element is considered to be enclosed in an anonymous span.

If a specified value of this attribute is not supported, then a presentation processor must interpret the attribute as if the value 1c were specified.

The tts:fontSize style is illustrated by the following example.

<region xml:id="r1">
  <style tts:extent="299px 97px"/>
  <style tts:backgroundColor="black"/>
  <style tts:color="white"/>
  <style tts:displayAlign="center"/>
  <style tts:textAlign="center"/>
  <style tts:fontFamily="proportionalSansSerif"/>
  <style tts:fontSize="18px"/>
</region>
...
<p region="r1">
  Then fill up the glasses<br/>
  with treacle and ink,<br/>
  Or anything else<br/>
  that is <span tts:fontSize="24px">pleasant</span> to drink.
</p>

Example Rendition – Font Size

8.2.11 tts:fontStyle

The tts:fontStyle attribute is used to specify a style property that defines the font style to apply to glyphs that are selected for glyph areas generated by content flowed into a region, where the mapping from font style value to specific font face or style parameterization is not determined by this specification.

This attribute may be specified by any element type that permits use of attributes in the TT Style Namespace; however, this attribute applies as a style property only to those element types indicated in the following table.

For the purpose of determining applicability of this style property, each character child of a p element is considered to be enclosed in an anonymous span.

Use of values oblique and reverseOblique denote a shear and reverse shear transformation (at an unspecified angle) in the inline progression dimension.

If a specified font style is not available, then a presentation processor must attempt to map the specified font style to an available font style that has similar typographic characteristics, or, in the absence of such a mapping, it must interpret the font style as if the value normal were specified.

The tts:fontStyle style is illustrated by the following example.

<region xml:id="r1">
  <style tts:extent="331px 84px"/>
  <style tts:backgroundColor="black"/>
  <style tts:color="white"/>
  <style tts:displayAlign="after"/>
  <style tts:textAlign="center"/>
  <style tts:fontFamily="proportionalSansSerif"/>
</region>
...
<p region="r1">
  In autumn, when the leaves are brown,<br/>
  Take pen and ink, and <span tts:fontStyle="italic">write it down.</span>
</p>

Example Rendition – Font Style

8.2.12 tts:fontWeight

The tts:fontWeight attribute is used to specify a style property that defines the font weight to apply to glyphs that are selected for glyph areas generated by content flowed into a region, where the mapping from font weight value to specific font face or weight parameterization is not determined by this specification.

This attribute may be specified by any element type that permits use of attributes in the TT Style Namespace; however, this attribute applies as a style property only to those element types indicated in the following table.

For the purpose of determining applicability of this style property, each character child of a p element is considered to be enclosed in an anonymous span.

If a specified font weight is not available, then a presentation processor must attempt to map the specified font weight to an available font weight that has similar typographic characteristics, or, in the absence of such a mapping, it must interpret the font weight as if the value normal were specified.

The tts:fontWeight style is illustrated by the following example.

<region xml:id="r1">
  <style tts:extent="376px 95px"/>
  <style tts:backgroundColor="black"/>
  <style tts:color="white"/>
  <style tts:displayAlign="center"/>
  <style tts:textAlign="center"/>
  <style tts:fontFamily="proportionalSansSerif"/>
</region>
...
<p region="r1">
  They told me you had been to her,<br/>
  <span tts:fontWeight="bold">and mentioned me to him:</span><br/>
  She gave me a good character<br/>
  <span tts:fontWeight="bold">but said I could not swim.</span>
</p>

Example Rendition – Font Weight

8.2.13 tts:lineHeight

The tts:lineHeight attribute is used to specify a style property that defines the inter-baseline separation between line areas generated by content flowed into a region.

This attribute may be specified by any element type that permits use of attributes in the TT Style Namespace; however, this attribute applies as a style property only to those element types indicated in the following table.

If the value of this attribute is normal , then the initial value of the style property must be considered to be the same as the largest font size that applies to any descendant element.

If specified as a <length> , then the length must be non-negative.

If a specified value of this attribute is not supported, then a presentation processor must interpret the attribute as if the value normal were specified.

The tts:lineHeight style is illustrated by the following example.

<region xml:id="r1">
  <style tts:extent="255px 190px"/>
  <style tts:backgroundColor="black"/>
  <style tts:color="white"/>
  <style tts:displayAlign="center"/>
  <style tts:textAlign="start"/>
  <style tts:fontFamily="proportionalSansSerif"/>
  <style tts:fontSize="16px"/>
  <style tts:lineHeight="32px"/>
</region>
...
<p region="r1">
  He thought he saw an elephant,<br/>
  That practised on a fife:<br/>
  He looked again, and found it was<br/>
  A letter from his wife.<br/>
  "At length I realise," he said,<br/>
  "The bitterness of Life.
"</p>

Example Rendition – Line Height

8.2.14 tts:opacity

The tts:opacity attribute is used to specify a style property that defines the opacity (or transparency) of marks associated with a region.

When presented onto a visual medium, the opacity of the region is applied uniformly and on a linear scale to all marks produced by content targeted to the region.

This attribute may be specified by any element type that permits use of attributes in the TT Style Namespace; however, this attribute applies as a style property only to those element types indicated in the following table.

An <alpha> value greater than 1.0 must be considered equivalent to an <alpha> value of 1.0.

The tts:opacity style is illustrated by the following example.

<region xml:id="r1" dur="5s">
  <set begin="0s" dur="1s" tts:opacity="1.00"/>
  <set begin="1s" dur="1s" tts:opacity="0.75"/>
  <set begin="2s" dur="1s" tts:opacity="0.50"/>
  <set begin="3s" dur="1s" tts:opacity="0.25"/>
  <set begin="4s" dur="1s" tts:opacity="0.00"/>
  <style tts:extent="304px 77px"/>
  <style tts:backgroundColor="black"/>
  <style tts:color="white"/>
  <style tts:displayAlign="after"/>
  <style tts:textAlign="center"/>
</region>
...
<p region="r1">
  The sun was shining on the sea
</p>

Example Rendition – Opacity

8.2.15 tts:origin

The tts:origin attribute is used to specify the x and y coordinates of the origin of a region area with respect to the origin of the root container extent, if specified, or the external authoring context, if not specified.

This attribute may be specified by any element type that permits use of attributes in the TT Style Namespace; however, this attribute applies as a style property only to those element types indicated in the following table.

If the value of this attribute consists of two <length> specifications, then they must be interpreted as x and y coordinates, where the first specification is the x coordinate, and the second specification is the y coordinate.

If the value of this attribute is auto , then the initial value of the style property must be considered to be the same as the root container origin. The root container origin is determined by the external authoring context.

If a specified value of this attribute is not supported, then a presentation processor must interpret the attribute as if the value auto were specified.

The tts:origin style is illustrated by the following example.

<region xml:id="r1">
  <style tts:origin="40px 40px"/>
  <style tts:extent="308px 92px"/>
  <style tts:backgroundColor="black"/>
  <style tts:color="white"/>
  <style tts:displayAlign="center"/>
  <style tts:textAlign="center"/>
</region>
...
<p region="r1">
  "To dine!" she shrieked in dragon-wrath.<br/>
  "To swallow wines all foam and froth!<br/>
   To simper at a table-cloth!"
</p>

Example Rendition – Origin

8.2.16 tts:overflow

The tts:overflow attribute is used to specify a style property that defines whether a region area is clipped or not if the descendant areas of the region overflow its extent.

This attribute may be specified by any element type that permits use of attributes in the TT Style Namespace; however, this attribute applies as a style property only to those element types indicated in the following table.

If the value of this attribute is visible , then content should not be clipped outside of the affected region, and region composition and layout must be performed as if the region's width and height were unconstrained, but with a well-defined origin. If the value is hidden or dynamic , then content should be clipped outside of the affected region.

If the value of this attribute is dynamic , then content is dynamically flowed into and out of the affected region according to the values of the tts:dynamicFlow style property; in this case, the semantics of the tts:dynamicFlow apply whether or not the affected region has overflowed.

If a specified value of this attribute is not supported, then a presentation processor must interpret the attribute as if the value hidden were specified.

The tts:overflow style is illustrated by the following example.

<region xml:id="r1">
  <style tts:extent="232px 40px"/>
  <style tts:origin="0px 0px"/>
  <style tts:backgroundColor="black"/>
  <style tts:color="red"/>
  <style tts:displayAlign="before"/>
  <style tts:textAlign="start"/>
  <style tts:fontFamily="proportionalSansSerif"/>
  <style tts:fontSize="18px"/>
  <style tts:wrapOption="noWrap"/>
  <style tts:overflow="visible"/>
</region>
<region xml:id="r2">
  <style tts:extent="232px 40px"/>
  <style tts:origin="0px 43px"/>
  <style tts:backgroundColor="black"/>
  <style tts:color="red"/>
  <style tts:displayAlign="before"/>
  <style tts:textAlign="start"/>
  <style tts:fontFamily="proportionalSansSerif"/>
  <style tts:fontSize="18px"/>
  <style tts:wrapOption="noWrap"/>
  <style tts:overflow="hidden"/>
</region>
...
<p region="r1">
  "But wait a bit," the Oysters cried,<br/>
  "Before we have our chat;
</p>
<p region="r2">
  For some of us are out of breath,<br/>
  And all of us are fat!"
</p>

Example Rendition – Overflow

8.2.17 tts:padding

The tts:padding attribute is used to specify padding (or inset) space on all sides of a region area.

This attribute may be specified by any element type that permits use of attributes in the TT Style Namespace; however, this attribute applies as a style property only to those element types indicated in the following table.

If the value of this attribute consists of one <length> specification, then that length applies to all edges of the affected areas. If the value consists of two <length> specifications, then the first applies to the before and after edges, and the second applies to the start and end edges. If three <length> specifications are provided, then the first applies to the before edge, the second applies to the start and end edges, and the third applies to the after edge. If four <length> specifications are provided, then they apply to before, end, after, and start edges, respectively.

If a specified value of this attribute is not supported, then a presentation processor must interpret the attribute as if the value 0px were specified.

The tts:padding style is illustrated by the following example.

<region xml:id="r1">
  <style tts:extent="446px 104px"/>
  <style tts:backgroundColor="black"/>
  <style tts:color="white"/>
  <style tts:displayAlign="after"/>
  <style tts:textAlign="center"/>
  <style tts:padding="10px 40px"/>
</region>
...
<p region="r1" tts:backgroundColor="red">
  Just the place for a Snark! I have said it twice:<br/>
  That alone should encourage the crew.<br/>
  Just the place for a Snark! I have said it thrice:<br/>
  What I tell you three times is true.
</p>

When rendering an area to which padding applies, the background color that applies to the area is rendered into the padded portion of the area.

Example Rendition – Padding

8.2.18 tts:showBackground

The tts:showBackground attribute is used to specify constraints on when the background color of a region is intended to be presented.

This attribute may be specified by any element type that permits use of attributes in the TT Style Namespace; however, this attribute applies as a style property only to those element types indicated in the following table.

If the value of this attribute is always , then the background color of a region is always rendered when performing presentation processing on a visual medium; if the value is whenActive , then the background color of a region is rendered only when some content is selected into the region.

If a specified value of this attribute is not supported, then a presentation processor must interpret the attribute as if the value always were specified.

The tts:showBackground style is illustrated by the following example.

<region xml:id="r1">
  <style tts:origin="0px 0px"/>
  <style tts:extent="265px 100px"/>
  <style tts:backgroundColor="black"/>
  <style tts:showBackground="always"/>
  <style tts:color="white"/>
  <style tts:displayAlign="before"/>
  <style tts:textAlign="start"/>
</region>
<region xml:id="r2">
  <style tts:origin="205px 60px"/>
  <style tts:extent="290px 100px"/>
  <style tts:backgroundColor="red"/>
  <style tts:color="white"/>
  <style tts:displayAlign="before"/>
  <style tts:textAlign="end"/>
  <style tts:showBackground="whenActive"/>
</region>

8.2.19 tts:textAlign

The tts:textAlign attribute is used to specify a style property that defines how inline areas are aligned within a containing block area in the inline progression direction.

This attribute may be specified by any element type that permits use of attributes in the TT Style Namespace; however, this attribute applies as a style property only to those element types indicated in the following table.

If a specified value of this attribute is not supported, then a presentation processor must interpret the attribute as if the value start were specified.

The tts:textAlign style is illustrated by the following example.

<region xml:id="r1">
  <style tts:extent="355px 43px"/>
  <style tts:origin="0px 0px"/>
  <style tts:backgroundColor="black"/>
  <style tts:color="white"/>
  <style tts:textAlign="start"/>
</region>
<region xml:id="r2">
  <style tts:extent="355px 43px"/>
  <style tts:origin="0px 47px"/>
  <style tts:backgroundColor="black"/>
  <style tts:color="white"/>
  <style tts:textAlign="end"/>
</region>
...
<p region="r1">
  Beware the Jabberwock, my son!<br/>
  The jaws that bite, the claws that catch!
</p>
<p region="r2">
  Beware the Jubjub bird, and shun<br/>
  The frumious Bandersnatch!
</p>

Example Rendition – Text Align

8.2.20 tts:textDecoration

The tts:textDecoration attribute is used to specify a style property that defines a text decoration effect to apply to glyph areas or other inline areas that are generated by content flowed into a region.

This attribute may be specified by any element type that permits use of attributes in the TT Style Namespace; however, this attribute applies as a style property only to those element types indicated in the following table.

For the purpose of determining applicability of this style property, each character child of a p element is considered to be enclosed in an anonymous span.

If a specified value of this attribute is not supported, then a presentation processor must interpret the attribute as if the value none were specified.

The tts:textDecoration style is illustrated by the following example.

<region xml:id="r1">
  <style tts:extent="385px 82px"/>
  <style tts:origin="0px 0px"/>
  <style tts:backgroundColor="black"/>
  <style tts:color="white"/>
  <style tts:padding="5px 2px"/>
  <style tts:textDecoration="underline"/>
</region>
...
<p region="r1">
  The sea was wet<span tts:textDecoration="noUnderline"> as </span>wet
  <span tts:textDecoration="noUnderline">
    could be,<br/>
    The sand was dry as dry.<br/>
    <span tts:textDecoration="lineThrough">There weren't any</span>
    You <span tts:textDecoration="lineThrough">couldn't</span>
    could not see a cloud<br/>
    Because no cloud was in the sky.
  </span>
</p>

Example Rendition – Text Decoration

8.2.21 tts:textOutline

The tts:textOutline attribute is used to specify a style property that defines a text outline effect to apply to glyphs that are selected for glyph areas generated by content flowed into a region.

This attribute may be specified by any element type that permits use of attributes in the TT Style Namespace; however, this attribute applies as a style property only to those element types indicated in the following table.

For the purpose of determining applicability of this style property, each character child of a p element is considered to be enclosed in an anonymous span.

The value of this attribute consists of an optional <color> term followed by one or two <length> terms. If a color term is present, then it denotes the outline color; if no color term is present, the computed value of the tts:color applies. The first length term denotes the outline thickness and the second length term, if present, indicates the blur radius.

If a specified value of this attribute is not supported, then a presentation processor must interpret the attribute as if the value none were specified.

The tts:textOutline style is illustrated by the following example.

<region xml:id="r1">
  <style tts:backgroundColor="transparent"/>
  <style tts:color="yellow"/>
  <style tts:textOutline="black 2px 0px"/>
  <style tts:fontFamily="proportionalSansSerif"/>
  <style tts:fontSize="24px"/>
</region>
...
<p>
  How doth the little crocodile<br/>
  Improve its shining tail,<br/>
  And pour the waters of the Nile<br/>
  On every golden scale!<br/>
  How cheerfully he seems to grin,<br/>
  How neatly spreads his claws,<br/>
  And welcomes little fishes in,<br/>
  With gently smiling jaws!
</p>

Example Rendition – Text Outline

8.2.22 tts:unicodeBidi

The tts:unicodeBidi attribute is used to specify a style property that defines a directional embedding or override according to the Unicode bidirectional algorithm.

This attribute may be specified by any element type that permits use of attributes in the TT Style Namespace; however, this attribute applies as a style property only to those element types indicated in the following table.

For the purpose of determining applicability of this style property, each character child of a p element is considered to be enclosed in an anonymous span.

If a specified value of this attribute is not supported, then a presentation processor must interpret the attribute as if the value normal were specified.

The tts:unicodeBidi style is illustrated by the following example.

<region xml:id="r1">
  <style tts:extent="265px 84px"/>
  <style tts:padding="5px"/>
  <style tts:backgroundColor="black"/>
  <style tts:color="white"/>
  <style tts:displayAlign="after"/>
  <style tts:textAlign="center"/>
</region>
...
<p region="r1">
  Little birds are playing<br/>
  Bagpipes on the shore,<br/>
  <span tts:unicodeBidi="bidiOverride" tts:direction="rtl">where the tourists snore.</span>
</p>

Example Rendition – Unicode Bidirectionality

8.2.23 tts:visibility

The tts:visibility attribute is used to specify a style property that defines whether generated areas are visible or not when rendered on a visual presentation medium.

This attribute may be specified by any element type that permits use of attributes in the TT Style Namespace; however, this attribute applies as a style property only to those element types indicated in the following table.

For the purpose of determining applicability of this style property, each character child of a p element is considered to be enclosed in an anonymous span.

The tts:visibility style has no affect on content layout or composition, but merely determines whether composed content is visible or not.

If a specified value of this attribute is not supported, then a presentation processor must interpret the attribute as if the value visible were specified.

The tts:visibility style is illustrated by the following example.

<region xml:id="r1">
  <style tts:extent="398px 121px"/>
  <style tts:backgroundColor="black"/>
  <style tts:color="white"/>
  <style/>
</region>
...
<p region="r1" dur="4s">
  <span tts:visibility="hidden">
    <set begin="1s" tts:visibility="visible"/>
    Curiouser
  </span>
  <span tts:visibility="hidden">
    <set begin="2s" tts:visibility="visible"/>
    and
  </span>
  <span tts:visibility="hidden">
    <set begin="3s" tts:visibility="visible"/>
    curiouser!
  </span>
</p>

Example Rendition – Visibility

8.2.24 tts:wrapOption

The tts:wrapOption attribute is used to specify a style property that defines whether or not automatic line wrapping (breaking) applies within the context of the affected element.

This attribute may be specified by any element type that permits use of attributes in the TT Style Namespace; however, this attribute applies as a style property only to those element types indicated in the following table.

For the purpose of determining applicability of this style property, each character child of a p element is considered to be enclosed in an anonymous span.

If a specified value of this attribute is not supported, then a presentation processor must interpret the attribute as if the value wrap were specified.

The tts:wrapOption style is illustrated by the following example.

<region xml:id="r1">
  <style tts:extent="192px 117px"/>
  <style tts:backgroundColor="black"/>
  <style tts:color="white"/>
  <style tts:displayAlign="after"/>
  <style tts:overflow="hidden"/>
  <style tts:wrapOption="noWrap"/>
</region>
...
<p>
  I'll tell thee everything I can:<br/>
  There's little to relate.<br/>
  I saw an aged aged man,<br/>
  A-sitting on a gate.
</p>

Example Rendition – Wrap Option

8.2.25 tts:writingMode

The tts:writingMode attribute is used to specify a style property that defines the block and inline progression directions to be used for the purpose of stacking block and inline areas within a region area.

This attribute may be specified by any element type that permits use of attributes in the TT Style Namespace; however, this attribute applies as a style property only to those element types indicated in the following table.

If a specified value of this attribute is not supported, then a presentation processor must interpret the attribute as if the value lrtb were specified.

The tts:writingMode style is illustrated by the following example.

<region xml:id="r1">
  <style tts:extent="50px 570px"/>
  <style tts:origin="0px 0px"/>
  <style tts:padding="10px 3px"/>
  <style tts:backgroundColor="black"/>
  <style tts:color="white"/>
  <style tts:writingMode="tbrl"/>
</region>
<region xml:id="r2">
  <style tts:extent="310px 50px"/>
  <style tts:origin="70px 120px"/>
  <style tts:padding="10px 3px"/>
  <style tts:backgroundColor="black"/>
  <style tts:color="white"/>
  <style tts:writingMode="rltb"/>
</region>
...
<p region="r1">
  I sometimes dig for buttered rolls,<br/>
  Or set limed twigs for crabs:
</p>
<p region="r2" tts:direction="rtl" tts:unicodeBidi="bidiOverride">
  I sometimes search the grassy knolls for the wheels of Hansom-cabs.
</p>

Example Rendition – Writing Mode

8.2.26 tts:zIndex

The tts:zIndex attribute is used to specify a style property that defines the front-to-back ordering of region areas in the case that they overlap.

This attribute may be specified by any element type that permits use of attributes in the TT Style Namespace; however, this attribute applies as a style property only to those element types indicated in the following table.

If two areas are associated with the same Z-index value, then, if those areas overlap in space, the area(s) generated by lexically subsequent elements must be rendered over area(s) generated by lexically prior elements, where lexical order is defined as the postorder traversal of a document instance.

The semantics of the value auto are those defined by [XSL 1.1] , § 7.28.9, where the tt element is considered to establish the root stacking context.

If a specified value of this attribute is not supported, then a presentation processor must interpret the attribute as if the value auto were specified.

The tts:zIndex style is illustrated by the following example.

<region xml:id="r1">
  <style tts:origin="0px 0px"/>
  <style tts:extent="400px 100px"/>
  <style tts:padding="5px"/>
  <style tts:backgroundColor="black"/>
  <style tts:color="white"/>
  <style tts:zIndex="0"/>
</region>
<region xml:id="r2">
  <style tts:origin="100px 60px"/>
  <style tts:extent="400px 100px"/>
  <style tts:padding="5px"/>
  <style tts:backgroundColor="red"/>
  <style tts:color="white"/>
  <style tts:textAlign="end"/>
  <style tts:zIndex="1"/>
</region>
<region xml:id="r3">
  <style tts:origin="0px 120px"/>
  <style tts:extent="400px 100px"/>
  <style tts:padding="5px"/>
  <style tts:backgroundColor="black"/>
  <style tts:color="white"/>
  <style tts:zIndex="2"/>
</region>
<region xml:id="r4">
  <style tts:origin="100px 180px"/>
  <style tts:extent="400px 100px"/>
  <style tts:padding="5px"/>
  <style tts:backgroundColor="red"/>
  <style tts:color="white"/>
  <style tts:textAlign="end"/>
  <style tts:zIndex="3"/>
</region>
...
<p region="r1">
  I passed by his garden, and marked, with one eye,<br/>
  How the Owl and the Panther were sharing a pie.
</p>
<p region="r2">
  The Panther took pie-crust, and gravy, and meat,<br/>
  While the Owl had the dish as its share of the treat.
</p>
<p region="r3">
  When the pie was all finished, the Owl, as a boon,<br/>
  Was kindly permitted to pocket the spoon:
</p>
<p region="r4">
  While the Panther received knife and fork<br/>
  with a growl,<br/>
  And concluded the banquet by...
</p>

Example Rendition – Z Index

8.3.1 <alpha>

An <alpha> expression is used to express an opacity value, where 0 means fully transparent and 1 means fully opaque.

<alpha>
  : float

In the above syntax representation, the syntactic element float must adhere to the lexical representation defined by [XML Schema Part 2]  § 3.2.4.1. If the value represented is less than 0.0, then it must be interpreted as equal to 0.0; similarly, if the value represented is greater than 1.0, then it must be interpreted as 1.0.

If a presentation processor does not support a specific, valid opacity value, then it must interpret it as being equal to the closest supported value.

8.3.2 <color>

A <color> expression is used to specify a named color, exact RGB color triple, or exact RGBA color tuple, where the alpha component, if expressed, is maximum (255) at 100% opacity and minimum (0) at 0% opacity, and where the applicable color space is defined by [SRGB] .

<color>
  : "#" rrggbb
  | "#" rrggbbaa
  | "rgb" "(" r-value "," g-value "," b-value ")"
  | "rgba" "(" r-value "," g-value "," b-value "," a-value ")"
  | <namedColor>
rrggbb
  :  <hexDigit>{6}
rrggbbaa
  :  <hexDigit>{8}
r-value | g-value | b-value | a-value
  : component-value
component-value
  : non-negative-integer                    // valid range: [0,255]
non-negative-integer
  : <digit>+

When expressing RGB component values, these values are considered to not be premultiplied by alpha.

For the purpose of performing presentation processing such that non-opaque or non-transparent alpha or opacity values apply, then the semantics of compositing functions are defined with respect to the use of the [SRGB] color space for both inputs and outputs of the composition function.

If a presentation processor does not support a specific, valid color or alpha value, then it must interpret it as being equal to the closest supported value.

8.3.3 <digit>

A <digit> is used to express integers and other types of numbers or tokens.

<digit>
  : "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9"

8.3.4 <duration>

A <duration> expression is used to express a temporal duration value.

<duration>
  : <digit>+ ( "." <digit>+ )? metric
metric
  : "s"                 // seconds
  | "ms"                // milliseconds
  | "f"                 // frames
  | "t"                 // ticks

It is an error to omit the metric component of a duration.

When operating with smpte time base and discontinuous mode, a duration expression must be considered to denote a duration in (local) real-time, independently of the governing time base.

8.3.5 <familyName>

A <familyName> expression specifies a font family name.

If the name contains a quotation delimiter character, then it must be expressed as a <quotedString>. If the name contains a whitespace character, then it should be expressed as a <quotedString>; however, if it is expressed as a <string>, then it must not contain a COMMA ',' character.

<familyName>
  : <string>
  | <quotedString>

8.3.6 <flowFunction>

A <flowFunction> expression specifies a unit of content to be dynamic flowed into and out of a region according to an optional dynamic flow style.

<flowFunction>
  : "in(" flowArguments ")"
  | "out(" flowArguments ")"
flowArguments
  : flowUnit [ "," flowStyle ]
flowUnit
  : "glyph"
  | "inline"

  | "line"
  | "block"

  | "character"
  | "word"
  | extensionToken
flowStyle
  : "jump"
  | "smooth"
  | extensionTokenextensionToken

  | extensionToken
extensionToken

  : "x-" <token>

Dynamic flow can be specified independently for flowing content into its region and flowing it out of its region. These two phases of dynamic flow are specified using the in() and out() flow functions respectively.

Dynamic flow occurs on the basis of specific visual or semantic content units. In the case of glyph , inline , line , and block line , the unit of dynamic flow is based upon a visually rendered construct ( glyph ) or upon an area of the area tree produced by formatting the affected content. In the case of character and word , the unit of dynamic flow is based upon a semantic unit associated with one or more visually rendered or area units.

The dynamic flow unit word must be interpreted as being dependent upon the language or writing system of the affected content. If the language or writing system is unknown or unspecified, then word is interpreted as follows:

1. If the affected content consists solely or mostly of Unified CJK Ideographic characters or of characters of another Unicode character block that are afforded similar treatment to that of Unified CJK Ideographic characters, then word is to be interpreted as if character were specified.

2. Otherwise, word is to be interpreted as denoting a sequence of one or more characters that are not interpreted as an XML whitespace character.

When a flow unit is flowed into or out of its region, the manner by which the unit is flowed is controlled by the optional flowStyle argument of the relevant flow function. If the flow style is specified as jump , or if no flow style is specified, then the flow unit is instantaneously transitioned into, within, or out of the region. If the flow style is smooth , then the flow unit is smoothly transitioned by means of pixel based exposure, movement, or hiding, respectively.

If a presentation processor that supports dynamic flow does not the smooth flow style, then this flow style must be interpreted as if the jump flow style were specified.

8.3.7 <flowIntervalFunction>

A <flowIntervalFunction> expression specifies an interval or duration that affects dynamic flow timing behavior.

<flowIntervalFunction>
  : "intra(" flowIntervalArguments ")"
  | "inter(" flowIntervalArguments ")"

  : "fill(" flowIntervalArguments ")"
  | "clear(" flowIntervalArguments ")"

flowIntervalArguments
  : "auto"
  | <duration>
  | flowIntervalRate
flowIntervalRate
  : <digit>+ ( "." <digit>+ )?

The intra() fill() flow interval function is used to determine the computed fill interval state parameter for performing dynamic flow processing, which expresses the duration of time between fill timer events, as specified by B.5.1 Fill Timer , which in turn, limits the dynamic flowed content fill rate.

The inter() clear() flow interval function is used to determine the computed clear interval state parameter for performing dynamic flow processing, which expresses the duration of time between clear timer events, as specified by B.5.2 Clear Timer , which in turn, limits the dynamic flowed content retention period.

If a <duration> is specified as an argument to a flow interval function, then it is considered to represent a definite duration . If a flow interval rate is specified as an argument to a flow interval function, then it is considered to represent a definite rate in units per second, where the applicable unit is determined in the context of whether the rate is used with an intra() fill() or inter() clear() flow interval function.

The computed fill and clear interval values are defined by B.3 Flow Interval Timing Calculation .

8.3.8 <genericFamilyName>

A <genericFamilyName> expression specifies a font family using a general token that indicates a class of font families.

The resolution of a generic family name to a concrete font instance is considered to be implementation dependent, both in the case of content authoring and content interpretation.

<genericFamilyName>
  : "default"
  | "monospace"
  | "sansSerif"
  | "serif"
  | "monospaceSansSerif"
  | "monospaceSerif"
  | "proportionalSansSerif"
  | "proportionalSerif"

The mapping between a generic (font) family name and an actual font is not determined by this specification; however, the distinction of monospace versus proportional and serif versus sans-serif should be maintained if possible when performing presentation.

If a generic (font) family name of monospace is specified, then it may be interpreted as equivalent to either monospaceSansSerif or monospaceSerif . The generic family names sansSerif and serif are to be interpreted as equivalent to proportionalSansSerif and proportionalSerif , respectively.

If the generic family name default is specified (or implied by an initial value), then its typographic characteristics is considered to be implementation dependent; however, it is recommended that this default font family be mapped to an monospaced, sans-serif font.

8.3.9 <hexDigit>

A <hexDigit> is used to express integers and other types of numbers or tokens that employ base 16 arithmetic.

For the purpose of parsing, no distinction must be made between lower and upper case.

<hexDigit>
  : <digit>
  | "a" | "b" | "c" | "d" | "e" | "f"
  | "A" | "B" | "C" | "D" | "E" | "F"

8.3.10 <integer>

An <integer> expression is used to express an arbitrary, signed integral value.

<integer>
  : ( "+" | "-" )? <digit>+

8.3.11 <length>

A <length> expression is used to express either a coordinate component of point in a cartesian space or a distance between two points in a cartesian space.

<length>
  : scalar
  | percentage
scalar
  : number units
percentage
  : number "%"
sign
  : "+" | "-"
number
  : sign? non-negative-number
non-negative-number
  : non-negative-integer
  | non-negative-real
non-negative-integer
  : <digit>+
non-negative-real
  : <digit>* "." <digit>+
units
  : "px"
  | "em"
  | "c"                                     // abbreviation of "cell"

It is an error to omit the units component of a scalar length value.

The semantics of the unit of measure px (pixel) are as defined by [XSL 1.1] , § 5.9.13.

When specified relative to a font whose size is expressed as a single length measure or as two length measures of equal length, the unit of measure em is considered to be identical to that defined by [XSL 1.1] , § 5.9.13; however, when specified relative to a font whose size is expressed as two length measures of non-equal lengths, then one em is equal to the inline progression dimension of the anisomorphically scaled font when used to specify lengths in the inline progression direction and equal to the block progression dimension of the scaled font when used to specify lengths in the block progression direction.

The semantics of the unit of measure c (cell) are defined by the parameter 6.2.1 ttp:cellResolution .

8.3.12 <namedColor>

A <namedColor> is used to express an RGBA color with a convenient name, and where the applicable color space is defined by [SRGB] .

For the purpose of parsing, no distinction must be made between lower and upper case.

<namedColor>
  : "transparent"                           // #00000000
  | "black"                                 // #000000ff
  | "silver"                                // #c0c0c0ff
  | "gray"                                  // #808080ff
  | "white"                                 // #ffffffff
  | "maroon"                                // #800000ff
  | "red"                                   // #ff0000ff
  | "purple"                                // #800080ff
  | "fuchsia"                               // #ff00ffff
  | "magenta"                               // #ff00ffff (= fuchsia)
  | "green"                                 // #008000ff
  | "lime"                                  // #00ff00ff
  | "olive"                                 // #808000ff
  | "yellow"                                // #ffff00ff
  | "navy"                                  // #000080ff
  | "blue"                                  // #0000ffff
  | "teal"                                  // #008080ff
  | "aqua"                                  // #00ffffff
  | "cyan"                                  // #00ffffff (= aqua)

8.3.13 <quotedString>

A <quotedString> is used to express a delimited string that may contain a whitespace or a quotation delimiter character. Two types of quotation delimiters are provided in order to accommodate strings that contain the other delimiter.

<quotedString>
  : "\"" ( char - { "\"" } )* "\""
  | "\'" ( char - { "\'" } )* "\'"

In the above syntax representation, the syntactic element char must adhere to production [2] Char as defined by [XML 1.0]  § 2.2.

8.3.14 <string>

A <string> expression consists of a sequence of characters where no character is a quotation delimiter character.

<string>
  : ( char - { "\"" | "\'" } )+

In the above syntax representation, the syntactic element char must adhere to production [2] Char as defined by [XML 1.0]  § 2.2.

8.4.1 Style Association

Style association is a sub-process of 8.4.4 Style Resolution Processing used to determine the specified style set of each content and layout element.

Style matter may be associated with content and layout matter in a number of ways:

• inline styling

• referential styling

• chained referential styling

In addition to the above, style matter may be associated with layout matter using:

• nested styling

<p tts:color="white">White 1 <span tts:color="yellow">Yellow</span> White 2</p>

<style xml:id="s1" tts:color="white"/>
<style xml:id="s2" tts:color="yellow"/>
...
<p style="s1">White 1 <span style="s2">Yellow</span> White 2</p>

<style xml:id="s1" tts:color="white" tts:fontFamily="monospaceSerif"/>
<style xml:id="s2" style="s1" tts:color="yellow"/>
...
<p style="s1">White Monospace</p>
<p style="s2">Yellow Monospace</p>

<region xml:id="r1">
  <style tts:extent="128px 66px"/>
  <style tts:origin="0px 0px"/>
  <style tts:displayAlign="center"/>
</region>

8.4.2 Style Inheritance

Style inheritance is a sub-process of 8.4.4 Style Resolution Processing used to determine the specified style set of each content and layout element.

Styles are further propagated to content matter using:

• content style inheritance

• region style inheritance

For the purpose of determining inherited styles, the element hierarchy of an intermediate synchronic document form of a DFXP document instance must be used, where such intermediate forms are defined by 9.3.2 Intermediate Synchronic Document Construction .

<p tts:fontFamily="monospaceSansSerif">
  <span tts:color="yellow">Yellow Monospace</span>
</p>

<region xml:id="r1">
  <style tts:color="yellow"/>
  <style tts:fontFamily="monospaceSerif"/>
</region>
...
<p region="r1">Yellow Monospace</p>

8.4.3 Style Resolution Value Categories

During style resolution, layout, and presentation processing, three categories of style property values are distinguished as follows:

• specified values

• computed values

• actual values

8.4.4 Style Resolution Processing

The process of style resolution is defined herein as the procedure (and results thereof) for resolving (determining) the computed values of all style properties that apply to content and layout elements:

• 8.4.4.1 Conceptual Definitions

• 8.4.4.2 Specified Style Set Processing

• 8.4.4.3 Computed Style Set Processing

• 8.4.4.4 Style Resolution Process

The process described here forms an integral sub-process of 9.3 Region Layout and Presentation .

9.1.1 layout

The layout element is a container element used to group layout matter, including metadata that applies to layout matter.

The layout element accepts as its children zero or more elements in the Metadata.class element group, followed by zero or more region elements.

<layout
  xml:id = ID
  xml:lang = string
  xml:space = (default|preserve)
  {}>

  {any attribute not in default or any TT namespace}>

  Content: Metadata.class*, region*
</layout>

To the extent that time semantics apply to the content of the layout element, the implied time interval of this element is defined to be coterminous with the external time interval.

9.1.2 region

The region element is used to define a space or area into which content is to be flowed for the purpose of presentation.

In addition, and in accordance with 8.4.2.2 Region Style Inheritance , the region element may be used to specify inheritable style properties to be inherited by content that is flowed into it.

The region element accepts as its children zero or more elements in the Metadata.class element group, followed by zero or more elements in the Animation.class element group, followed by zero or more style elements.

Any metadata specified by children in the Metadata.class element group applies semantically to the region element and its descendants as a whole. Any animation elements specified by children in the Animation.class element group apply semantically to the region element. Any style child element must be considered a local style definition that applies only to the containing region element, i.e., does not apply for resolving referential styling.

<region
  begin = <timeExpression>
  dur = <timeExpression>
  end = <timeExpression>
  style = IDREFS
  timeContainer = (par|seq)
  ttm:role = string
  xml:id = ID
  xml:lang = string
  xml:space = (default|preserve)
  {}
  {}
  {}>

  {any attribute in TT Style namespace}
  {any attribute not in default or any TT namespace}>

  Content: Metadata.class*, Animation.class*, style*
</region>

If begin and (or) end attributes are specified on a region element, then they specify the beginning and (or) ending points of a time interval during which the region is eligible for activation and with respect to which animation child elements of the region are timed. If specified, these begin and end points are relative to the time interval of the nearest ancestor element associated with a time interval, irregardless of whether that interval is explicit or implied.

The nearest ancestor element of a region element that is associated with a time interval is the document instance's root tt element.

If a dur attribute is specified on the region element, then it specifies the simple duration of the region.

For the purpose of determining the semantics of presentation processing, a region that is temporally inactive must not produce any visible marks when presented on a visual medium.

If no timeContainer attribute is specified on a region element, then it must be interpreted as having parallel time containment semantics.

If a ttm:role attribute is specified on a region element, then it must adhere to the value syntax defined by Syntax Representation – ttm:role , and where the role(s) identified by this attribute expresses the semantic role(s) of the region independently from the semantic role(s) of any content targeted to (associated with) the region.

9.2.1 region

The region attribute is used to reference a region element which defines a space or area into which a content element is intended to be flowed.

The region attribute may be specified by an instance of the following element types:

• body

• div

• p

• span

9.3.1 Default Region

If a DFXP document instance does not specify a region element, then a default region is implied with the following characteristics:

• the identify identity of the default region is consider considered to be anonymous;

• the extent of the default region is the same as the root container region;

• the temporal interval of the default region is the same as temporal interval of the document instance;

Furthermore, if no region element was specified, then the region attribute must not be specified on any content element in the document instance.

If a default region is implied for a given document instance, then the body element is implicitly targeted to (associated with) the default region.

When implying a default region, the document instance is to be treated as if a region element and its parent layout element were specified in a head element, and a matching region attribute were specified on the body element as shown in the following example:

<tt xml:lang="" xmlns="http://www.w3.org/2006/10/ttaf1">
  <head>
    <layout>
      <region xml:id="anonymous"/>
    </layout>
  </head>
  <body region="anonymous"/>
</tt>

9.3.2 Intermediate Synchronic Document Construction

For the purposes of performing presentation processing, the active time duration of a document instance is divided into a sequence of time coordinates where at each time coordinate, some element becomes temporally active or inactive, then, at each such time coordinate, a document instance is mapped from its original, source form, DOC _source , to an intermediate synchronic document form, DOC _inter , as follows:

1. for each temporally active region R , replicate the sub-tree of DOC _source headed by the body element;

2. evaluating this sub-tree in a postorder traversal, prune elements if they are not a content element, if they are temporally inactive, if they are empty, or if they aren't associated with region R ;

3. if the pruned sub-tree is non-empty, then reparent it to the R element;

4. finally, after completing the above steps, prune the original body element from the intermediate document, then prune all region , begin , end , and dur attributes, which are no longer semantically relevant;

A content element is associated with a region according to the following ordered rules, where the first rule satisfied is used and remaining rules are skipped:

1. if the element specifies a region attribute, then the element is associated with the region referenced by that attribute;

2. if some ancestor of that element specifies a region attribute, then the element is associated with the region referenced by the most immediate ancestor that specifies this attribute;

3. if the element contains a descendant element that specifies a region attribute, then the element is associated with the region referenced by that attribute;

4. if a default region was implied (due to the absence of any region element), then the element is associated with the default region region;

5. the element is not associated with any region region.

The pseudo-code shown in Example – Content Hierarchy Region Mapping provides one possible algorithm that implements these processing steps.

PREPARE-CONTENT ( D ) := 
  foreach R in SELECT ( D, "/tt/head/layout/region" )
    if TEMPORALLY-ACTIVE? ( R )
      APPEND-CHILDREN ( R, SELECT ( D, "/tt/body" ) )
      foreach E in POSTORDER-TRAVERSE ( R )
        
          

        if ! CONTENT-ELEMENT? ( E ) or ! TEMPORALLY-ACTIVE? ( E ) or EMPTY? ( E ) or REGION-OF ( E ) != R
            then PRUNE ( E )
  PRUNE ( SELECT ( D, "/tt/body" ) )
  PRUNE ( SELECT ( D, "//*/@region" ) )
  PRUNE ( SELECT ( D, "//*/@begin" ) )
  PRUNE ( SELECT ( D, "//*/@end" ) )
  PRUNE ( SELECT ( D, "//*/@dur" ) )
 
REGION-OF ( E ) :=
  if NULL? ( E )
    return NULL
  else if HAS-ATTRIBUTE? ( E, "region" )
    return VALUE-OF-ATTRIBUTE ( E, "region" )
  else
    return REGION-OF ( PARENT-OF ( E ) )

The result of performing the processing described above will be a sequence of N intermediate synchronic document instances, DOC _{inter 0} … DOC _{inter N−1} .

9.3.3 Synchronic Flow Processing

Subsequent to performing a temporal (synchronic) slice and subsequent remapping of regionally selected content hierarchy, the resulting intermediate synchronic document is subjected to a flow transformation step that produces a rooted flow object tree represented as an XSL FO document instance as defined by [XSL 1.1] , and semantically extended by TT AF specific style properties that have no XSL FO counterpart.

Each intermediate synchronic document produced by 9.3.2 Intermediate Synchronic Document Construction is mapped to an XSL FO document instance, F , as follows:

1. perform the following ordered sub-steps to create anonymous spans:

   1. for each significant text node in a content element, synthesize an anonymous span to enclose the text node, substituting the new anonymous span for the original text node child in its sibling and parent hierarchy;

   2. for each contiguous sequence of anonymous spans, replace the sequence with a single anonymous span which contains a sequence of text nodes representing the individual text node children of the original sequence of anonymous spans;

   3. for each span element whose child is a single anonymous span, replace the anonymous span with its sequence of child text nodes;

2. resolve styles according to 8.4.4.4 Style Resolution Process ;

3. map the tt element to an fo:root element, populated initially with an fo:layout-master-set element that contains a valid fo:simple-page-master that, in turn, contains an fo:region-body child, where the root container extent expressed on the tt element is mapped to page-width and page-height attributes on the fo:simple-page-master element;

4. map the layout element to an fo:page-sequence element and a child fo:flow element that reference the page master and page region defined by the simple page master produced above;

5. map each non-empty region element to an fo:block-container element with an absolute-position attribute with value absolute , and where the region's position and extent are mapped to equivalent top , left , width , and height attributes;

6. for each body , div , and p element that is not associated with a tts:display style property with the value none , map the element to a distinct fo:block element, populating the style properties of fo:block by using the computed style set associated with each original TT AF content element;

7. for the resulting fo:block formatting object produced in the previous step that corresponds to the body element, synthesize and append to the end of its children an empty fo:block with the following attributes: space-after.optimum , space-after.maximum , and space-after.conditionality , where the value of the former two attributes is the height or width of the containing fo:block-container element, whichever of these is designated as the block progression dimension, and where the value of the last is retain ;

8. for each span element that is not associated with a tts:display style property with the value none and for each anonymous span that is a child of a p or span element, map the element or sequence of character items to a distinct fo:inline element, populating the style properties of fo:inline by using the computed style set associated with each original TT AF content element or anonymous span;

9. for each br element that is not associated with a tts:display style property with the value none , map the element to a distinct fo:character element having the following properties:

   • character="
"

   • suppress-at-line-break="retain"

10. for each TT AF style property attribute in some computed style set that has no counterpart in [XSL 1.1] , map that attribute directly through to the relevant formatting object produced by the input TT AF content element to which the style property applies;

11. optionally, synthesize a unique id attribute on each resulting formatting object element that relates that element to the input element that resulted in that formatting object element;

For each resulting XSL FO document instance DOC _FO , if processing requires presentation on a visual medium, then apply the formatting semantics prescribed by [XSL 1.1] in order to produce an XSL FO area tree that may then be subsequently rendered onto the visual medium.

9.3.4 Elaborated Example

An example of the processing steps described above is elaborated below, starting with Example – Sample Source Document .

<tt tts:extent="640px 480px" xml:lang="en"
  xmlns="http://www.w3.org/2006/10/ttaf1"
  xmlns:tts="http://www.w3.org/2006/10/ttaf1#styling">
  <head>
    <layout>
      <region xml:id="r1">
        <style tts:origin="10px 100px"/>
        <style tts:extent="620px 96px"/>
        <style tts:fontSize="40px"/>
        <style tts:fontWeight="bold"/>
        <style tts:backgroundColor="black"/>
        <style tts:color="red"/>
        <style tts:textAlign="center"/>
        <style tts:displayAlign="center"/>
      </region>
      <region xml:id="r2">
        <style tts:origin="10px 300px"/>
        <style tts:extent="620px 96px"/>
        <style tts:fontSize="40px"/>
        <style tts:fontWeight="bold"/>
        <style tts:backgroundColor="black"/>
        <style tts:color="yellow"/>
        <style tts:textAlign="center"/>
        <style tts:displayAlign="center"/>
      </region>
    </layout>
  </head>
  <body xml:id="b1">
    <div xml:id="d1" begin="0s" dur="2s">
      <p xml:id="p1" region="r1">Text 1</p>
      <p xml:id="p2" region="r2">Text 2</p>
    </div>
    <div xml:id="d2" begin="1s" dur="2s">
      <p xml:id="p3" region="r2">Text 3</p>
      <p xml:id="p4" region="r1">Text 4</p>
    </div>
  </body>
</tt>

In the above document, the content hierarchy consists of two divisions, each containing two paragraphs. This content is targeted (selected into) one of two non-overlapping regions that are styled identically except for their position and their foreground colors, the latter of which is inherited by and applies to the (and, in this case, anonymous) spans reparented into the regions.

The following, first intermediate document shows the synchronic state at time interval [0,1), during which time only division d1 is temporally active, and where paragraphs p1 and p2 (and their ancestors) are selected into regions r1 and r2 , respectively.

<tt tts:extent="640px 480px" xml:lang="en"
  xmlns="http://www.w3.org/2006/10/ttaf1"
  xmlns:tts="http://www.w3.org/2006/10/ttaf1#styling">
  <head>
    <layout>
      <region xml:id="r1">
        <style tts:origin="10px 100px"/>
        <style tts:extent="620px 96px"/>
        <style tts:fontSize="40px"/>
        <style tts:fontWeight="bold"/>
        <style tts:backgroundColor="black"/>
        <style tts:color="red"/>
        <style tts:textAlign="center"/>
        <style tts:displayAlign="center"/>
        <body xml:id="b1-1">
          <div xml:id="d1-1">
            <p xml:id="p1">Text 1</p>
          </div>
        </body>
      </region>
      <region xml:id="r2">
        <style tts:origin="10px 300px"/>
        <style tts:extent="620px 96px"/>
        <style tts:fontSize="40px"/>
        <style tts:fontWeight="bold"/>
        <style tts:backgroundColor="black"/>
        <style tts:color="yellow"/>
        <style tts:textAlign="center"/>
        <style tts:displayAlign="center"/>
        <body xml:id="b1-2">
          <div xml:id="d1-2">
            <p xml:id="p2">Text 2</p>
          </div>
        </body>
      </region>
    </layout>
  </head>
</tt>

An XSL FO document instance produced by performing flow processing upon the first intermediate document is shown below.

<fo:root xmlns:fo="http://www.w3.org/1999/XSL/Format">
  <fo:layout-master-set>
    <fo:simple-page-master master-name="m1"
      page-width="640px" page-height="480px">
      <fo:region-body/>
    </fo:simple-page-master>
  </fo:layout-master-set>
  <fo:page-sequence master-reference="m1">
    <fo:flow flow-name="xsl-region-body">
      <!-- region (r1) -->
      <fo:block-container id="r1" absolute-position="absolute"
        left="10px" top="100px" width="620px" height="96px"
        background-color="black" display-align="center">
        <!-- body (b1) -->
        <fo:block id="b1-1">
          <!-- div (d1) -->
          <fo:block id="d1-1">
            <!-- p (p1) -->
            <fo:block id="p1" text-align="center">
              <fo:inline font-size="40px" font-weight="bold"
              color="red">Text 1</fo:inline>
            </fo:block>
          </fo:block>
          <!-- body's space filler ->
          <fo:block
            space-after.optimum="96px"
            space-after.maximum="96px"
            space-after.conditionality="retain"/>
        </fo:block>
      </fo:block-container>
      <!-- region (r2) -->
      <fo:block-container id="r2" absolute-position="absolute"
        left="10px" top="300px" width="620px" height="96px"
        background-color="black" display-align="center">
        <!-- body (b1) -->
        <fo:block id="b1-2">
          <!-- div (d1) -->
          <fo:block id="d1-2">
            <!-- p (p2) -->
            <fo:block id="p2" text-align="center">
              <fo:inline font-size="40px" font-weight="bold"
              color="yellow">Text 2</fo:inline>
            </fo:block>
          </fo:block>
          <!-- body's space filler ->
          <fo:block
            space-after.optimum="96px"
            space-after.maximum="96px"
            space-after.conditionality="retain"/>
        </fo:block>
      </fo:block-container>
    </fo:flow>
  </fo:page-sequence>
</fo:root>

The following, second intermediate document shows the synchronic state at time interval [1,2), at which time both divisions d1 and d2 are temporally active, and where paragraphs p1 and p4 (and their ancestors) are selected into region r1 and paragraphs p2 and p3 (and their ancestors) are selected into region r2 .

<tt tts:extent="640px 480px" xml:lang="en"
  xmlns="http://www.w3.org/2006/10/ttaf1"
  xmlns:tts="http://www.w3.org/2006/10/ttaf1#styling">
  <head>
    <layout>
      <region xml:id="r1">
        <style tts:origin="10px 100px"/>
        <style tts:extent="620px 96px"/>
        <style tts:fontSize="40px"/>
        <style tts:fontWeight="bold"/>
        <style tts:backgroundColor="black"/>
        <style tts:color="red"/>
        <style tts:textAlign="center"/>
        <style tts:displayAlign="center"/>
        <body xml:id="b1-1">
          <div xml:id="d1-1">
            <p xml:id="p1">Text 1</p>
          </div>
          <div xml:id="d2-1">
            <p xml:id="p4">Text 4</p>
          </div>
        </body>
      </region>
      <region xml:id="r2">
        <style tts:origin="10px 300px"/>
        <style tts:extent="620px 96px"/>
        <style tts:fontSize="40px"/>
        <style tts:fontWeight="bold"/>
        <style tts:backgroundColor="black"/>
        <style tts:color="yellow"/>
        <style tts:textAlign="center"/>
        <style tts:displayAlign="center"/>
        <body xml:id="b1-2">
          <div xml:id="d1-2">
            <p xml:id="p2">Text 2</p>
          </div>
          <div xml:id="d2-2">
            <p xml:id="p3">Text 3</p>
          </div>
        </body>
      </region>
    </layout>
  </head>
</tt>

The following, third intermediate document shows the synchronic state at time interval [2,3), at which time only division d2 is temporally active, and where paragraphs p4 and p3 (and their ancestors) are selected into regions r1 and r2 , respectively.

<tt tts:extent="640px 480px" xml:lang="en"
  xmlns="http://www.w3.org/2006/10/ttaf1"
  xmlns:tts="http://www.w3.org/2006/10/ttaf1#styling">
  <head>
    <layout>
      <region xml:id="r1">
        <style tts:origin="10px 100px"/>
        <style tts:extent="620px 96px"/>
        <style tts:fontSize="40px"/>
        <style tts:fontWeight="bold"/>
        <style tts:backgroundColor="black"/>
        <style tts:color="red"/>
        <style tts:textAlign="center"/>
        <style tts:displayAlign="center"/>
        <body xml:id="b1-1">
          <div xml:id="d2-1">
            <p xml:id="p4">Text 4</p>
          </div>
        </body>
      </region>
      <region xml:id="r2">
        <style tts:origin="10px 300px"/>
        <style tts:extent="620px 96px"/>
        <style tts:fontSize="40px"/>
        <style tts:fontWeight="bold"/>
        <style tts:backgroundColor="black"/>
        <style tts:color="yellow"/>
        <style tts:textAlign="center"/>
        <style tts:displayAlign="center"/>
        <body xml:id="b1-2">
          <div xml:id="d2-2">
            <p xml:id="p3">Text 3</p>
          </div>
        </body>
      </region>
    </layout>
  </head>
</tt>

10.2.1 begin

The begin attribute is used to specify the begin point of a temporal interval associated with a timed element. If specified, the value of a begin attribute must adhere to a <timeExpression> specification as defined by 10.3.1 <timeExpression> .

The begin point of a temporal interval is included in the interval; i.e., the interval is left-wise closed.

The semantics of the begin attribute are those defined by [SMIL 2.1] , § 10.4.1, while taking into account any overriding semantics defined by this specification.

10.2.2 end

The end attribute is used to specify the ending point of a temporal interval associated with a timed element. If specified, the value of an end attribute must adhere to a <timeExpression> specification as defined by 10.3.1 <timeExpression> .

The ending point of a temporal interval is not included in the interval; i.e., the interval is right-wise open.

The presentation effects of a non-empty active temporal interval include the frame immediately prior to the frame (or tick) equal to or immediately following the time specified by the ending point, but do not extend into this latter frame (or tick).

The semantics of the end attribute are those defined by [SMIL 2.1] , § 10.4.1, while taking into account any overriding semantics defined by this specification.

10.2.3 dur

The dur attribute is used to specify the duration of a temporal interval associated with a timed element. If specified, the value of a dur attribute must adhere to a <timeExpression> specification as defined by 10.3.1 <timeExpression> .

The semantics of the dur attribute are those defined by [SMIL 2.1] , § 10.4.1, while taking into account any overriding semantics defined by this specification.

10.2.4 timeContainer

The timeContainer attribute is used to specify a local temporal context by means of which timed child elements are temporally situated.

If specified, the value of a timeContainer attribute must be one of the following:

• par

• seq

If the time container semantics of an element instance is par , then the temporal intervals of child elements are considered to apply in parallel, i.e., simultaneously in time. Furthermore, the specification of the time interval of each child element is considered to be relative to the temporal interval of the container element instance.

If the time container semantics of an element instance is seq , then the temporal intervals of child elements are considered to apply in sequence, i.e., sequentially in time. Furthermore, the specification of the time interval of each child element is considered to be relative to the temporal interval of its sibling elements, unless it is the first child element, in which case it is considered to be relative to the temporal interval of the container element instance.

Each time container is considered to constitute an independent time base, i.e., time coordinate system.

If a timeContainer attribute is not specified on an element that has time container semantics, then par time container semantics must apply.

Time container semantics applies only to the following element types:

• body

• div

• p

• region

• span

The semantics of parallel and sequential time containment are those defined by [SMIL 2.1] , § 10.3.2, while taking into account any overriding semantics defined by this specification.

10.3.1 <timeExpression>

A <timeExpression> is used to specify a coordinate along some time base, where the applicable time base is determined by the ttp:timeBase parameter.

<timeExpression>
  : clock-time
  | offset-time
clock-time
  : hours ":" minutes ":" seconds ( fraction | ":" frames ( "." sub-frames )? )?
offset-time
  : time-count fraction? metric
hours
  : <digit> <digit>
  | <digit> <digit> <digit>+
minutes | seconds
  : <digit> <digit>
frames
  : <digit> <digit>
  | <digit> <digit> <digit>+
sub-frames
  : <digit>+
fraction
  : "." <digit>+
time-count
  : <digit>+
metric
  : "h"                 // hours
  | "m"                 // minutes
  | "s"                 // seconds
  | "ms"                // milliseconds
  | "f"                 // frames
  | "t"                 // ticks

If a <timeExpression> is expressed in terms of a clock-time , then leading zeroes are used when expressing hours, minutes, seconds, and frames less than 10. Minutes are constrained to the range [0…59], while seconds are constrained to [0…60], where the value 60 applies only to leap seconds.

If a <timeExpression> is expressed in terms of a clock-time and a frames term is specified, then the value of this term must be constrained to the interval [0… F-1 ], where F is the frame rate determined by the the ttp:frameRate parameter as defined by 6.2.3 ttp:frameRate .

If a <timeExpression> is expressed in terms of a clock-time and a sub-frames term is specified, then the value of this term must be constrained to the interval [0… S-1 ], where S is the sub-frame rate determined by the the ttp:subFrameRate parameter as defined by 6.2.9 ttp:subFrameRate .

11.1.1 set

The set element is used as a child element of a content element or a region element in order to express a discrete change of some style parameter value that applies over some time interval.

The set element accepts as its children zero or more elements in the Metadata.class element group.

<set
  begin = <timeExpression>
  dur = <timeExpression>
  end = <timeExpression>
  xml:id = ID
  xml:lang = string
  xml:space = (default|preserve)
  {}
  {}>

  {a single attribute in TT Style namespace}
  {any attribute not in default or any TT namespace}>

  Content: Metadata.class*
</set>

An example of using the set element to animate content styling is illustrated below:

...
<p dur="5s" tts:color="yellow">
<set begin="1s" dur="1s" tts:color="red"/>
<set begin="2s" dur="1s" tts:color="green"/>
<set begin="3s" dur="1s" tts:color="red"/>
Text with Flashing Colors!
</p>
...

An example of using the set element to animate region styling is illustrated below:

<tt xml:lang="" xmlns="http://www.w3.org/2006/10/ttaf1"
    xmlns:ttp="http://www.w3.org/2006/10/ttaf1#parameter"
    xmlns:tts="http://www.w3.org/2006/10/ttaf1#styling"
    ttp:cellResolution="40 16">
    <head>
      <layout>
        <region xml:id="r1" timeContainer="seq">
          <set dur="10s" tts:origin=" 8c 14c"/>
          <set dur="2s"  tts:origin=" 2c  2c"/>
          <set dur="3s"  tts:origin=" 8c 14c"/>
          <set dur="2s"  tts:origin="14c  4c"/>
          <set dur="10s" tts:origin=" 8c 14c"/>
          <style tts:extent="24c 2c"/>
        </region>
      </layout>
    </head>
    <body region="r1">...</body>
</tt>

12.1.1 metadata

The metadata element functions as a generic container for metadata information.

Metadata information may be expressed by a metadata element in one of two (non-mutually exclusive) manners: (1) by specifying one or more metadata attributes on the metadata element, and (2) by specifying one or more child elements in the metadata element that express metadata. Both types of metadata are referred to in this document as metadata items .

<metadata
  xml:id = ID
  xml:lang = string
  xml:space = (default|preserve)
  {}
  {}
  {}>
  }*

  {any attribute in TT Metadata namespace}
  {any attribute not in default or any TT namespace}>
  Content: ({any element in TT Metadata namespace}|{any element not in any TT namespace})*
</metadata>

The use of document metadata is illustrated by the following example.

...
<head>
  <metadata xmlns:ttm="http://www.w3.org/2006/10/ttaf1#metadata">
    <ttm:title>Document Metadata Example</ttm:title>
    <ttm:desc>This document employs document metadata.</ttm:desc>
  </metadata>
</head>
...

The use of element metadata is illustrated by the following example.

...
<div>
  <metadata xmlns:ttm="http://www.w3.org/2006/10/ttaf1#metadata">
    <ttm:title>Chapter 6 – Sherlock Holmes Gives a Demonstration</ttm:title>
    <ttm:desc>Holmes shows Watson how the murderer entered the window.</ttm:desc>
  </metadata>
</div>
...

The use of metadata attribute items is illustrated by the following example.

...
<div xmlns:ext="http://foo.bar.example.org/ttaf1#metadata">
  <metadata ext:ednote="remove this division prior to publishing"/>
</div>
...

12.1.2 ttm:title

The ttm:title element is used to express a human-readable title of a specific element instance.

<ttm:title
  xml:id = ID
  xml:lang = string
  xml:space = (default|preserve)
  {}>

  {any attribute not in default or any TT namespace}>

  Content: #PCDATA
</ttm:title>

Examples of the ttm:name element are shown above in Example Fragment – Document Metadata and Example Fragment – Element Metadata .

12.1.3 ttm:desc

The ttm:desc element is used to express a human-readable description of a specific element instance.

<ttm:desc
  xml:id = ID
  xml:lang = string
  xml:space = (default|preserve)
  {}>

  {any attribute not in default or any TT namespace}>

  Content: #PCDATA
</ttm:desc>

Examples of the ttm:desc element are shown above in Example Fragment – Document Metadata and Example Fragment – Element Metadata .

12.1.4 ttm:copyright

The ttm:copyright element is used to express a human-readable copyright that applies to some scoping level.

A copyright statement that applies to a document as a whole should appear as a child of the head element.

<ttm:copyright
  xml:id = ID
  xml:lang = string
  xml:space = (default|preserve)
  {}>

  {any attribute not in default or any TT namespace}>

  Content: #PCDATA
</ttm:copyright>

12.1.5 ttm:agent

The ttm:agent element is used to define an agent for the purpose of associating content information with an agent who is involved in the production or expression of that content.

The ttm:agent element accepts as its children zero or more ttm:name elements followed by zero or one ttm:actor element.

At least one ttm:name element child should be specified that expresses a name for the agent, whether it be the name of a person, character, group, or organization.

<ttm:agent
  type = (person|character|group|organization|other)
  xml:id = ID
  xml:lang = string
  xml:space = (default|preserve)
  {}>

  {any attribute not in default or any TT namespace}>

  Content: ttm:name*, ttm:actor?
</ttm:agent>

A type attribute must be specified on each ttm:agent element, and, if specified, must have one of the following values:

• person

• character

• group

• organization

• other

If the value of the type attribute is character , then the ttm:agent element instance should specify a ttm:actor child that specifies the agent that plays the role of the actor.

A ttm:agent metadata item is considered to be significant only when specified as a child of the head element or as a child of a metadata element child of the head element.

The use of agent metadata is illustrated by the following example.

<tt xml:lang="en" xmlns="http://www.w3.org/2006/10/ttaf1" xmlns:ttm="http://www.w3.org/2006/10/ttaf1#metadata">
  <head>
    <ttm:agent xml:id="connery" type="person">
      <ttm:name type="family">Connery</ttm:name>
      <ttm:name type="given">Thomas Sean</ttm:name>
      <ttm:name type="alias">Sean</ttm:name>
      <ttm:name type="full">Sir Thomas Sean Connery</ttm:name>
    </ttm:agent>
    <ttm:agent xml:id="bond" type="character">
      <ttm:name type="family">Bond</ttm:name>
      <ttm:name type="given">James</ttm:name>
      <ttm:name type="alias">007</ttm:name>
      <ttm:actor agent="connery"/>
    </ttm:agent>
  </head>
  <body>
    <div>
      ...  
      <p ttm:agent="bond">I travel, a sort of licensed troubleshooter.</p>
      ...  
    </div>
  </body>
</tt>

12.1.6 ttm:name

The ttm:name element is used to specify a name of a person, character, group, or organization.

<ttm:name
  type = (full|family|given|alias|other)
  xml:id = ID
  xml:lang = string
  xml:space = (default|preserve)
  {}>

  {any attribute not in default or any TT namespace}>

  Content: #PCDATA
</ttm:name>

A type attribute must be specified on each ttm:name element, and, if specified, must have one of the following values:

• full

• family

• given

• alias

• other

The relationship between the type of a name and the syntactic expression of the name is not defined by this specification.

Two examples of the ttm:name element are shown above in Example Fragment – Agent Metadata .

12.1.7 ttm:actor

The ttm:actor element is used to link the definition of a (role-based) character agent with another agent that portrays the character.

<ttm:actor
  agent = IDREF
  xml:id = ID
  xml:lang = string
  xml:space = (default|preserve)
  {}>

  {any attribute not in default or any TT namespace}>

  Content: EMPTY
</ttm:actor>

The agent attribute of a ttm:actor element must reference a ttm:agent element that denotes the person, group, or organization acting the part of a character.

An example of the ttm:actor element is shown above in Example Fragment – Agent Metadata .

12.2.1 ttm:agent

The ttm:agent attribute takes an IDREFS value, and is used with certain content elements to designate the agents that perform or are involved in the performance of the content.

If specified, a ttm:agent attribute must reference ttm:agent element instances that appear as a descendent of the same document instance as that of the referring element.

An example of the ttm:agent attribute is shown above in Example Fragment – Agent Metadata .

12.2.2 ttm:role

The ttm:role attribute may be used by a content author to express the roles, functions, or characteristics of some content element that is so labeled.

If specified, the value of this attribute must adhere to the following syntax, where the syntactic element S must adhere to production [3] S as defined by [XML 1.0]  § 2.3:

ttm:role
  role ( S role )*
role
  : "action"
  | "caption"
  | "description"
  | "dialog"
  | "expletive"
  | "kinesic"
  | "lyrics"
  | "music"
  | "narration"
  | "quality"
  | "sound"
  | "source"
  | "suppressed"
  | "reproduction"
  | "thought"
  | "title"
  | "transcription"
  | extension-role
extension-role
  : "x-" token-char+
token-char
  : { XML NameChar }    // XML 1.1 Production [4a]