Changeset 12

Show
Ignore:
Timestamp:
12/24/07 19:03:20 (1 year ago)
Author:
skit
Message:

* Modification pydoc EventBroadcaster?
* Modification des classes View et Model vers AbstractView? et AbstractModel?
* Correction bug multiton des classes ModelLocator? et ViewLocator?
* Ajout import PluginListener? dans le package Pyxoo.Plugin.abstract

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • project/trunk/src/Pyxoo/Events/broadcaster.py

    r7 r12  
    8282 
    8383    def addEventListener(self, eventType, listener, *args): 
    84         """addEventListener(string, instance):boolean 
     84        """addEventListener(string, instance, ...):boolean 
    8585        Adds passed-in listener for receiving passed-in event type.""" 
    8686        if not Type.isString(eventType): 

  • project/trunk/src/Pyxoo/Model/locator.py

    r10 r12  
    2323 
    2424from Pyxoo.Core.locator import Locator 
    25 from Pyxoo.Model.model import Model 
     25from Pyxoo.Model.model import AbstractModel 
    2626from Pyxoo.Plugin.plugin import Plugin, NullPlugin 
    2727from Pyxoo.Log.stringifier import PyxooStringifier 
    …… 
    3131     
    3232    def __new__(cls, owner=NullPlugin()): 
     33        """__new__(Plugin):ModelLocator""" 
    3334        if not cls.__M.__contains__(owner): 
    34             tmp = object.__new__(cls, owner)  
    35             type(tmp).__init__(tmp, owner)            
     35            tmp = object.__new__(cls)  
     36            tmp.__init(owner)            
    3637            cls.__M.__setitem__(owner, tmp) 
    3738        return cls.__M.get(owner) 
    3839     
    39     def __init__(self, owner=NullPlugin()): 
    40         """__init__(Object) 
    41         Constructs a ModelLocator implementation.""" 
     40    def __init(self, owner=NullPlugin()): 
     41        """__init(Plugin) 
     42        Initialize ModelLocator implementation.""" 
    4243        if not isinstance(owner, Plugin): 
    4344            raise TypeError("owner param must be a Plugin") 
    …… 
    6869        """registerModel(String, Model):void 
    6970        Registers passed-in model associated to passed-in key."""  
    70         if  not isinstance(model, Model): 
     71        if  not isinstance(model, AbstractModel): 
    7172            raise TypeError("model param must be an instance of Model class.") 
     73        if self.isRegistered( key ): 
     74            return False 
    7275        self.__models.__setitem__(key, model) 
     76        return True 
    7377         
    7478    def unregisterModel(self,key):   

  • project/trunk/src/Pyxoo/Model/model.py

    r7 r12  
    2222__author__  = Pyxoo.__author__ 
    2323 
     24from Pyxoo.Events.broadcaster import EventBroadcaster 
     25from Pyxoo.Events.event import StringEvent 
     26from Pyxoo.Plugin.plugin import NullPlugin 
    2427 
    25 class Model: 
    26     def handleEvent(self, event): 
    27         raise NotImplementedError 
     28 
     29class AbstractModel: 
     30    onInitEVENT = "onInit" 
     31    __owner = None 
     32    __name  = None 
    2833     
    29     def onInit(self): 
    30         raise NotImplementedError 
     34    def __init__( self, owner=None, name=None ): 
     35        """__init__(Plugin, String)""" 
     36        self.__eventBroadcaster = EventBroadcaster( self ) 
     37        if owner:self.setOwner( owner ) 
     38        if name:self.setName( name ) 
    3139     
    32     def notifyChanged(self, event): 
    33         raise NotImplementedError 
     40    def handleEvent( self, event ): 
     41        """handleEvent(IEvent):void""" 
     42        pass 
    3443     
    35     def release(self): 
    36         raise NotImplementedError 
     44    def onInit( self ): 
     45        """onInit():void""" 
     46        self.notifyChanged( StringEvent( AbstractModel.onInitEVENT, self.getName() ) ) 
    3747     
    38     def getOwner(self): 
    39         raise NotImplementedError 
     48    def notifyChanged( self, event ): 
     49        """notifyChanged(IEvent):void""" 
     50        self.__eventBroadcaster.broadcast( event ) 
    4051     
    41     def setOwner(self, owner): 
    42         raise NotImplementedError 
     52    def release( self ): 
     53        """release():void""" 
     54        self.__eventBroadcaster.removeAllListeners() 
     55        from Pyxoo.Model.locator import ModelLocator 
     56        ModelLocator( self.getOwner() ).unregisterModel( self.getName() ) 
     57        self.__name = None 
    4358     
    44     def getName(self): 
    45         raise NotImplementedError 
     59    def getOwner( self ): 
     60        """getOwner():Plugin""" 
     61        return self.__owner 
    4662     
    47     def setName(self, name): 
    48         raise NotImplementedError 
     63    def setOwner( self, owner ): 
     64        """setOwner(Plugin):void""" 
     65        if owner: 
     66            if not isinstance( owner, Plugin ): 
     67                raise TypeError( "owner parameter must be a Plugin instance" ) 
     68            self.__owner = owner 
     69        else: 
     70            self.__owner = NullPlugin() 
     71     
     72    def getName( self ): 
     73        """getName():String""" 
     74        return self.__name 
     75     
     76    def setName( self, name ): 
     77        """setName(String):void""" 
     78        from Pyxoo.Model.locator import ModelLocator 
     79        modelLocator = ModelLocator( self.getOwner() ) 
     80        if not modelLocator.isRegistered( name ): 
     81            if modelLocator.isRegistered( self.getName() ): 
     82                modelLocator.unregisterModel( self.getName() ) 
     83            if modelLocator.registerModel( name, self ): 
     84                self.__name = name 
     85 
     86    def addListener( self, listener ): 
     87        """addListener(object):boolean""" 
     88        return self.__eventBroadcaster.addListener( listener ) 
     89         
     90    def removeListener( self, listener ): 
     91        """removeListener(object):boolean""" 
     92        return self.__eventBroadcaster.removeListener( listener ) 
     93     
     94    def addEventListener( self, eventType, listener, *args ): 
     95        """addEventListener(String, object, ...):boolean""" 
     96        return self.__eventBroadcaster.addEventListener( eventType, listener, *args ) 
     97     
     98    def removeEventListener( self, eventType, listener ): 
     99        """removeEventListener(String, object):boolean""" 
     100        return self.__eventBroadcaster.removeEventListener( eventType, listener ) 
     101     
     102    def _getBroadcaster( self ): 
     103        """_getBroadcaster():EventBroadcaster""" 
     104        return self.__eventBroadcaster 
     105     
     106    def _fireprivateEvent( self, event ): 
     107        """_fireprivateEvent(IEvent):void""" 
     108        self.getOwner().firePrivateEvent( event ) 
     109         

  • project/trunk/src/Pyxoo/Plugin/abstract.py

    r9 r12  
    2525from Pyxoo.Model.locator import ModelLocator 
    2626from Pyxoo.View.locator import ViewLocator 
    27 from Pyxoo.Plugin.plugin import Plugin 
     27from Pyxoo.Plugin.plugin import Plugin, PluginListener 
    2828from Pyxoo.Plugin.channel import ChannelExpert 
    2929from Pyxoo.Events.event import BasicEvent  

  • project/trunk/src/Pyxoo/View/locator.py

    r10 r12  
    2323 
    2424from Pyxoo.Core.locator import Locator 
    25 from Pyxoo.View.view import View 
     25from Pyxoo.View.view import AbstractView 
    2626from Pyxoo.Plugin import plugin 
    2727from Pyxoo.Log.stringifier import PyxooStringifier 
    …… 
    3131     
    3232    def __new__(cls, owner=plugin.NullPlugin()): 
     33        """__new__(Plugin):ViewLocator""" 
    3334        if not cls.__M.__contains__(owner): 
    34             tmp = object.__new__(cls, owner)  
    35             type(tmp).__init__(tmp, owner)            
     35            tmp = object.__new__(cls)  
     36            tmp.__init(owner)            
    3637            cls.__M.__setitem__(owner, tmp) 
    3738        return cls.__M.get(owner) 
    3839             
    39     def __init__(self, owner=plugin.NullPlugin()): 
    40         """__init__(Plugin) 
    41         Constructs a ViewLocator implementation.""" 
     40    def __init(self, owner=plugin.NullPlugin()): 
     41        """__init(Plugin) 
     42        Initialize a ViewLocator implementation.""" 
    4243        if not isinstance(owner, plugin.Plugin): 
    4344            raise TypeError("owner param must be a Plugin") 
    …… 
    6667         
    6768    def registerView(self, key, view): 
    68         """registerView(string, View):void 
     69        """registerView(string, View):boolean 
    6970        Registers passed-in view associated to passed-in key."""  
    70         if  not isinstance(view, View): 
     71        if  not isinstance(view, AbstractView): 
    7172            raise TypeError("view param must be an instance of View class.") 
    72         self.__views.__setitem__(key, view) 
     73        if self.isRegistered(key): 
     74            return False 
     75        else: 
     76            self.__views.__setitem__(key, view) 
     77            return True 
    7378         
    7479    def unregisterView(self, key): 

  • project/trunk/src/Pyxoo/View/view.py

    r7 r12  
    2222__author__  = Pyxoo.__author__ 
    2323 
     24from Pyxoo.Plugin.plugin import Plugin 
     25from Pyxoo.Events.broadcaster import EventBroadcaster 
     26from Pyxoo.Utils import Type 
    2427 
    25 class View: 
    26     def handleEvent(self, event): 
    27         raise NotImplementedError 
     28class AbstractView: 
     29    __owner = None 
     30    __name  = None 
    2831     
    29     def onInit(self): 
    30         raise NotImplementedError 
     32    def __init__( self, owner=None, name=None ): 
     33        """__init__(Plugin, String)""" 
     34        self.__eventBroadcaster = EventBroadcaster( self ) 
     35        if owner:self.setOwner( owner ) 
     36        if name:self._initAbstractView( name ) 
    3137     
    32     def notifyChanged(self, event): 
    33         raise NotImplementedError 
     38    def handleEvent( self, event ): 
     39        """handleEvent(IEvent):void""" 
     40        pass 
    3441     
    35     def release(self): 
    36         raise NotImplementedError 
     42    def onInit( self ): 
     43        """onInit():void""" 
     44        pass 
    3745     
    38     def getOwner(self): 
    39         raise NotImplementedError 
     46    def notifyChanged( self, event ): 
     47        """notifyChanged(IEvent):void""" 
     48        self._getBroadcaster().broadcastEvent( event ) 
    4049     
    41     def setOwner(self, owner): 
    42         raise NotImplementedError 
     50    def release( self ): 
     51        """release():void""" 
     52        self._getBroadcaster().removeAllListeners() 
     53        from Pyxoo.View.locator import ViewLocator 
     54        ViewLocator( self.getOwner() ).unregisterView( self.getName() ) 
    4355     
    44     def getName(self): 
    45         raise NotImplementedError 
     56    def getOwner( self ): 
     57        """getOwner():Plugin""" 
     58        return self.__owner 
    4659     
    47     def setName(self, name): 
    48         raise NotImplementedError 
     60    def setOwner( self, owner ): 
     61        """setOwner(Plugin):void""" 
     62        if not isinstance( owner, Plugin ): 
     63            raise TypeError( "owner param must be a Plugin" )  
     64        self.__owner = owner 
     65     
     66    def getName( self ): 
     67        """getName():String""" 
     68        return self.__name 
     69     
     70    def setName( self, name ): 
     71        """setName(String):void""" 
     72        if not Type.isString( name ): 
     73            raise TypeError( "name param must be a String" )  
     74        from Pyxoo.View.locator import ViewLocator 
     75        locator = ViewLocator( self.getOwner() ) 
     76        if name and not locator.isRegistered( name ): 
     77            if locator.isRegistered( self.getName() ): 
     78                locator.unregisterView( self.getName() ) 
     79            if locator.registerView( name, self ): 
     80                self.__name = name 
     81         
     82    def addListener( self, listener ): 
     83        """addListener(object):boolean""" 
     84        return self.__eventBroadcaster.addListener( listener ) 
     85         
     86    def removeListener( self, listener ): 
     87        """removeListener(listener):boolean""" 
     88        return self.__eventBroadcaster.removeListener( listener ) 
     89     
     90    def addEventListener( self, eventType, listener, *args ): 
     91        """addEventListener(String, object, ...):boolean""" 
     92        return self.__eventBroadcaster.addEventListener( eventType, listener, *args ) 
     93     
     94    def removeEventListener( self, eventType, listener ): 
     95        """removeEventListener(String, object):boolean""" 
     96        return self.__eventBroadcaster.removeEventListener( eventType, listener ) 
     97     
     98    def _initAbstractView( self, name ): 
     99        """_initAbstractView(String):void""" 
     100        self.setName( name ) 
     101        self.onInit() 
     102     
     103    def _getBroadcaster( self ): 
     104        """_getBroadcaster():EventBroadcaster""" 
     105        return self.__eventBroadcaster 
     106     
     107    def _fireprivateEvent( self, event ): 
     108        """_fireprivateEvent(IEvent):void""" 
     109        self.getOwner().firePrivateEvent( event ) 

  • project/trunk/test/model/TestModelLocator.py

    r7 r12  
    2121 
    2222 
    23 from Pyxoo.Model.model import Model 
     23from Pyxoo.Model.model import AbstractModel 
    2424from Pyxoo.Model.locator import ModelLocator 
    2525from Pyxoo.Plugin.plugin import Plugin 
    …… 
    2828    def setUp(self): 
    2929        self.instance = ModelLocator() 
    30         self.m1 = Model() 
    31         self.m2 = Model() 
     30        self.m1 = AbstractModel() 
     31        self.m2 = AbstractModel() 
    3232        class A:pass 
    3333        self.otherObject = A() 
    …… 
    3636        self.assertTrue(id(self.instance) == id(ModelLocator())) 
    3737        self.assertFalse(id(self.instance) == id( ModelLocator(Plugin()))) 
    38      
     38        pluginA, pluginB = Plugin(), Plugin() 
     39        self.assertTrue( id( ModelLocator( pluginA ) ) == id( ModelLocator( pluginA ) ) ) 
     40        self.assertFalse( id( ModelLocator( pluginA ) ) == id( ModelLocator( pluginB ) ) ) 
     41 
    3942    def testRegisterModel(self): 
    4043        self.instance.registerModel("m1", self.m1) 
    4144        self.assertRaises( TypeError, self.instance.registerModel, "mX", self.otherObject) 
    4245        self.assertTrue( self.instance.isRegistered("m1") ) 
     46         
     47    def testRegisterModelWithPlugin(self): 
     48        pluginA, pluginB = Plugin(), Plugin() 
     49        self.assertTrue( ModelLocator( pluginA ).registerModel( "v1", self.m1 ) ) 
     50        self.assertFalse( ModelLocator( pluginA ).registerModel( "v1", self.m1 ) ) 
     51        self.assertTrue( ModelLocator( pluginB ).registerModel( "v1", self.m1 ) ) 
     52        self.assertFalse( ModelLocator( pluginB ).registerModel( "v1", self.m1 ) ) 
    4353         
    4454    def testUnregisterModel(self): 

  • project/trunk/test/view/TestViewLocator.py

    r7 r12  
    2121 
    2222 
    23 from Pyxoo.View.view import View 
     23from Pyxoo.View.view import AbstractView 
    2424from Pyxoo.View.locator import ViewLocator 
    2525from Pyxoo.Plugin.plugin import Plugin 
    2626 
    27 class TestViewLocator(unittest.TestCase): 
    28     def setUp(self): 
     27class TestViewLocator( unittest.TestCase ): 
     28    def setUp( self ): 
    2929        self.instance = ViewLocator() 
    30         self.view = View() 
     30        self.view = AbstractView() 
    3131        class A:pass 
    3232        self.otherObject = A() 
    3333         
    34     def testMultiTon(self): 
    35         self.assertTrue(id(self.instance) == id(ViewLocator())) 
    36         self.assertFalse(id(self.instance) == id(ViewLocator(Plugin()))) 
     34    def testMultiTon( self ): 
     35        self.assertTrue( id( self.instance ) == id( ViewLocator() ) ) 
     36        self.assertFalse( id( self.instance ) == id( ViewLocator( Plugin() ) ) )         
     37        pluginA, pluginB = Plugin(), Plugin() 
     38        self.assertTrue( id( ViewLocator( pluginA ) ) == id( ViewLocator( pluginA ) ) ) 
     39        self.assertFalse( id( ViewLocator( pluginA ) ) == id( ViewLocator( pluginB ) ) ) 
     40         
    3741                         
    38     def testRegisterView(self): 
    39         self.instance.registerView("aKey", self.view) 
    40         self.assertRaises( TypeError, self.instance.registerView, "aSecondKey", self.otherObject) 
    41         self.assertTrue( self.instance.isRegistered("aKey") ) 
     42    def testRegisterView( self ): 
     43        self.assertTrue(self.instance.registerView( "aKey", self.view )) 
     44        self.assertFalse(self.instance.registerView( "aKey", self.view )) 
     45        self.assertRaises( TypeError, self.instance.registerView, "aSecondKey", self.otherObject ) 
     46        self.assertTrue( self.instance.isRegistered( "aKey" ) ) 
    4247         
    43     def testUnregisterView(self): 
    44         self.instance.registerView("v1", self.view) 
    45         self.instance.registerView("v2", View()) 
    46         self.assertTrue( self.instance.isRegistered("v1") ) 
    47         self.assertTrue( self.instance.isRegistered("v2") ) 
    48         self.instance.unregisterView("v1") 
    49         self.assertFalse( self.instance.isRegistered("v1") ) 
    50         self.assertTrue( self.instance.isRegistered("v2") ) 
     48    def testResgisterViewWithPlugin( self ): 
     49        pluginA, pluginB = Plugin(), Plugin() 
     50        self.assertTrue( ViewLocator( pluginA ).registerView( "v1", self.view ) ) 
     51        self.assertFalse( ViewLocator( pluginA ).registerView( "v1", self.view ) ) 
     52        self.assertTrue( ViewLocator( pluginB ).registerView( "v1", self.view ) ) 
     53        self.assertFalse( ViewLocator( pluginB ).registerView( "v1", self.view ) ) 
    5154         
    52     def testLocate(self):         
    53         self.instance.registerView("v1", self.view) 
    54         v2 = View() 
    55         self.instance.registerView("v2", v2) 
    56         self.assertEquals( self.view, self.instance.locate("v1") ) 
    57         self.assertEquals( v2, self.instance.locate("v2") ) 
    58         self.instance.unregisterView("v1") 
    59         self.assertEquals( None, self.instance.locate("v1") )         
     55    def testUnregisterView( self ): 
     56        self.instance.registerView( "v1", self.view ) 
     57        self.instance.registerView( "v2", AbstractView() ) 
     58        self.assertTrue( self.instance.isRegistered( "v1" ) ) 
     59        self.assertTrue( self.instance.isRegistered( "v2" ) ) 
     60        self.instance.unregisterView( "v1" ) 
     61        self.assertFalse( self.instance.isRegistered( "v1" ) ) 
     62        self.assertTrue( self.instance.isRegistered( "v2" ) ) 
     63         
     64    def testLocate( self ):         
     65        self.instance.registerView( "v1", self.view ) 
     66        v2 = AbstractView() 
     67        self.instance.registerView( "v2", v2 ) 
     68        self.assertEquals( self.view, self.instance.locate( "v1" ) ) 
     69        self.assertEquals( v2, self.instance.locate( "v2" ) ) 
     70        self.instance.unregisterView( "v1" ) 
     71        self.assertEquals( None, self.instance.locate( "v1" ) )