def initialize_model(self):
"""
Initialize the C{Model}.
Called by the C{initializeFacade} method.
Override this method in your subclass of C{Facade}
if one or both of the following are true:
You wish to initialize a different C{IModel}.
You have C{Proxy}s to register with the Model that do not
retrieve a reference to the Facade at construction time.
If you don't want to initialize a different C{IModel},
call C{super.initialize_model()} at the beginning of your
method, then register C{Proxy}s.
Note: This method is I{rarely} overridden; in practice you are more
likely to use a C{Command} to create and register C{Proxy}s
with the C{Model}, since C{Proxy}s with mutable data will likely
need to send C{INotification}s and thus will likely want to fetch a reference to
the C{Facade} during their construction.
"""
if self.model is None:
self.model = Model(self.multiton_key)
class Facade(IFacade):
"""
A base Singleton C{IFacade} implementation.
In PureMVC, the C{Facade} class assumes these
responsibilities:
Initializing the C{Model}, C{View} and C{Controller} Singletons.
Providing all the methods defined by the C{IModel, IView, & IController} interfaces.
Providing the ability to override the specific C{Model}, C{View} and C{Controller} Singletons created.
Providing a single point of contact to the application for registering C{Commands} and notifying C{Observers}
@see: L{Model<org.puremvc_multicore.as3.core.model.Model>}
@see: L{View<org.puremvc_multicore.as3.core.view.View>}
@see: L{Controller<org.puremvc_multicore.as3.core.controller.Controller>}
@see: L{Notification<org.puremvc_multicore.as3.patterns.observer.Notification>}
@see: L{Mediator<org.puremvc_multicore.as3.patterns.mediator.Mediator>}
@see: L{Proxy<org.puremvc_multicore.as3.patterns.proxy.Proxy>}
@see: L{SimpleCommand<org.puremvc_multicore.as3.patterns.command.SimpleCommand>}
@see: L{MacroCommand<org.puremvc_multicore.as3.patterns.command.MacroCommand>}
"""
__metaclass__ = FacadeMeta
controller = None
model = None
view = None
def __init__(self, key):
"""
Initialize the Singleton C{Facade} instance.
Called automatically by the constructor. Override in your
subclass to do any subclass specific initializations. Be
sure to call C{Facade.initializeFacade()}, though.
"""
self.initialize_notifier(key)
self.initialize_controller()
self.initialize_model()
self.initialize_view()
def initialize_controller(self):
"""
Initialize the C{Controller}.
Called by the C{initializeFacade} method.
Override this method in your subclass of C{Facade}
if one or both of the following are true:
You wish to initialize a different C{IController}.
You have C{Commands} to register with the C{Controller} at startup.
If you don't want to initialize a different C{IController},
call C{super.initialize_controller()} at the beginning of your method, then register C{Proxy}s.
Note: This method is I{rarely} overridden; in practice you are more
likely to use a C{Command} to create and register C{Proxy}s
with the C{Model}, since C{Proxy}s with mutable data will likely
need to send C{INotification}s and thus will likely want to fetch a reference to
the C{Facade} during their construction.
"""
if self.controller is None:
self.controller = Controller(self.multiton_key)
def initialize_model(self):
"""
Initialize the C{Model}.
Called by the C{initializeFacade} method.
Override this method in your subclass of C{Facade}
if one or both of the following are true:
You wish to initialize a different C{IModel}.
You have C{Proxy}s to register with the Model that do not
retrieve a reference to the Facade at construction time.
If you don't want to initialize a different C{IModel},
call C{super.initialize_model()} at the beginning of your
method, then register C{Proxy}s.
Note: This method is I{rarely} overridden; in practice you are more
likely to use a C{Command} to create and register C{Proxy}s
with the C{Model}, since C{Proxy}s with mutable data will likely
need to send C{INotification}s and thus will likely want to fetch a reference to
the C{Facade} during their construction.
"""
if self.model is None:
self.model = Model(self.multiton_key)
def initialize_view(self):
"""
Initialize the C{View}.
Called by the C{initializeFacade} method.
Override this method in your subclass of C{Facade}
if one or both of the following are true:
You wish to initialize a different C{IView}.
You have C{Observers} to register with the C{View}
If you don't want to initialize a different C{IView},
call C{super.initialize_view()} at the beginning of your
method, then register C{IMediator} instances.
Note: This method is I{rarely} overridden; in practice you are more
likely to use a C{Command} to create and register C{Mediator}s
with the C{View}, since C{IMediator} instances will need to send
C{INotification}s and thus will likely want to fetch a reference
to the C{Facade} during their construction.
"""
if self.view is None:
self.view = View(self.multiton_key)
def register_command(self, notificationName, command_class_ref):
"""
Register an C{ICommand} with the C{Controller} by Notification name.
@param notificationName: the name of the C{INotification} to associate the C{ICommand} with
@param command_class_ref: a reference to the Class of the C{ICommand}
"""
self.controller.register_command(notificationName, command_class_ref)
def remove_command(self, notification_name):
"""
Remove a previously registered C{ICommand} to C{INotification} mapping from the Controller.
@param notification_name: the name of the C{INotification} to remove the C{ICommand} mapping for
"""
self.controller.remove_command(notification_name)
def has_command(self, notification_name):
"""
Check if a Command is registered for a given Notification
@param notification_name: the name of the C{INotification}
@return: whether a Command is currently registered for the given C{notification_name}.
"""
return self.controller.has_command(notification_name)
def register_proxy(self, proxy):
"""
Register an C{IProxy} with the C{Model} by name.
@param proxy: the C{IProxy} instance to be registered with the C{Model}.
"""
self.model.register_proxy(proxy)
def retrieve_proxy(self, proxy_name):
"""
Retrieve an C{IProxy} from the C{Model} by name.
@param proxy_name: the name of the proxy to be retrieved.
@return: the C{IProxy} instance previously registered with the given C{proxy_name}.
"""
return self.model.retrieve_proxy(proxy_name)
def remove_proxy(self, proxy_name):
"""
Remove an C{IProxy} from the C{Model} by name.
@param proxy_name: the C{IProxy} to remove from the C{Model}.
@return: the C{IProxy} that was removed from the C{Model}
"""
proxy = None
if self.model is not None:
proxy = self.model.remove_proxy(proxy_name)
return proxy
def has_proxy(self, proxy_name):
"""
Check if a Proxy is registered
@param proxy_name: the name of the C{IProxy}
@return: whether a Proxy is currently registered with the given C{proxy_name}.
"""
return self.model.has_proxy(proxy_name)
def register_mediator(self, mediator):
"""
Register a C{IMediator} with the C{View}.
@param mediator: a reference to the C{IMediator}
"""
if self.view is not None:
self.view.register_mediator(mediator)
def retrieve_mediator(self, mediator_name):
"""
Retrieve an C{IMediator} from the C{View}.
@param mediator_name: the name of the C{IMediator}
@return: the C{IMediator} previously registered with the given C{mediator_name}.
"""
return self.view.retrieve_mediator(mediator_name)
def remove_mediator(self, mediator_name):
"""
Remove an C{IMediator} from the C{View}.
@param mediator_name: name of the C{IMediator} to be removed.
@return: the C{IMediator} that was removed from the C{View}
"""
mediator = None
if self.view is not None:
mediator = self.view.remove_mediator(mediator_name)
return mediator
def has_mediator(self, mediator_name):
"""
Check if a Mediator is registered or not
@param mediator_name: the name of the C{IMediator}
@return: whether a Mediator is registered with the given C{mediator_name}.
"""
return self.view.has_mediator(mediator_name)
def send_notification(self, notification_name, body=None, type=None):
"""
Create and send an C{INotification}.
Keeps us from having to construct new notification
instances in our implementation code.
@param notification_name: the name of the notification to send
@param body: the body of the notification (optional)
@param type: the type of the notification (optional)
"""
self.notify_observers(Notification(notification_name, body, type))
def notify_observers(self, notification):
"""
Notify C{Observer}s.
This method is left public mostly for backward
compatibility, and to allow you to send custom
notification classes using the facade.
Usually you should just call send_notification
and pass the parameters, never having to
construct the notification yourself.
@param notification: the C{INotification} to have the C{View} notify C{Observers} of.
"""
if self.view is not None:
self.view.notify_observers(notification)
def initialize_notifier(self, key):
self.multiton_key = key
