Add constructors for SVG elements and remove static factory providers for html elements.

sdk/lib/html/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."""
 
 import emitter
 import os
@@ skipping 40 matching lines @@
 # 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 ElementConstructorInfo(object):
   def __init__(self, name=None, tag=None,
                params=[], opt_params=[],
-               factory_provider_name='_Elements'):
+               factory_provider_name='document'):
     self.name = name          # The constructor name 'h1' in 'HeadingElement.h1'
-    self.tag = tag or name    # The HTML tag
+    self.tag = tag or name    # The HTML or SVG tag
     self.params = params
     self.opt_params = opt_params
     self.factory_provider_name = factory_provider_name
 
   def ConstructorInfo(self, interface_name):
     info = OperationInfo()
     info.overloads = None
     info.declared_name = interface_name
     info.name = interface_name
     info.constructor_name = self.name
     info.js_name = None
     info.type_name = interface_name
     info.param_infos = map(lambda tXn: ParamInfo(tXn[1], tXn[0], True),
                            self.opt_params)
     info.requires_named_arguments = True
+    info.factory_parameters = ['"%s"' % self.tag]
     return info
 
 _html_element_constructors = {
   'AnchorElement' :
     ElementConstructorInfo(tag='a', opt_params=[('DOMString', 'href')]),
   'AreaElement': 'area',
   'ButtonElement': 'button',
   'BRElement': 'br',
   'BaseElement': 'base',
   'BodyElement': 'body',
@@ skipping 52 matching lines @@
   'TableElement': 'table',
   'TableRowElement': 'tr',
   #'TableSectionElement'  <thead> <tbody> <tfoot>
   'TextAreaElement': 'textarea',
   'TitleElement': 'title',
   'TrackElement': 'track',
   'UListElement': 'ul',
   'VideoElement': 'video'
 }
 
-def HtmlElementConstructorInfos(typename):
+_svg_element_constructors = {
+  'SVGAElement': 'a',
+  'SVGAnimateColorElement': 'animateColor',
+  'SVGAnimateElement': 'animate',
+  'SVGAnimateMotionElement': 'animateMotion',
+  'SVGAnimateTransformElement': 'animateTransform',
+  'SVGAnimationElement': 'animation',
+  'SVGCircleElement': 'circle',
+  'SVGClipPathElement': 'clipPath',
+  'SVGCursorElement': 'cursor',
+  'SVGDefsElement': 'defs',
+  'SVGDescElement': 'desc',
+  'SVGEllipseElement': 'ellipse',
+  'SVGFilterElement': 'filter',
+  'SVGFontElement': 'font',
+  'SVGFontFaceElement': 'font-face',
+  'SVGFontFaceFormatElement': 'font-face-format',
+  'SVGFontFaceNameElement': 'font-face-name',
+  'SVGFontFaceSrcElement': 'font-face-src',
+  'SVGFontFaceUriElement': 'font-face-uri',
+  'SVGForeignObjectElement': 'foreignObject',
+  'SVGGlyphElement': 'glyph',
+  'SVGGElement': 'g',
+  'SVGHKernElement': 'hkern',
+  'SVGImageElement': 'image',
+  'SVGLinearGradientElement': 'linearGradient',
+  'SVGLineElement': 'line',
+  'SVGMarkerElement': 'marker',
+  'SVGMaskElement': 'mask',
+  'SVGMPathElement': 'mpath',
+  'SVGPathElement': 'path',
+  'SVGPatternElement': 'pattern',
+  'SVGPolygonElement': 'polygon',
+  'SVGPolylineElement': 'polyline',
+  'SVGRadialGradientElement': 'radialGradient',
+  'SVGRectElement': 'rect',
+  'SVGScriptElement': 'script',
+  'SVGSetElement': 'set',
+  'SVGStopElement': 'stop',
+  'SVGStyleElement': 'style',
+  'SVGSwitchElement': 'switch',
+  'SVGSymbolElement': 'symbol',
+  'SVGTextElement': 'text',
+  'SVGTitleElement': 'title',
+  'SVGTRefElement': 'tref',
+  'SVGTSpanElement': 'tspan',
+  'SVGUseElement': 'use',
+  'SVGViewElement': 'view',
+  'SVGVKernElement': 'vkern',
+}
+
+_element_constructors = {
+  'html': _html_element_constructors,
+  'svg': _svg_element_constructors
+}
+
+_factory_ctr_strings = {
+  'html': {
+      'provider_name': 'document',
+      'constructor_name': '$dom_createElement'
+  },
+  'svg': {
+    'provider_name': '_SvgElementFactoryProvider',
+    'constructor_name': 'createSVGElement_tag',
+  },
+}
+
+def ElementConstructorInfos(typename, element_constructors,
+                            factory_provider_name='_Elements'):
   """Returns list of ElementConstructorInfos about the convenience constructors
-  for an Element."""
+  for an Element or SvgElement."""
   # TODO(sra): Handle multiple and named constructors.
-  if typename not in _html_element_constructors:
+  if typename not in element_constructors:
     return []
-  infos = _html_element_constructors[typename]
+  infos = element_constructors[typename]
   if isinstance(infos, str):
-    infos = ElementConstructorInfo(tag=infos)
+    infos = ElementConstructorInfo(tag=infos,
+        factory_provider_name=factory_provider_name)
   if not isinstance(infos, list):
     infos = [infos]
   return infos
 
-def EmitHtmlElementFactoryConstructors(emitter, infos, typename, class_name,
-                                       rename_type):
-  for info in infos:
-    constructor_info = info.ConstructorInfo(typename)
-
-    inits = emitter.Emit(
-        '\n'
-        '  static $RETURN_TYPE $CONSTRUCTOR($PARAMS) {\n'
-        '    $CLASS _e = document.$dom_createElement("$TAG");\n'
-        '$!INITS'
-        '    return _e;\n'
-        '  }\n',
-        RETURN_TYPE=rename_type(constructor_info.type_name),
-        CONSTRUCTOR=constructor_info.ConstructorFactoryName(rename_type),
-        CLASS=class_name,
-        TAG=info.tag,
-        PARAMS=constructor_info.ParametersDeclaration(
-            rename_type, force_optional=True))
-    for param in constructor_info.param_infos:
-      inits.Emit('    if ($E != null) _e.$E = $E;\n', E=param.name)
-
 # ------------------------------------------------------------------------------
 
 class HtmlDartInterfaceGenerator(object):
   """Generates dart interface and implementation for the DOM IDL interface."""
 
   def __init__(self, options, library_emitter, event_generator, interface,
                backend):
     self._renamer = options.renamer
     self._database = options.database
     self._template_loader = options.templates
@@ skipping 24 matching lines @@
               NAME=self._interface.id,
               PARAMS=info.ParametersDeclaration(self._DartType))
     self._backend.GenerateCallback(info)
 
   def GenerateInterface(self):
     interface_name = self._interface_type_info.interface_name()
 
     factory_provider = None
     if interface_name in interface_factories:
       factory_provider = interface_factories[interface_name]
+    factory_constructor_name = None
 
     constructors = []
     if interface_name in _static_classes:
       constructor_info = None
     else:
       constructor_info = AnalyzeConstructor(self._interface)
     if constructor_info:
       constructors.append(constructor_info)
       factory_provider = '_' + interface_name + 'FactoryProvider'
       factory_provider_emitter = self._library_emitter.FileEmitter(
           '_%sFactoryProvider' % interface_name, self._library_name)
       self._backend.EmitFactoryProvider(
           constructor_info, factory_provider, factory_provider_emitter)
 
-    infos = HtmlElementConstructorInfos(interface_name)
+    # HTML Elements and SVG Elements have convenience constructors.
+    infos = ElementConstructorInfos(interface_name,
+        _element_constructors[self._library_name], factory_provider_name=
+        _factory_ctr_strings[self._library_name]['provider_name'])
+
     if infos:
-      template = self._template_loader.Load(
-          'factoryprovider_Elements.darttemplate')
-      EmitHtmlElementFactoryConstructors(
-          self._library_emitter.FileEmitter('_Elements', self._library_name,
-              template),
-          infos,
-          self._interface.id,
-          self._interface_type_info.implementation_name(),
-          self._DartType)
-
+      factory_constructor_name = _factory_ctr_strings[
+          self._library_name]['constructor_name']
+    
     for info in infos:
       constructors.append(info.ConstructorInfo(self._interface.id))
       if factory_provider:
         assert factory_provider == info.factory_provider_name
       else:
         factory_provider = info.factory_provider_name
 
     implementation_emitter = self._ImplementationEmitter()
 
     base_type_info = None
@@ skipping 30 matching lines @@
         LIBRARYNAME=self._library_name,
         CLASSNAME=self._interface_type_info.implementation_name(),
         EXTENDS=' extends %s' % base_class if base_class else '',
         IMPLEMENTS=implements_str,
         DOMNAME=self._interface.doc_js_name,
         NATIVESPEC=self._backend.NativeSpec())
     self._backend.StartInterface(self._implementation_members_emitter)
 
     self._backend.AddConstructors(constructors, factory_provider,
         self._interface_type_info.implementation_name(),
-        base_class)
+        base_class, factory_constructor_name=factory_constructor_name)
 
     events_class_name = self._event_generator.ProcessInterface(
         self._interface, interface_name,
         self._backend.CustomJSMembers(),
         implementation_emitter)
     if events_class_name:
       self._backend.EmitEventGetter(events_class_name)
 
     merged_interface = self._interface_type_info.merged_interface()
     if merged_interface:
@@ skipping 610 matching lines @@
       'svg': DartLibrary('svg', template_loader, library_type, output_dir),
       'html': DartLibrary('html', template_loader, library_type, output_dir),
     }
 
   def AddFile(self, basename, library_name, path):
     self._libraries[library_name].AddFile(path)
 
   def Emit(self, emitter, auxiliary_dir):
     for lib in self._libraries.values():
       lib.Emit(emitter, auxiliary_dir)