Element constructors

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 421 matching lines @@
   'webkitSpeechChange': 'speechChange',
   'webkitsourceclose': 'sourceClose',
   'webkitsourceended': 'sourceEnded',
   'webkitsourceopen': 'sourceOpen',
   'webkitTransitionEnd': 'transitionEnd',
   'write': 'write',
   'writeend': 'writeEnd',
   'writestart': 'writeStart'
 }
 
+
+
+# Information for generating element constructors.
+#
+# TODO(sra): maybe remove all the argument complexity and use cascades.
+#
+#   var c = new CanvasElement(width: 100, height: 70);
+#   var c = new CanvasElement()..width = 100..height = 70;
+#
+class ElementCtorInfo(object):
+  def __init__(self, tag=None, params=[], opt_params=[],
+               factory_provider_name='_Elements'):
+    self.tag = tag
+    self.params = params
+    self.opt_params = opt_params
+    self.factory_provider_name = factory_provider_name
+
+  def ConstructorInfo(self, interface):
+    info = OperationInfo()
+    info.overloads = None
+    info.declared_name = interface.id
+    info.name = interface.id
+    info.js_name = None
+    info.type_name = interface.id
+    info.param_infos = map(lambda tXn: ParamInfo(tXn[1], None, tXn[0], 'null'),
+                           self.opt_params)
+    return info
+
+_html_element_constructors = {
+  'AnchorElement' : ElementCtorInfo(tag='a', opt_params=[('String', 'href')]),
+  'AreaElement': 'area',
+  'ButtonElement': 'button',
+  'BRElement': 'br',
+  'BaseElement': 'base',
+  'BodyElement': 'body',
+  'ButtonElement': 'button',
+  'CanvasElement':
+    ElementCtorInfo(tag='canvas',
+                    opt_params=[('int', 'height'), ('int', 'width')]),
+  'DListElement': 'dl',
+  'DetailsElement': 'details',
+  'DivElement': 'div',
+  'EmbedElement': 'embed',
+  'FieldSetElement': 'fieldset',
+  'Form': 'form',
+  'HRElement': 'hr',
+  'HeadElement': 'head',
+  'HtmlElement': 'html',
+  'IFrameElement': 'iframe',
+  'ImageElement':
+    ElementCtorInfo(tag='img',
+                    opt_params=[('String', 'src'),
+                                ('int', 'height'), ('int', 'width')]),
+  'InputElement':
+    ElementCtorInfo(tag='input', opt_params=[('String', 'type')]),
+  'KeygenElement': 'keygen',
+  'LIElement': 'li',
+  'LabelElement': 'label',
+  'LegendElement': 'legend',
+  'LinkElement': 'link',
+  'MapElement': 'map',
+  'MenuElement': 'menu',
+  'MeterElement': 'meter',
+  'OListElement': 'ol',
+  'ObjectElement': 'object',
+  'OptGroupElement': 'optgroup',
+  'OutputElement': 'output',
+  'ParagraphElement': 'p',
+  'ParamElement': 'param',
+  'PreElement': 'pre',
+  'ProgressElement': 'progress',
+  'ScriptElement': 'script',
+  'SourceElement': 'source',
+  'SpanElement': 'span',
+  'StyleElement': 'style',
+  'TableCaptionElement': 'caption',
+  'TableCellElement': 'td',
+  'TableColElement': 'col',
+  'TableElement': 'table',
+  'TableRowElement': 'tr',
+  #'TableSectionElement'  <thead> <tbody> <tfoot>
+  'TextAreaElement': 'textarea',
+  'TitleElement': 'title',
+  'TrackElement': 'track',
+  'UListElement': 'ul',
+  'VideoElement': 'video'
+}
+
 # These classes require an explicit declaration for the "on" method even though
 # they don't declare any unique events, because the concrete class hierarchy
 # 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:
@@ skipping 132 matching lines @@
     super(HtmlSystem, self).__init__(
         templates, database, emitters, output_dir)
     self._shared = HtmlSystemShared(database)
 
 class HtmlInterfacesSystem(HtmlSystem):
 
   def __init__(self, templates, database, emitters, output_dir):
     super(HtmlInterfacesSystem, self).__init__(
         templates, database, emitters, output_dir)
     self._dart_interface_file_paths = []
+    self._factory_provider_emitters = {}
 
   def InterfaceGenerator(self,
                          interface,
                          common_prefix,
                          super_interface_name,
                          source_filter):
     """."""
     interface_name = interface.id
     dart_interface_file_path = self._FilePathForDartInterface(interface_name)
 
@@ skipping 21 matching lines @@
   def GenerateLibraries(self):
     pass
 
 
   def _FilePathForDartInterface(self, interface_name):
     """Returns the file path of the Dart interface definition."""
     # TODO(jmesserly): is this the right path
     return os.path.join(self._output_dir, 'html', 'interface',
                         '%s.dart' % interface_name)
 
+  def _EmitterForFactoryProviderBody(self, name):
+    if name not in self._factory_provider_emitters:
+      path = self._FilePathForDartInterface(name)
+      self._dart_interface_file_paths.append(path)
+      template = self._templates.Load('factoryprovider_%s.darttemplate' % name)
+      file_emitter = self._emitters.FileEmitter(path)
+      self._factory_provider_emitters[name] = file_emitter.Emit(template)
+    return self._factory_provider_emitters[name]
+
 # ------------------------------------------------------------------------------
 
 # TODO(jmesserly): inheritance is probably not the right way to factor this long
 # term, but it makes merging better for now.
 class HtmlDartInterfaceGenerator(DartInterfaceGenerator):
   """Generates Dart Interface definition for one DOM IDL interface."""
 
   def __init__(self, system, interface, emitter, template,
                common_prefix, super_interface, source_filter, shared):
     super(HtmlDartInterfaceGenerator, self).__init__(system, interface,
@@ skipping 25 matching lines @@
       extends_str += ' extends ' + ', '.join(extends)
       comment = ','
     if suppressed_extends:
       extends_str += ' /*%s %s */' % (comment, ', '.join(suppressed_extends))
 
     factory_provider = None
     constructor_info = AnalyzeConstructor(self._interface)
     if constructor_info:
       factory_provider = '_' + typename + 'FactoryProvider';
 
+    if not constructor_info:
+      (constructor_info, factory_provider) = self._EmitElementFactory(typename)
+
     if typename in interface_factories:
       factory_provider = interface_factories[typename]
 
     if factory_provider:
       extends_str += ' default ' + factory_provider
 
     # TODO(vsm): Add appropriate package / namespace syntax.
     (self._type_comment_emitter,
      self._members_emitter,
      self._top_level_emitter) = self._emitter.Emit(
@@ skipping 26 matching lines @@
         TYPE=DartType(element_type))
 
     emit_events, events = self._shared.GetEventAttributes(self._interface)
     if not emit_events:
       return
     elif events:
       self.AddEventAttributes(events)
     else:
       self._EmitEventGetter(self._shared.GetParentEventsClass(self._interface))
 
+  def _EmitElementFactory(self, typename):
+    """Returns pair (constructor_info, factory_provider_name)."""
+    if typename not in _html_element_constructors:
+      return (None, None)
+    info = _html_element_constructors[typename]
+    if isinstance(info, str): info = ElementCtorInfo(tag=info)
+    constructor_info = info.ConstructorInfo(self._interface)
+    em = self._system._EmitterForFactoryProviderBody(info.factory_provider_name)
+    inits = em.Emit(
+        '\n'
+        '  factory $CONSTRUCTOR($PARAMS) {\n'
+        '    $CLASSNAME _e = _document.$dom_createElement("$TAG");\n'
+        '$!INITS'
+        '    return _e;\n'
+        '  }\n',
+        CONSTRUCTOR=typename,
+        CLASSNAME='_' + typename + 'Impl',  # TODO: fix
+        TAG=info.tag,
+        PARAMS=constructor_info.ParametersInterfaceDeclaration())
+    for param in constructor_info.param_infos:
+      inits.Emit('    if ($E != null) _e.$E = $E;\n', E=param.name)
+
+    return (constructor_info, info.factory_provider_name)
+
+
   def AddAttribute(self, getter, setter):
     dom_name = DartDomNameOfAttribute(getter)
     html_getter_name = self._shared.RenameInHtmlLibrary(
       self._interface, dom_name, 'get:')
     html_setter_name = self._shared.RenameInHtmlLibrary(
       self._interface, dom_name, 'set:')
 
     if not html_getter_name or self._shared.IsPrivate(html_getter_name):
       getter = None
     if not html_setter_name or self._shared.IsPrivate(html_setter_name):
@@ skipping 831 matching lines @@
             Collect(database.GetInterface(parent.type.id),
                     seen, collected)
 
   inheritance_closure = {}
   for interface in database.GetInterfaces():
     seen = set()
     collected = []
     Collect(interface, seen, collected)
     inheritance_closure[interface.id] = collected
   return inheritance_closure