scripts.systemhtml.HtmlDartInterfaceGenerator Class Reference

Inheritance diagram for scripts.systemhtml.HtmlDartInterfaceGenerator:

Public Member Functions
def	__init__ (self, options, library_emitter, event_generator, prototype_event_generator, interface, backend)
def	Generate (self)
def	GenerateCallback (self)
def	GenerateInterface (self)

Detailed Description

Generates dart interface and implementation for the DOM IDL interface.

Definition at line 596 of file systemhtml.py.

Constructor & Destructor Documentation

__init__()

def scripts.systemhtml.HtmlDartInterfaceGenerator.__init__	(		self,
			options,
			library_emitter,
			event_generator,
			prototype_event_generator,
			interface,
			backend
	)

Definition at line 599 of file systemhtml.py.

                 prototype_event_generator, interface, backend):
        self._renamer = options.renamer
        self._database = options.database
        self._template_loader = options.templates
        self._type_registry = options.type_registry
        self._options = options
        self._library_emitter = library_emitter
        self._event_generator = event_generator
        self._prototype_event_generator = prototype_event_generator
        self._interface = interface
        self._backend = backend
        self._interface_type_info = self._type_registry.TypeInfo(
            self._interface.id)
        self._library_name = self._renamer.GetLibraryName(self._interface)
        self._metadata = options.metadata
 

Member Function Documentation

Generate()

def scripts.systemhtml.HtmlDartInterfaceGenerator.Generate

(

self

)

Definition at line 616 of file systemhtml.py.

    def Generate(self):
        if IsCustomType(self._interface.id):
            pass
        elif 'Callback' in self._interface.ext_attrs:
            if len(GetCallbackHandlers(self._interface)) > 0:
                self.GenerateCallback()
            elif generateCallbackInterface(self._interface.id):
                self.GenerateInterface()
            else:
                return
        else:
            self.GenerateInterface()
 

GenerateCallback()

def scripts.systemhtml.HtmlDartInterfaceGenerator.GenerateCallback

(

self

)

Generates a typedef for the callback interface.

Definition at line 629 of file systemhtml.py.

    def GenerateCallback(self):
        """Generates a typedef for the callback interface."""
        typedef_name = self._renamer.RenameInterface(self._interface)
        if not typedef_name:
            return
 
        info = GetCallbackInfo(self._interface)
        code = self._library_emitter.FileEmitter(self._interface.id,
                                                 self._library_name)
        code.Emit(self._template_loader.Load('callback.darttemplate'))
 
        annotations = self._metadata.GetFormattedMetadata(
            self._library_name, self._interface)
 
        params = info.ParametersAsDeclaration(self._DartType)
 
        types = params.split()
        if len(types) > 0:
            mapType = types[0] in _callback_list_generics_mapping
            if mapType is True:
                types[0] = 'List'
                params = " ".join(types)
 
        code.Emit(
            '$(ANNOTATIONS)typedef void $NAME($PARAMS);\n',
            ANNOTATIONS=annotations,
            NAME=typedef_name,
            PARAMS=params)
        self._backend.GenerateCallback(info)
 

GenerateInterface()

def scripts.systemhtml.HtmlDartInterfaceGenerator.GenerateInterface

(

self

)

Definition at line 659 of file systemhtml.py.

    def GenerateInterface(self):
        interface_name = self._interface_type_info.interface_name()
 
        implementation_name = self._interface_type_info.implementation_name()
        self._library_emitter.AddTypeEntry(
            self._library_name, self._interface.id, implementation_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)
            # TODO(antonm): consider removing it later.
            factory_provider = interface_name
 
        # HTML Elements and SVG Elements have convenience constructors.
        infos = ElementConstructorInfos(
            self._interface.id,
            _element_constructors[self._library_name],
            factory_provider_name=_factory_ctr_strings[self._library_name]
            ['provider_name'])
 
        if infos:
            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 and factory_provider != info.factory_provider_name:
                _logger.warn('Conflicting factory provider names: %s != %s' %
                             (factory_provider, info.factory_provider_name))
            factory_provider = info.factory_provider_name
 
        implementation_emitter = self._ImplementationEmitter()
 
        base_type_info = None
        if self._interface.parents:
            supertype = self._interface.parents[0].type.id
            if not IsDartCollectionType(supertype) and not IsPureInterface(
                    supertype, self._database):
                base_type_info = self._type_registry.TypeInfo(supertype)
 
        if base_type_info:
            base_class = base_type_info.implementation_name()
        else:
            base_class = self._backend.RootClassName()
 
        implements = self._backend.AdditionalImplementedInterfaces()
        for parent in self._interface.parents:
            parent_type_info = self._type_registry.TypeInfo(parent.type.id)
            if parent_type_info.interface_name() != base_class and \
                parent_type_info != base_type_info:
                implements.append(parent_type_info.interface_name())
 
        secure_base_name = self._backend.SecureBaseName(interface_name)
        if secure_base_name:
            implements.append(secure_base_name)
 
        implements_str = ''
        if implements:
            # Get rid of duplicates using OrderedDict.
            implements = list(OrderedDict([(i, None) for i in implements]))
            implements_str = ' implements ' + ', '.join(implements)
 
        mixins = self._backend.Mixins()
 
        mixins_str = ''
        if mixins:
            mixins_str = ' with ' + ', '.join(mixins)
            if not base_class:
                base_class = 'JavaScriptObject'
            elif (base_class == 'NativeFieldWrapperClass2' and
                  self._options.dart_js_interop and
                  not (isinstance(self._backend, Dart2JSBackend))):
                base_class = 'DartHtmlDomObject'
 
        annotations = self._metadata.GetFormattedMetadata(
            self._library_name, self._interface, None, '')
 
        class_modifiers = ''
        if (self._renamer.ShouldSuppressInterface(self._interface) or
                IsPureInterface(self._interface.id, self._database)):
            # XMLHttpRequestProgressEvent can't be abstract we need to instantiate
            # for JsInterop.
            if (not (isinstance(self._backend, Dart2JSBackend)) and
                (self._interface.id == 'XMLHttpRequestProgressEvent' or
                 self._interface.id == 'DOMStringMap')):
                # Suppress abstract for XMLHttpRequestProgressEvent and DOMStringMap
                # for Dartium.  Need to be able to instantiate the class; can't be abstract.
                class_modifiers = ''
            else:
                # For Dartium w/ JsInterop these suppressed interfaces are needed to
                # instantiate the internal classes.
                if (self._renamer.ShouldSuppressInterface(self._interface) and
                        not (isinstance(self._backend, Dart2JSBackend)) and
                        self._options.dart_js_interop):
                    class_modifiers = ''
                else:
                    class_modifiers = 'abstract '
 
        native_spec = ''
        if not IsPureInterface(self._interface.id, self._database):
            native_spec = self._backend.NativeSpec()
 
        class_name = self._interface_type_info.implementation_name()
 
        js_interop_wrapper = '''
 
  @Deprecated("Internal Use Only")
  external static Type get instanceRuntimeType;
 
  @Deprecated("Internal Use Only")
  {0}.internal_() : super.internal_();
 
'''.format(class_name)
        if base_class == 'NativeFieldWrapperClass2' or base_class == 'DartHtmlDomObject':
            js_interop_wrapper = '''
 
  @Deprecated("Internal Use Only")
  external static Type get instanceRuntimeType;
 
  @Deprecated("Internal Use Only")
  {0}.internal_() {{ }}
'''.format(class_name)
            # Change to use the synthesized class so we can construct with a mixin
            # classes prefixed with name of NativeFieldWrapperClass2 don't have a
            # default constructor so classes with mixins can't be new'd.
            if (self._options.templates._conditions['DARTIUM'] and
                    self._options.dart_js_interop and
                (self._interface.id == 'NamedNodeMap' or
                 self._interface.id == 'CSSStyleDeclaration')):
                base_class = 'DartHtmlDomObject'
 
        maplikeKeyType = ''
        maplikeValueType = ''
        if self._interface.isMaplike:
            maplikeKeyType = self._type_registry.\
                _TypeInfo(self._interface.maplike_key_value[0].id).dart_type()
            maplikeValueType = 'dynamic'
            mixins_str = " with MapMixin<%s, %s>" % (maplikeKeyType,
                                                     maplikeValueType)
 
        implementation_members_emitter = implementation_emitter.Emit(
            self._backend.ImplementationTemplate(),
            LIBRARYNAME='dart.dom.%s' % self._library_name,
            ANNOTATIONS=annotations,
            CLASS_MODIFIERS=class_modifiers,
            CLASSNAME=class_name,
            EXTENDS=' extends %s' % base_class if base_class else '',
            IMPLEMENTS=implements_str,
            MIXINS=mixins_str,
            DOMNAME=self._interface.doc_js_name,
            NATIVESPEC=native_spec,
            KEYTYPE=maplikeKeyType,
            VALUETYPE=maplikeValueType,
            NULLABLE='?',
            NULLSAFECAST=True,
            NULLASSERT='!')
        if self._interface.doc_js_name is 'RadioNodeList':
            print(self._backend.ImplementationTemplate())
            print(implementation_members_emitter)
        stream_getter_signatures_emitter = None
        element_stream_getters_emitter = None
        class_members_emitter = None
        if type(implementation_members_emitter) == tuple:
            # We add event stream getters for both Element and ElementList, so in
            # impl_Element.darttemplate, we have two additional "holes" for emitters
            # to fill in, with small variations. These store these specialized
            # emitters.
            if (len(implementation_members_emitter) == 3):
                stream_getter_signatures_emitter = \
                    implementation_members_emitter[0]
                element_stream_getters_emitter = implementation_members_emitter[
                    1]
                implementation_members_emitter = \
                    implementation_members_emitter[2]
 
            # We add special emitters for classes migrated to static type extensions
            elif (len(implementation_members_emitter) == 2):
                class_members_emitter = \
                    implementation_members_emitter[0]
                implementation_members_emitter = \
                    implementation_members_emitter[1]
        self._backend.StartInterface(implementation_members_emitter)
        self._backend.EmitHelpers(base_class, class_members_emitter)
        self._event_generator.EmitStreamProviders(
            self._interface, self._backend.CustomJSMembers(),
            implementation_members_emitter, self._library_name)
        self._prototype_event_generator.CollectStreamProviders(
            self._interface, self._backend.CustomJSMembers(),
            self._library_name)
        self._backend.AddConstructors(constructors, factory_provider,
                                      factory_constructor_name,
                                      class_members_emitter)
 
        isElement = False
        for parent in self._database.Hierarchy(self._interface):
            if parent.id == 'Element':
                isElement = True
 
        # Write out the JsInterop code.
        if (implementation_members_emitter and
                self._options.templates._conditions['DARTIUM'] and
                self._options.dart_js_interop and
                not IsPureInterface(self._interface.id, self._database)):
            implementation_members_emitter.Emit(js_interop_wrapper)
 
        if isElement and self._interface.id != 'Element':
            implementation_members_emitter.Emit(
                '  /**\n'
                '   * Constructor instantiated by the DOM when a custom element has been created.\n'
                '   *\n'
                '   * This can only be called by subclasses from their created constructor.\n'
                '   */\n'
                '  $CLASSNAME.created() : super.created();\n',
                CLASSNAME=self._interface_type_info.implementation_name())
 
        self._backend.EmitSupportCheck()
 
        merged_interface = self._interface_type_info.merged_interface()
        if merged_interface:
            self._backend.AddMembers(
                self._database.GetInterface(merged_interface),
                not self._backend.ImplementsMergedMembers())
 
        self._backend.AddMembers(self._interface, False,
                                 self._options.dart_js_interop)
        self._backend.AddSecondaryMembers(self._interface)
        self._event_generator.EmitStreamGetters(
            self._interface, [], implementation_members_emitter,
            self._library_name, stream_getter_signatures_emitter,
            element_stream_getters_emitter)
        self._prototype_event_generator.CollectStreamGetters(
            self._interface, [], self._library_name)
        self._backend.FinishInterface()
 

---

The documentation for this class was generated from the following file:

• third_party/dart-lang/sdk/tools/dom/scripts/systemhtml.py