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)
