Changeset 1362

Show
Ignore:
Timestamp:
06/12/07 01:00:25 (1 year ago)
Author:
arj..@yirdis.nl
Message:

Added register and unregister methods to application.py for adapters, subscription adapters and handlers. Those methods should replace zope.components' provide* methods.

Also modified services, so they unregister their handlers properly.

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • gaphor/trunk/gaphor/application.py

    r1301 r1362  
    1818 
    1919class _Application(object): 
     20    """ 
     21    The Gaphor application is started from the Application instance. It behaves 
     22    as a singleton in many ways. 
     23 
     24    The Application is responsible for loading services and plugins. Services 
     25    are registered as "utilities" in a global registry. 
     26 
     27    Methods are provided that wrap zope.component's handle, adapter and 
     28    subscription registrations. In addition to registration methods also 
     29    unregister methods are provided. This way services can be properly 
     30    unregistered on shutdown for example. 
     31    """ 
    2032 
    2133    # interface.implements(IApplication) 
     
    2335    def __init__(self): 
    2436        self._uninitialized_services = {} 
     37        self.globalSiteManager = component.getGlobalSiteManager() 
    2538 
    2639    def init(self, services=None): 
     
    6578            log.info('initializing service service.%s' % name) 
    6679            srv.init(self) 
    67             component.provideUtility(srv, IService, name) 
    68             component.handle(ServiceInitializedEvent(name, srv)) 
     80            self.globalSiteManager.registerUtility(srv, IService, name) 
     81            self.handle(ServiceInitializedEvent(name, srv)) 
    6982            return srv 
    7083 
     
    7487    def get_service(self, name): 
    7588        try: 
    76             return component.getUtility(IService, name) 
     89            return self.globalSiteManager.getUtility(IService, name) 
    7790        except component.ComponentLookupError: 
    7891            return self.init_service(name) 
     
    8396 
    8497    def shutdown(self): 
    85         for name, srv in component.getUtilitiesFor(IService): 
     98        for name, srv in self.globalSiteManager.getUtilitiesFor(IService): 
    8699            srv.shutdown() 
    87             component.handle(ServiceShutdownEvent(name, srv)) 
     100            self.handle(ServiceShutdownEvent(name, srv)) 
     101            self.globalSiteManager.unregisterUtility(srv, IService, name) 
    88102 
    89103        # Re-initialize Zope's global site manager 
    90104        # (cleanup adapters and utilities): 
    91105        try: 
    92             from zope.component import globalSiteManager 
    93             globalSiteManager.__init__('base') 
     106            self.globalSiteManager.__init__('base') 
    94107        except Exception, e: 
    95108            log.error('Re-initialization of the Zope SiteManager failed', e) 
    96109        self.__init__() 
     110 
     111    # Wrap zope.component's SiteManager methods 
     112 
     113    def registerAdapter(self, factory, adapts=None, provides=None, name=''): 
     114        """ 
     115        Register an adapter (factory) that adapts objects to a specific 
     116        interface. A name can be used to distinguish between different adapters 
     117        that adapt to the same interfaces. 
     118        """ 
     119        self.globalSiteManager.registerAdapter(factory, adapts, provides, 
     120                              name, event=False) 
     121 
     122    def unregisterAdapter(self, factory=None, 
     123                          required=None, provided=None, name=u''): 
     124        """ 
     125        Unregister a previously registered adapter. 
     126        """ 
     127        self.globalSiteManager.unregisterAdapter(factory, 
     128                              required, provided, name) 
     129 
     130    def registerSubscriptionAdapter(self, factory, adapts=None, provides=None): 
     131        """ 
     132        Register a subscription adapter. See registerAdapter(). 
     133        """ 
     134        self.globalSiteManager.registerSubscriptionAdapter(factory, adapts, 
     135                              provides, event=False) 
     136 
     137    def unregisterSubscriptionAdapter(self, factory=None, 
     138                          required=None, provided=None, name=u''): 
     139        """ 
     140        Unregister a previously registered subscription adapter. 
     141        """ 
     142        self.globalSiteManager.unregisterSubscriptionAdapter(factory, 
     143                              required, provided, name) 
     144 
     145    def registerHandler(self, factory, adapts=None): 
     146        """ 
     147        Register a handler. Handlers are triggered (executed) when specific 
     148        events are emited through the handle() method. 
     149        """ 
     150        self.globalSiteManager.registerHandler(factory, adapts, event=False) 
     151 
     152    def unregisterHandler(self, factory=None, required=None): 
     153        """ 
     154        Unregister a previously registered handler. 
     155        """ 
     156        self.globalSiteManager.unregisterHandler(factory, required) 
     157  
     158    def handle(self, *objects): 
     159        """ 
     160        Send event notifications to registered handlers. 
     161        """ 
     162        self.globalSiteManager.handle(*objects) 
    97163 
    98164# Make sure there is only one! 
  • gaphor/trunk/gaphor/services/actionmanager.py

    r1301 r1362  
    2020 
    2121    def init(self, app): 
     22        self._app = app 
    2223        self.ui_manager = gtk.UIManager() 
    2324        log.info('Loading not yet registered action provider services') 
     
    2728                self.register_action_provider(service) 
    2829 
    29         component.provideHandler(self._service_initialized_handler) 
     30        app.registerHandler(self._service_initialized_handler) 
    3031 
    3132    def shutdown(self): 
    32         pass 
     33        self._app.unregisterHandler(self._service_initialized_handler) 
    3334 
    3435    def execute(self, action_id, active=None): 
  • gaphor/trunk/gaphor/services/copyservice.py

    r1301 r1362  
    5050 
    5151    def init(self, app): 
     52        self._app = app 
    5253        self.action_group.get_action('edit-copy').props.sensitive = False 
    5354        self.action_group.get_action('edit-paste').props.sensitive = False 
    5455         
    55         component.provideHandler(self._update) 
     56        app.registerHandler(self._update) 
    5657 
    5758    def shutdown(self): 
    5859        self.copy_buffer = set() 
     60        self._app.unregisterHandler(self._update) 
    5961 
    6062    @component.adapter(IDiagramSelectionChange) 
  • gaphor/trunk/gaphor/services/undomanager.py

    r1301 r1362  
    108108        self._current_transaction = None 
    109109        self._transaction_depth = 0 
     110        self.action_group = build_action_group(self) 
    110111 
    111112    def init(self, app): 
    112113        self._app = app 
    113         component.provideHandler(self.begin_transaction) 
    114         component.provideHandler(self.commit_transaction) 
    115         component.provideHandler(self.rollback_transaction) 
    116         component.provideHandler(self._action_executed) 
    117         self._provide_undo_handlers() 
    118         self.action_group = build_action_group(self) 
     114        app.registerHandler(self.begin_transaction) 
     115        app.registerHandler(self.commit_transaction) 
     116        app.registerHandler(self.rollback_transaction) 
     117        app.registerHandler(self._action_executed) 
     118        self._register_undo_handlers() 
    119119        self._action_executed(None) 
    120120 
    121121    def shutdown(self): 
    122         pass 
     122        self._app.unregisterHandler(self.begin_transaction) 
     123        self._app.unregisterHandler(self.commit_transaction) 
     124        self._app.unregisterHandler(self.rollback_transaction) 
     125        self._app.unregisterHandler(self._action_executed) 
     126        self._unregister_undo_handlers() 
    123127 
    124128    def clear_undo_stack(self): 
     
    254258    ## 
    255259 
    256     def _provide_undo_handlers(self): 
    257         component.provideHandler(self.undo_create_event) 
    258         component.provideHandler(self.undo_delete_event) 
    259         component.provideHandler(self.undo_attribute_change_event) 
    260         component.provideHandler(self.undo_association_set_event) 
    261         component.provideHandler(self.undo_association_add_event) 
    262         component.provideHandler(self.undo_association_delete_event) 
     260    def _undo_handler(self, event): 
     261        self.add_undo_action(lambda: state.saveapply(*event)); 
     262 
     263    def _register_undo_handlers(self): 
     264        self._app.registerHandler(self.undo_create_event) 
     265        self._app.registerHandler(self.undo_delete_event) 
     266        self._app.registerHandler(self.undo_attribute_change_event) 
     267        self._app.registerHandler(self.undo_association_set_event) 
     268        self._app.registerHandler(self.undo_association_add_event) 
     269        self._app.registerHandler(self.undo_association_delete_event) 
    263270 
    264271        # 
     
    267274        state.observers.add(state.revert_handler) 
    268275 
    269         def _undo_handler(event): 
    270             self.add_undo_action(lambda: state.saveapply(*event)); 
    271  
    272         state.subscribers.add(_undo_handler) 
    273  
     276        state.subscribers.add(self._undo_handler) 
     277 
     278    def _unregister_undo_handlers(self): 
     279        self._app.unregisterHandler(self.undo_create_event) 
     280        self._app.unregisterHandler(self.undo_delete_event) 
     281        self._app.unregisterHandler(self.undo_attribute_change_event) 
     282        self._app.unregisterHandler(self.undo_association_set_event) 
     283        self._app.unregisterHandler(self.undo_association_add_event) 
     284        self._app.unregisterHandler(self.undo_association_delete_event) 
     285 
     286        from gaphas import state 
     287        state.observers.discard(state.revert_handler) 
     288 
     289        state.subscribers.discard(self._undo_handler) 
    274290 
    275291    @component.adapter(IElementCreateEvent) 
  • gaphor/trunk/gaphor/tests/test_application.py

    r1247 r1362  
    2222        Application.load_services() 
    2323        assert Application.get_service('undo_manager') 
    24         assert Application.get_service('plugin_manager') 
     24        assert Application.get_service('file_manager') 
    2525 
    2626        # After that, services are also available as Utilities: 
    2727        assert component.queryUtility(IService, 'undo_manager') 
    28         assert component.queryUtility(IService, 'plugin_manager') 
     28        assert component.queryUtility(IService, 'file_manager') 
    2929 
    3030 
  • gaphor/trunk/gaphor/ui/diagramtoolbox.py

    r1293 r1362  
    9595        """ 
    9696        tool = list(itemiter(TOOLBOX_ACTIONS))[id][0] 
    97         log.info('Selected item %d: %s' % (id, tool)) 
    9897        getattr(self, tool.replace('-', '_'))() 
    9998