oliv wrote:

(NB : xpost et fu2 *fr.comp.objet*)

Tu connais le pattern Composite
non justement et je n'ai rien trouvé de clair sur le net pour m'éclairer sur ça.

Ah ? (...) Mouais, effectivement, c'est moyen faible...

tu peux m'expliquer ou me donner des liens vers des exemples simples.

Le mieux serait probablement de t'acheter le GoF (un des rares bouquins
d'informatique qui vaille l'investissement).

Rapidement: le but de ce pattern est de manipuler de façon uniforme des
objets 'simples' (feuilles) et des objets 'composés' (noeuds) (nb : oui,
c'est une arborescence...). Ces deux types d'objet présentent une
interface commune (spécifique à l'application of course). Les objets
composés implémentent les opérations définies par cette interface en
terme de délégation vers ses enfants (qu'ils soient simples ou composés !-)

Dans un logiciel de dessin vectoriel, par exemple (et tout à fait au
hasard...), les 'objets simples' sont les primitives (lignes, texte,
courbe, ...), et tout le reste est 'composé' à partir des primitives
(par exemple, un rectangle est composé de 4 lignes, une boite avec titre
est composée de deux rectangles et d'un texte, etc...)


En bref, on a

                 +----------------+
                 | <<interface>>  |
                 |   Composant    |
                 +----------------+
                 | +op1()         |   *
                 | +op2()         | <-------------------------+
                 +----------------+            childrens      |
                          ^                                   |
                          |                                   |
        +-----------------+-------------+                     |
        |                               |                     |
+--------------+         +-------------------------------+    |
|   Simple     |         | Composite                     |<>--+
+--------------+         +-------------------------------+
| +op1()       |         | +op1() :                      |
| +op2()       |         |   for child in self.childrens:|
+--------------+         |     child.op1()               |
                         | (idem pour op2())             |
                         +-------------------------------+




Evidemment, Composite doit avoir quelques opérations supplémentaires
pour ajouter/enlever des enfants...

Dans ton cas, les opérations seraient quelque chose comme:
- draw()
- move_to()
- move_by()

etc...

Après, tu te retrouve avec deux cas de figure:
- les objets composés 'statiques ' (contruits en dur dans ton appli, ie
rectangles etc)
- les objets composés 'dynamiques': par exemple quand un utilisateur
sélectionne un groupe d'objets pour les déplacer.

Pour le second cas, il te suffit d'avoir une classe composée
'Selection', que tu crée - et détruuit - à la demande.


Sérieusement, achète toi le GoF. Non seulement pour avoir les patterns
sous le coude - et pour ce que tu es en train de faire, je pense qu'il y
en a pas mal d'autres qui te serviront -, mais aussi parce que c'est un
des meilleurs ouvrages existant sur la conception objet.


--
bruno desthuilliers
python -c "print '@'.join(['.'.join([w[::-1] for w in p.split('.')]) for
p in 'onurb@xiludom.gro'.split('@')])"