def _setupRegistries(self): ''' Setups the registries. First one is the adapter registry which has all the information how models can be adapted to different interfaces. The other registries know how to map a model interface to a node() view/primitive renderer. They're fed with the default objects (all kinds of models, primitive renderers, ...) Finally, there's the serialization registry where you can register serializers for nodes. ''' self.adapterRegistry = adapterRegistry = AdapterRegistry() self.primitiveRendererRegistry = PrimitiveRendererRegistry( adapterRegistry) self.viewRegistry = ViewRegistry(adapterRegistry) self.renderNodeRegistry = RenderNodeRegistry(adapterRegistry) for primitive_kind in self.primitive_kinds: primitiveRendererType = getattr( views, 'Default%sRenderer' % primitive_kind) modelInterface = primitiveRendererType.can_render self.primitiveRendererRegistry.register(modelInterface, primitiveRendererType) for model_kind in self.model_kinds: modelInterface = getattr(models, 'I%s' % model_kind) def createDefaultView(model, look, scaled): primitiveRendererConstructor, model = self.primitiveRendererRegistry.getRendererConstructor( model) primitiveRenderer = primitiveRendererConstructor() primitiveRenderer = observables.ObservableBaseRenderer( self.renderer, look, model, primitiveRenderer, scaled) return observables.ObservableDefaultView( look, primitiveRenderer) self.viewRegistry.register(modelInterface, createDefaultView) for model_kind in self.model_kinds: modelInterface = getattr(models, 'I%s' % model_kind) def createDefaultRenderableNode(model, renderer, transform, look, scaled, name, render_to_surface, surface_size, filter, show): viewConstructor, model = self.viewRegistry.getViewConstructor( model) view = viewConstructor(model=model, look=look, scaled=scaled) renderNode = observables.ObservableDefaultRenderableNode( renderer, render_to_surface, surface_size, filter, model, view, transform, show, name) return renderNode self.renderNodeRegistry.register(modelInterface, createDefaultRenderableNode) # create serialization registries self.serializerRegistry = FactoryUsingDict() self.unserializerRegistry = FactoryUsingDict() def createNativeSerializer(): # import those two here, because they might need to import the simpleCanvas module itself # so importing here avoids a circular dependency from ..serialization.serializer import Serializer from ..serialization import defaultSerializers serializer = Serializer() defaultSerializers.registerDefaultSerializers( serializer.nodeSerializerRegistry) return serializer # register our native serializer and unserializer here self.serializerRegistry.register('fcsf', createNativeSerializer) self.unserializerRegistry.register('fcsf', createNativeSerializer) def createSvgSerializer(): # import those two here, because they might need to import the simpleCanvas module itself # so importing here avoids a circular dependency from ..serialization.svg import SVGExporter from ..serialization.svg import defaultSVGSerializers serializer = SVGExporter(self.adapterRegistry) defaultSVGSerializers.registerDefaultSVGSerializers( serializer.elementCreatorRegistry) defaultSVGSerializers.registerDefaultNodeSerializers( serializer.nodeSerializerRegistry) # register the viewNodel-from-model connections to the svg exporter for model_kind in self.model_kinds: modelInterface = getattr(models, 'I%s' % model_kind) def createViewModel(model, look): viewModelConstructor, model = self.primitiveRendererRegistry.getRendererConstructor( model) viewModel = viewModelConstructor() return viewModel, model serializer.viewModelCreatorRegistry.register( modelInterface, createViewModel) return serializer # register svg exporter, no importer defined self.serializerRegistry.register('svg', createSvgSerializer)