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

Re: Enumeration of EventListeners in DOM Level 3 Events

From: Richard Schwerdtfeger <schwer@us.ibm.com>
Date: Tue, 18 Dec 2001 13:24:39 -0600
To: rayw@netscape.com (Ray Whitmer)
Cc: "Ian B. Jacobs" <ij@w3.org>, Philippe Le Hegaret <plh@w3.org>, w3c-dom-ig@w3.org, w3c-wai-ua@w3.org, w3c-wai-ua-request@w3.org
Message-ID: <OFC2BB74AD.5C3F1B44-ON86256B26.0067E3D4@raleigh.ibm.com>

One of the problems you and I are both dealing with is the state of things
(almost 2 years ago) with what they are now. Talking about implementing a
semantic model 2 years ago was not realistic. Yes its almost 2 years we
talked about the issues. (January FTF)

>What you are fighting for here is useless.  Start listening.  Hacking UI
events will never be a good solution, no matter how you decorate them.
>Especially as you begin adding new requirements on the script writer, why
maintain the hackish approach when you can move towards a simple >semantic
design that will be easier for everyone.

I am listening. I don't disagree that semantic events would be very useful.
However, I believe that what you would like to impose on a script writer
requires an immense amount of work and that web content, in general today,
does not support it. Currently, there is no notion of a semantic event in
JavaScript. JavaScript is very low level. Nobody is asking to "hack"
anything. The problem is there has been a lot of push back to accept event
activation of any form. It is a lot of work for the DOM working group.

>As I have said, the ability to ask about the presence of a specific type
of listener in the hierarchy of a particular node is something we could
>discuss, but you have a lot of broken ideas in this writeup to overcome,
so don't blame us that you didn't do symantic events.  They are not that

I think we are talking about the same thing. Unfortunately, most event
usage today does not support semantic information and we have to deal with
lots of legacy script on the web. Doing semantic events will not cover the
bulk of what is out there is built on a non-semantic infrastucture in which
case the use of descriptions is very helpful. The legacy information we
have today is onblur, onfocus, onactivate, onclick, etc. Below this we have
an attached function (whatever it is).


Rich Schwerdtfeger
Senior Technical Staff Member
IBM Accessibility Center
Research Division
EMail/web: schwer@us.ibm.com

"Two roads diverged in a wood, and I -
I took the one less traveled by, and that has made all the difference.",

                    com (Ray             To:     Richard Schwerdtfeger/Austin/IBM@IBMUS                             
                    Whitmer)             cc:     "Ian B. Jacobs" <ij@w3.org>, Philippe Le Hegaret <plh@w3.org>,     
                                          w3c-wai-ua@w3.org, w3c-wai-ua-request@w3.org, w3c-dom-ig@w3.org           
                    12/18/2001           Subject:     Re: Enumeration of EventListeners in DOM Level 3 Events       
                    12:54 PM                                                                                        

I have removed www-dom because I believe you have referred to discussions
that are not public.  I added instead w3c-dom-ig.

Adding the event type enumeration only fixes a small part of the fact that
it is broken.  There is no justification to ignore the other issues that
have been repeated here.  Enumeration of types leads to broken thinking
about listeners, and enumeration of listeners is even worse because there
are already methods for properly dispatching an event of any given type at
a given node and the only reason to enumerate them would be to invoke them

The place to get a list of possible types is from a specification, not from
an enumeration, because you cannot dispatch previously-unknown types.  The
proper way to dispatch events to the listener is to call the dispatch
function.  And best way to know whether a listener responding to a specific
type that you know and care about is present would be to ask specifically.
Enumerating the types at a single node doesn't tell you the listeners that
will respond to events on that node, and gives you more information that is
useless and likely to be harmful.

In all of this, there is no real justification for enumeration of types or
listeners.  The use cases we have seen only require knowing whether
handlers will receive specific events of known types of a given node
(notice that I did not say at a given node, because that is not the same as
of, which is another part of what is broken with the enumeration).  Since
DOM Level 2, you can fire an event, and not in the haphazard way that is
most likely to result if someone is manually invoking listeners, that will
break the assumptions of the script writer about delivery of events
according to the specification.

Richard Schwerdtfeger wrote:

     It appears that you are complaining about issues that are a direct
     of the DOM working group including only part of the requirements I had
     placed on you for PF. What would you have me say? Stop shooting
     with the arrows?
We had no problem with our requirements -- only with those represented as
coming to us "from WAI", which are broken and do not support use cases.

I was told that the requirement that this feature was based upon was "let
us enumerate listeners".  If you had emphasized "let us enumerate listener
types" instead of "let us enumerate listeners", I suspect that we would
have been happier to do that instead.  But either enumeration is broken
when dictated as a requirement, because it ignores the real problems that
needs to be solved and insists on a broken solution that doesn't even solve
the problem at hand.
          How does the application construct the proper event, by trial and

     First, an authoring tool ought be able to do this. How might you
     expect a
     person to create an application without this capability? I also
     this may be implementation dependent.
Applications can only do this about event types they know about.
Enumeration of event types you do not know about is useless at best.  The
ability to deal with a specific event type comes from an application
following a specification.  Events which are implementation dependent
without subscribing to a standard specification cannot be properly invoked
by an application.  This is the fallacy of the thinking (that lead to the
current situation) that you can blindly:

1.  enumerate the events
2.  list them on the menu
3.  invoke them from the menu

A far more real description would be:

1.  Identify certain user-based event types that certain classes of users
cannot generate due to an alternative UI -- this has nothing to do yet with
what has been registered.
2.  Carefully construct handling with alternate user interface for these
types.  For example, a keystroke requires a code, a mouse requires a
position and button state, etc.
3.  Permit the user to fire the carefully constructed events at the node in
question.  Presumably requiring the user to numerically speak the key codes
or mouse coordinates is a bad thing so there is a significant amount of
effort to design a suitable alternative UI for firing many UI events.

The ability to do this is already completely available from DOM as it
exists today.  All that is missing is

4.  Permitting these known specific event types to be omitted from the
accessibility menu if there are no known listeners.  This neither requires
nor suggests as a good solution enumeration of listeners, which there is no
reason for, nor even enumeration of event types registered on a particular
          What if the user chooses to invoke functions that should never be
          accessible, such as mutation events.

     If you new the "type" of event you could selectively pick those which
     fire. So what might happen if the mutation event was fired. ...
     nothing since the application would look to see what changed.
It is quite possible to send bad info and crash the application by giving
it a previously-impossible situation, such as a null reference.
Willy-nilly invoking of handlers is not a good idea.  Any application which
permits events to be erroneously fired is badly broken.  The application
discussed here should only fire well-designed UI events, and enumerating
lots of handlers it is clueless about is worse than useless.

Far better to ask a question, "are events of this specific type that I can
generate well handled by a listener"?
          How does the DOM Level 3 script know which event type definition
          to the function, or which listeners must only be invoked in

     Another requirement that I had placed on DOM 3 for PF was to be able
     have a description for each event. Currently, there is no mechanism in
     script to store a description of the event function executed so I when
     met with PF for DOM 3 I had asked that the function name be stored.
     Wood thought this was not an unreasonable request at the time.
That's easy.  The function name is "handleEvent".  Look at the IDL.  You
can make it a constant in your program, but it solves no problems.
Javascript implementations may make a wrapper outside of DOM of an
arbitrarily-named function, but according to the DOM specification, the IDL
fixes the name, and if you give Netscape an object, as the specification
states and do not rely on this wrappering, it must be named handleEvent.

Also, it is flawed to present this name as a menu item to a user, because
it implies that he can invoke the single handler individually, and it would
be broken to do so, because handlers of a specific type work in concert.
One key handler may handle the letter "Q" to quit a specific mode.  The
parent may handle all other keystrokes.  The only way to properly invoke
the key handlers is together.  Even if it says "QuitState", it will not
quit the state of the program unless it gets the Q and the proper way to
fire a keystroke is at all applicable handlers until one cancels.  They are
likely to rely on each other.
     These are all fine questions. The bottom line here is that the DOM
     group only implemented part of the requirements. There is not much I
     can do
     about that except that that if DOM 3 needs to be an interim step to
     we want to go then lets take it. I would love to have had the DOM
     group include all the PF requirements but you are going to do what you
     going to do.
These PF requirements are very poor and broken.  Hacks at best that won't
work well a majority of the time.  We have talked to you for quite some
time about your specifying  semantic events (that would make sense to
enumerate and would be able to automatically appear on a menu, etc.) but
you haven't done them, and "you are going to do what you are going to do".
This is much better than the hacks you are pursuing today, IMO.

The bottom line is several of the DOM group objected to the requirements --
as we did at the time -- because they said "enumerate listeners", which was
obviously broken and had already been repeatedly rejected for similar
reasons.  But it kept getting left in because it came from WAI, ignoring a
discussion of the merits.  It needs to be fixed or eliminated.  If the
requirements had had anything to do with the real accessibility use cases
and had acknowledged the existing state and design of DOM, then we would be
a lot further along today.
     What the DOM WG needed to do is:

        Enumerate all events by type
        For each event provide a description for future script writers to
        able to store a text description. For now DOM implementers should
        the function name here. (We had discussed this when I met at the
     face to
        Allow the user to be able to fire each event based on the
        received from the type and description.
An event is something that is delivered to a listener.  There are never any
events attached to a node to enumerate.

Enumerating listeners is a very broken approach, because the code itself is
the most concise description of what a handler will do.  As much as you
would like them to be semantic, they are not.  Just adding a semantic
description does not help in the least.  The function name is a constant.
And if you had access to it, it would be improper at several levels, as I
have explained, to present it to the user.  The DOM implementation knows no
function name, because according to the DOM specification, the name of the
handler is always the same.  Even if it did, it would be completely wrong
to present it to the user except in a few limited circumstances that you
have not advocated a way of detecting.

I will strongly oppose the ability to individually fire events -- not in
concert as the DOM specification requires -- because it breaks
compatibility with DOM level 2 and breaks the assumptions people make when
they write scripts -- that they work in concert.  If you want that type of
model,design it.  Don't blame other non-semantic systems for not being

You can keep trying to shift blame, but the problem is that the WAI group
has not produced semantic events, which has been ignored for quite some
time.  Then, the accessibility guidelines can require that for
accessibility purposes, non-semantic events should restrict themselves to
dealing with the UI and then invoking semantic events.
     What WCAG needs to do is:

        Define industry standard techniques for storing functional
        in web content.
This is entirely wrong.  Even if you could store a functional description
of what a particular mouse click handler would do, it would be nearly
impossible for an accessibility provider to intelligently use a description
of what many, and likely most, typical UI event handlers do.

You need to simplify, and use semantic events to establish a level that can
be intelligently invoked from alternative UIs.
        Come up with standard descriptions for common functions.
        Document a way for DOM implementers to retrieve them.
        Work with standards bodies, like that for ECMA script, to hav them
This is way more than you need to do, and the result is not as useful as
simple semantic events.
     People working in accessibility have had to fight for every beach head
     can get. If the DOM working group implements part of what we asked in
     3 then it is easier to get the rest in 4.

What you are fighting for here is useless.  Start listening.  Hacking UI
events will never be a good solution, no matter how you decorate them.
Especially as you begin adding new requirements on the script writer, why
maintain the hackish approach when you can move towards a simple semantic
design that will be easier for everyone.

As I have said, the ability to ask about the presence of a specific type of
listener in the hierarchy of a particular node is something we could
discuss, but you have a lot of broken ideas in this writeup to overcome, so
don't blame us that you didn't do symantic events.  They are not that hard.

Ray Whitmer
Received on Tuesday, 18 December 2001 14:24:54 UTC

This archive was generated by hypermail 2.3.1 : Wednesday, 7 January 2015 14:49:31 UTC