Composite

// L’interface du composant déclare des opérations communes pour
// les objets simples et complexes d’une composition.
interface Graphic is
    method move(x, y)
    method draw()

// La classe feuille représente les objets finaux d’une
// composition. Un objet feuille ne peut pas avoir de sous-
// objets. En général, ce sont les feuilles qui lancent les
// traitements. Les objets composite ne font que déléguer le
// travail à leurs sous-composants.
class Dot implements Graphic is
    field x, y

    constructor Dot(x, y) { ... }

    method move(x, y) is
        this.x += x, this.y += y

    method draw() is
        // Dessine un point aux coordonnées X et Y.

// Toutes les classes composant peuvent étendre d’autres
// composants.
class Circle extends Dot is
    field radius

    constructor Circle(x, y, radius) { ... }

    method draw() is
        // Trace un cercle de rayon R aux coordonnées X et Y.

// La classe composite représente les composants complexes qui
// peuvent avoir des enfants. Les objets composite délèguent
// généralement les tâches à leurs enfants et « additionnent »
// ensuite le résultat.
class CompoundGraphic implements Graphic is
    field children: array of Graphic

    // Un composite peut ajouter ou retirer d’autres composants
    // (simples ou complexes) de la liste de ses enfants.
    method add(child: Graphic) is
        // Ajoute un enfant au tableau d’enfants.

    method remove(child: Graphic) is
        // Retire un enfant du tableau d’enfants.

    method move(x, y) is
        foreach (child in children) do
            child.move(x, y)

    // Un composite exécute sa logique principale d’une certaine
    // manière : il parcourt récursivement tous ses enfants,
    // puis récupère et additionne leurs résultats. L’objet est
    // entièrement parcouru, car les enfants du composite
    // passent ces appels à leurs propres enfants et ainsi de
    // suite.
    method draw() is
        // 1. Pour chaque composant enfant :
        //     - Dessine le composant.
        //     - Met à jour le rectangle de délimitation.
        // 2. Dessine un rectangle en pointillé en utilisant les
        // coordonnées de la délimitation.


// Le code client manipule les composants grâce à leur interface
// de base. Ainsi, le code client peut aussi bien prendre en
// charge les composants simples que les complexes.
class ImageEditor is
    field all: CompoundGraphic

    method load() is
        all = new CompoundGraphic()
        all.add(new Dot(1, 2))
        all.add(new Circle(5, 3, 10))
        // ...

    // Combine les composants sélectionnés en un seul composant
    // complexe.
    method groupSelected(components: array of Graphic) is
        group = new CompoundGraphic()
        foreach (component in components) do
            group.add(component)
            all.remove(component)
        all.add(group)
        // Tous les composants vont être dessinés.
        all.draw()