Discussion :

[Antoine_935]

Salut à tous.

Créer un proxy pour une méthode n'est pas difficile, mais qu'en est-il pour les proxys de properties ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
>>> class Prop(object):
...     def __init__(self):
...         self.__model = None
...     
...     def getModel(self):
...         return self.__model
...     
...     def setModel(self):
...         self.__model = model
...     
...     model = property(getModel, setModel)
... 
>>> class Prox:
...     def __init__(self):
...         self.__prop = Prop()
...         
...         # On peu facilement faire des proxy pour fonctions
...         self.propGetModel = self.__prop.getModel
... 
...     # Comment faire un proxy pour les properties de self.__prop ?
...     # Autrement dit, comment emuler le code ci-dessous, mais version propre...
...     def getPropModel(self):
...         return self.__prop.model
...     
...     def setPropModel(self, new):
...         self.__prop.model = new
...     
...     propModel = property(getPropModel, setPropModel)

[Pragmateek]

Dans le cas présenté n'y a t'il pas moyen de procéder par héritage afin que le proxy hérite des propriétés ?

[Antoine_935]

Dans ce cas-ci, effectivement, l'héritage est une bonne solution, mais dans le contexte dans lequel je suis, je n'y ai pas droit.

Le contexte en question, c'est un pattern Observer, ou plus précisément du MVC.
Par exemple, un widget Button sera lié à un ButtonModel, qui pourra être partagé avec d'autres Button. C'est ce qui m'empêche de me servir de l'héritage.

[Pragmateek]

Pourriez vous donner plus de détails sur la finalité, afin de vérifier qu'un proxy est bien une solution conceptuellement viable et qu'il n'en existe pas de meilleure ?

[Antoine_935]

Voici un résumé de l'implémentation (la totale serait bcp trop longue).
Elle se calque assez précisément sur le MVC de Swing, que j'apprécie beaucoup et qui me manque atrocement avec gtk.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
class ButtonModel(object):
    def __init__(self, text):
        self.__text = text
 
 
    def getText(self):
        return self.__text
 
    def setText(self, new):
        self.__text = new
        self._fireChangeEvent()
 
    text = property(getText, setText)
 
 
    def _fireChangeEvent():
        # Methode qui envoie un event à chaque Observer enregistré
        # par leur methode stateChanged
 
class Button:
    def __init__(self, model):
        self.__model = model
        self.__update()
 
    def stateChanged(self, e):
        self.__update()
 
    def __update(self):
        # Met a jour le label du bouton selon le modèle
        self.set_label(self.__model.text)
 
    # Il me faudrait ici une sorte de proxy de la property model.text
    # de manière à ce que le changement du label d'un bouton
    # soit répercuté sur tous les autres.

[Pragmateek]

Pas sûr que ce soit ça, mais une solution serait que :
- tous les composants dont l'état doit être tracé soient "Observable" : le modèle et les boutons,
- un contrôleur soit Observer de ceux-ci et demande aux autres contrôles, les boutons, de se mettre à jour, via "__update".

Ainsi :
- si le modèle est changé il prévient le contrôleur qui va invoquer la méthode "__update" de tous les boutons dont il a la charge,
- si le texte d'un bouton est changé, le bouton prévient le contrôleur qui ira update le modèle, à partir de là c'est comme pour le cas précédent.

Cependant si tous les boutons doivent être synchronisés, pourquoi peuvent-ils être modifiés indépendamment ?