Commande

// La classe de base commande définit une interface commune pour
// toutes les commandes concrètes.
abstract class Command is
    protected field app: Application
    protected field editor: Editor
    protected field backup: text

    constructor Command(app: Application, editor: Editor) is
        this.app = app
        this.editor = editor

    // Fait une sauvegarde de l’état de l’éditeur.
    method saveBackup() is
        backup = editor.text

    // Rétablit l’état de l’éditeur.
    method undo() is
        editor.text = backup

    // La méthode d’exécution est abstraite pour forcer les
    // commandes concrètes à fournir leurs propres
    // implémentations. La méthode doit retourner un booléen qui
    // indique si la commande a modifié l'état de l’éditeur.
    abstract method execute()


// Les commandes concrètes sont écrites ici.
class CopyCommand extends Command is
    // La commande pour copier n’est pas sauvegardée dans
    // l’historique, car elle ne modifie pas l'état de
    // l’éditeur.
    method execute() is
        app.clipboard = editor.getSelection()
        return false

class CutCommand extends Command is
    // La commande ‘couper’ change l’état de l’éditeur, elle
    // doit donc être sauvegardée dans l’historique. Elle sera
    // sauvegardée tant que la méthode renvoie vrai.
    method execute() is
        saveBackup()
        app.clipboard = editor.getSelection()
        editor.deleteSelection()
        return true

class PasteCommand extends Command is
    method execute() is
        saveBackup()
        editor.replaceSelection(app.clipboard)
        return true

// Le traitement ‘annuler’ est aussi une commande.
class UndoCommand extends Command is
    method execute() is
        app.undo()
        return false


// L’historique principal des commandes est juste une pile.
class CommandHistory is
    private field history: array of Command

    // Dernier entré...
    method push(c: Command) is
        // Pousse la commande à la fin du tableau de
        // l’historique.

    // ...premier sorti.
    method pop():Command is
        // Récupère la commande la plus récente de l’historique.


// La classe éditeur possède des fonctionnalités de traitement
// de texte. Elle joue le rôle du récepteur : toutes les
// commandes finissent par déléguer l’exécution aux méthodes de
// l’éditeur.
class Editor is
    field text: string

    method getSelection() is
        // Retourne le texte sélectionné.

    method deleteSelection() is
        // Supprime le texte sélectionné.

    method replaceSelection(text) is
        // Insère le contenu du presse-papiers à la position
        // actuelle.


// La classe application configure les relations de l’objet.
// Elle agit comme un demandeur : lorsque quelque chose doit
// être fait, elle crée un objet commande et lance son
// traitement.
class Application is
    field clipboard: string
    field editors: array of Editors
    field activeEditor: Editor
    field history: CommandHistory

    // Le code qui assigne les commandes à l’objet UI pourrait
    // ressembler à ceci.
    method createUI() is
        // ...
        copy = function() { executeCommand(
            new CopyCommand(this, activeEditor)) }
        copyButton.setCommand(copy)
        shortcuts.onKeyPress("Ctrl+C", copy)

        cut = function() { executeCommand(
            new CutCommand(this, activeEditor)) }
        cutButton.setCommand(cut)
        shortcuts.onKeyPress("Ctrl+X", cut)

        paste = function() { executeCommand(
            new PasteCommand(this, activeEditor)) }
        pasteButton.setCommand(paste)
        shortcuts.onKeyPress("Ctrl+V", paste)

        undo = function() { executeCommand(
            new UndoCommand(this, activeEditor)) }
        undoButton.setCommand(undo)
        shortcuts.onKeyPress("Ctrl+Z", undo)

    // Lance une commande et vérifie si elle doit être ajoutée à
    // l’historique.
    method executeCommand(command) is
        if (command.execute())
            history.push(command)

    // Prend la commande la plus récente dans l’historique et
    // lance sa méthode ‘annuler’. Vous remarquerez que nous ne
    // connaissons pas la classe de la commande. Nous n’avons
    // pas besoin de la connaître puisque la commande sait
    // comment annuler sa propre action.
    method undo() is
        command = history.pop()
        if (command != null)
            command.undo()