W3C home > Mailing lists > Public > w3c-wai-ua@w3.org > July to September 2001

[Issue 516] Is ordered rendering required to satisfy checkpoint 2.4?

From: Ian B. Jacobs <ij@w3.org>
Date: Wed, 25 Jul 2001 12:20:16 -0400
Message-ID: <3B5EF1C0.87F2C554@w3.org>
To: jferraio@Adobe.COM, lilley@w3.org, dean@w3.org, w3c-wai-ua@w3.org

After the 19 July teleconference, I spoke with Dean Jackson about
issue 516 [2]: "2.4: Checkpoint doesn't make sense for SMIL 2.0".
In the 14 July draft [3], the first provision of the checkpoint
  "For content where user input is only possible within a finite
  time interval controlled by the user agent, allow configuration
  to make the time interval "infinite". Do this by pausing
  automatically at the end of each time interval where user input
  is possible, and resuming automatically after the user has
  explicitly completed input."

At the 19 July teleconference, there was a proposal to delete the
second sentence. It was suggested that a sufficient technique
would be to allow time-independent interaction.

I'd like to examine three scenarios more closely:

  Scenario 1: The user agent renders content with no time line.
  All content is independent of time and is unordered (except for
  document order). All interaction is possible immediately (since
  there is no time line). This is like an HTML document or an SVG
  document where the animation elements have been ignored.

For the next two scenarios, imagine a presentation that may be
paused and resumed manually by the user (like a videocassette
player). The user may interact with the document (e.g., links,
user focus events, etc.) in either the paused or play state.

  Scenario 2: Time line, but no automatic advance. In this
  scenario, nothing happens automatically: the user must step
  through the entire presentation manually. Thus, order is
  preserved, and all time intervals are infinite since the user
  advances manually.  This would "solve" the problem we are
  trying to solve, but would probably be unwieldly because the
  user would have to step through the entire presentation.
  Scenario 3: Time line, with semi-automatic advance. In this
  scenario, the animation proceeds until there is a finite amount
  of time for user interaction. In this scenario, the desired
  user agent behavior is to pause automatically to allow for user
  input, and resume automatic play upon explicit request from the

(There is a fourth scenario: the user agent should follow the
timing and rendering rules of the specification. Of course, the
UA should do that in general, except for where we require
additional functionality.)

I was under the impression by the end of the 19 July teleconf
that people may have been satisfied with some variation on
the first scenario, but it may not have been clear what the 
implications are: order is lost, and that may mean substantial loss 
of meaning. I do not think that this is the proper scope of the 
checkpoint, as the semantics of the presentation should be 
preserved as much as possible.

I am interested in feedback from the Working Group about which
scenario they expected checkpoint 2.4 to cover. It may be
possible to rewrite 2.4 to cover scenario 3, but still to remove
the technique for pausing infinitely. I welcome suggestions on
how to preserve order and remove time-dependence.

On implementing scenario 3

Dean and I talked about ways in which an SVG viewer might
implement the third scenario. We talked about the implementation
having two components (for the purposes of this discussion): an
animation engine and a user interface component. As I understand
the model, the viewer operates as follows:

 a) The animation engine's job is to calculate positions of
 graphical objects. For each increment on the time line, the
 animation engine calculates the position of each displayed

 b) After the animation engine has calculated positions, the user
 interface component redraws the objects at their new positions.

 c) Loop until done.

Here's how we imagined it would be feasible to implement scenario
3.  It assumes that there's a mechanism that allows the user to
manually pause and resume a presentation.

 1) The animation engine knows when it's at the end of a time
 interval. After all, it uses this information as part of its
 calculations to determine the position of graphical objects.

 2) When the animation engine is at the end of a time interval,
 it calculates which animated elements will be affected. This is
 known through markup (either by parent/child relationship or by
 href). Furthermore, the only elements we are interested in here
 are those that are known by specification to have associated
 behaviors. The animation can designate a set of elements using
 xpath, for example.

 3) The animation engine tells the UI component to pause the user
 agent and highlight the elements that are affected.

 4) Thus, the user agent automatically enters "paused mode",
 allowing the user to interact with links, etc (some of which
 have been highlighted to emphasize that they are
 time-dependent).  The user can manually resume the presentation
 when the user wishes.

I am interested in feedback from developers about whether this
makes sense.

 - Ian

[1] http://lists.w3.org/Archives/Public/w3c-wai-ua/2001JulSep/0136
[2] http://server.rehab.uiuc.edu/ua-issues/issues-linear-lc3.html#516
[3] http://www.w3.org/WAI/UA/WD-UAAG10-20010714/

Ian Jacobs (ij@w3.org)   http://www.w3.org/People/Jacobs
Cell:                    +1 917 450-8783
Received on Wednesday, 25 July 2001 12:22:13 UTC

This archive was generated by hypermail 2.4.0 : Friday, 17 January 2020 20:38:31 UTC