Move html events generation to domimpl.

lib/dom/scripts/systemhtml.py

 #!/usr/bin/python
 # Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 # for details. All rights reserved. Use of this source code is governed by a
 # BSD-style license that can be found in the LICENSE file.
 
 """This module provides shared functionality for the system to generate
 Dart:html APIs from the IDL database."""
 
 from systemfrog import *
 from systeminterface import *
@@ skipping 430 matching lines @@
 # doesn't match the interface hierarchy.
 _html_explicit_event_classes = set(['DocumentFragment'])
 
 def _OnAttributeToEventName(on_method):
   event_name = on_method.id[2:]
   if event_name in _on_attribute_to_event_name_mapping:
     return _on_attribute_to_event_name_mapping[event_name]
   else:
     return event_name
 
-def _DomToHtmlEvents(interface_id, events):
+def DomToHtmlEvents(interface_id, events):
   event_names = set(map(_OnAttributeToEventName, events))
   if interface_id in _html_manual_events:
     for manual_event_name in _html_manual_events[interface_id]:
       event_names.add(manual_event_name)
 
   return sorted(event_names, key=lambda name: _html_event_names[name])
 
+def DomToHtmlEvent(event_name):
+  assert event_name in _html_event_names, \
+         'No known html event name for event: ' + event_name

[Anton Muhin, 2012/05/16 13:17:57]

nit: something like 'No html event with name %s' % event_name might be a better
variant.  up to you though.

+  return _html_event_names[event_name]
+
 # ------------------------------------------------------------------------------
 class HtmlSystemShared(object):
 
   def __init__(self, database, generator):
     self._event_classes = set()
     self._seen_event_names = {}
     self._database = database
     self._generator = generator
 
   def _AllowInHtmlLibrary(self, interface, member, member_prefix):
@@ skipping 302 matching lines @@
                                  NAME=html_name,
                                  PARAMS=info.ParametersInterfaceDeclaration())
 
   def FinishInterface(self):
     pass
 
   def AddConstant(self, constant):
     self._EmitConstant(self._members_emitter, constant)
 
   def AddEventAttributes(self, event_attrs):
-    event_attrs = _DomToHtmlEvents(self._interface.id, event_attrs)
+    event_attrs = DomToHtmlEvents(self._interface.id, event_attrs)
     self._shared._event_classes.add(self._interface.id)
     events_interface = self._interface.id + 'Events'
     self._EmitEventGetter(events_interface)
 
     events_members = self._emitter.Emit(
         '\ninterface $INTERFACE extends $PARENTS {\n$!MEMBERS}\n',
         INTERFACE=events_interface,
         PARENTS=', '.join(
             self._shared.GetParentsEventsClasses(self._interface)))
 
@@ skipping 266 matching lines @@
     else:
       self._members_emitter.Emit(
           '\n'
           '  $TYPE $NAME($PARAMS) native;\n',
           TYPE=self._NarrowOutputType(info.type_name),
           NAME=info.name,
           PARAMS=info.ParametersImplementationDeclaration(
               lambda type_name: self._NarrowInputType(type_name)))
 
   def AddEventAttributes(self, event_attrs):
-    event_attrs = _DomToHtmlEvents(self._interface.id, event_attrs)
+    event_attrs = DomToHtmlEvents(self._interface.id, event_attrs)
     events_class = '_' + self._interface.id + 'EventsImpl'
     events_interface = self._interface.id + 'Events'
     self._EmitEventGetter(events_class)
 
     self._shared._event_classes.add(self._interface.id)
 
     parent_event_class = self._shared.GetParentEventsClass(self._interface)
 
     # TODO(jacobr): specify the type of _ptr as EventTarget
     events_members = self._dart_code.Emit(
@@ skipping 233 matching lines @@
     self._members_emitter.Emit(
         '  $(CLASSNAME)._wrap(ptr) : super._wrap(ptr);\n',
         CLASSNAME=self._class_name)
 
     # Emit a factory provider class for the constructor.
     constructor_info = AnalyzeConstructor(interface)
     if constructor_info:
       self._EmitFactoryProvider(interface_name, constructor_info)
 
     emit_events, events = self._shared.GetEventAttributes(self._interface)
-    if not emit_events:
-      return
-    elif events:
-      self.AddEventAttributes(events)
-    else:
-      parent_events_class = self._shared.GetParentEventsClass(self._interface)
-      self._EmitEventGetter('_' + parent_events_class + 'Impl')
+    if emit_events:
+      self._members_emitter.Emit(
+          '\n'
+          '  Events get on() => $THIS.on;\n',
+          THIS=self.DomObjectName())
 
   def _EmitFactoryProvider(self, interface_name, constructor_info):
     template_file = 'factoryprovider_%s.darttemplate' % interface_name
     template = self._system._templates.TryLoad(template_file)
     if not template:
       template = self._system._templates.Load('factoryprovider.darttemplate')
 
     factory_provider = '_' + interface_name + 'FactoryProvider'
     emitter = self._system._ImplFileEmitter(factory_provider)
     emitter.Emit(
@@ skipping 84 matching lines @@
         THIS=self.DomObjectName())
 
   def AddSecondaryAttribute(self, interface, getter, setter):
     self._SecondaryContext(interface)
     self.AddAttribute(getter, setter)
 
   def AddSecondaryOperation(self, interface, info):
     self._SecondaryContext(interface)
     self.AddOperation(info)
 
-  def AddEventAttributes(self, event_attrs):
-    event_attrs = _DomToHtmlEvents(self._interface.id, event_attrs)
-    events_class = '_' + self._interface.id + 'EventsImpl'
-    events_interface = self._interface.id + 'Events'
-    self._EmitEventGetter(events_class)
-
-    self._shared._event_classes.add(self._interface.id)
-
-    parent_event_class = self._shared.GetParentEventsClass(self._interface)
-
-    # TODO(jacobr): specify the type of _ptr as EventTarget
-    events_members = self._dart_code.Emit(
-        '\n'
-        'class $CLASSNAME extends $SUPER implements $INTERFACE {\n'
-        '  $CLASSNAME(_ptr) : super(_ptr);\n'
-        '$!MEMBERS}\n',
-        CLASSNAME=events_class,
-        INTERFACE=events_interface,
-        SUPER='_' + parent_event_class + 'Impl')
-
-    for event_name in event_attrs:
-      if event_name in _html_event_names:
-        events_members.Emit(
-            "\n"
-            "  EventListenerList get $NAME() => _get('$RAWNAME');\n",
-            RAWNAME=event_name,
-            NAME=_html_event_names[event_name])
-      else:
-        raise Exception('No known html even name for event: ' + event_name)
-
-  def _EmitEventGetter(self, events_class):
-    self._members_emitter.Emit(
-        '\n'
-        '  $TYPE get on() {\n'
-        '    if (_on == null) _on = new $TYPE(this);\n'
-        '    return _on;\n'
-        '  }\n',
-        TYPE=events_class)
-
   def _SecondaryContext(self, interface):
     if interface is not self._current_secondary_parent:
       self._current_secondary_parent = interface
       self._members_emitter.Emit('\n  // From $WHERE\n', WHERE=interface.id)
 
   # TODO(jacobr): change this to more directly match the frog version.
   def AddIndexer(self, element_type):
     """Adds all the methods required to complete implementation of List."""
     # We would like to simply inherit the implementation of everything except
     # get length(), [], and maybe []=.  It is possible to extend from a base
@@ skipping 97 matching lines @@
     self._members_emitter.Emit(
         '\n'
         '  $TYPE $HTML_NAME($PARAMS) => $FUNCTION_CALL;\n',
         TYPE=info.type_name,
         HTML_NAME=html_name,
         PARAMS=info.ParametersImplementationDeclaration(),
         FUNCTION_CALL=function_call)
 
   def AddStaticOperation(self, info):
     pass