macht in Python rückgängig machen

Question

vor allem .. sorry, wenn mein Englisch war schlecht. seine meine dritte Sprache
im arbeitet an einem Lack-Software, die über Bilder zeichnen und speichern Sie sie erneut (zur Kommentierung schlagen)
i verwenden Haufen und wxpython. aber im noch Probleme mit einigen Funktionen ..
was ist der ideale Weg, um die Undo-Option zu machen?
eine andere Frage .. wenn der Benutzer das Bild skalieren (durch den Zeichnungsrahmen zu vergrößern) die Linien nicht skaliert. Wie mache ich das passieren.

habe ich all diese Probleme beseitigen, indem temporäre Bilder auf die Festplatte zu speichern, wenn der Benutzer eine Zeile beendet und weist dieses neue Bild (die alte Karte mit einer Linie auf mich) mit dem Rahmen. Undo und Redo wird durch Umschalten zwischen diesen Bildern gemacht wird ... so, wenn die Bild Benutzer Skala wird die Linie skalieren. aber das ist schlecht, da es eine Menge Festplattenspeicher nimmt (wenn Sie 1000 Linien zeichnen) und seine langsam, weil es jedes Mal, wenn ein Benutzer ziehen Sie eine Linie

ein neues Bild zuordnet

hoffen, meine Idee ist klar

hat jemand eine bessere Lösung?

Answer 1

Die kanonische Strategie ist es, die Eingabemuster . Hier finden Sie die Dinge darstellen Sie tun können, als Befehlsobjekte, und jedes Objekt auf einen Stapel gelegt wird. Der Zustand der Anwendung wird dann von einem Ausgangszustand zuzüglich alles definiert, dass der Stapel aufweist. Somit ist der „Undo“ Betrieb dann nur die oberen Stapel Artikel knallen und die übrigen Elemente in den Ausgangszustand erneute Anwendung.

In der Praxis ist es manchmal teuer zu halten diese Operationen in den Anfangszustand der Anwendung den aktuellen Zustand zu erzeugen. Zum Beispiel könnte dies mit so etwas wie eine komplexen Reihe von Bildanpassungen wahr sein, wie Sie in Photoshop finden könnten. In solchen Fällen, dass ist es üblich, einen Wechsel state-Stack Serie im Speicher zu halten:

+---------+
| state_0 |
+---------+       +---------+
| next   -------> | stack_0 |
+---------+       +---------+
                  | data    |       +---------+
                  | next   -------> | state_1 |
                  +---------+       +---------+
                                    | next   ----- ...
                                    +---------+

Jeder stack_i hält Befehle, bis sie eine gewisse voreingestellte Komplexität überschreitet (beispielsweise die Befehle Rechenkosten X übersteigen) oder ordinal (z.B. der Stapel hält X oder mehrere Befehle) zu begrenzen. An diesem Punkt wird ein neuer Zwischenzustand Objekt state_i+1 erstellt, um den Zustand zu verkapseln, und ein neuer, leerer Stapel stack_i+1 erstellt neue Befehle zu halten.

Auf diese Weise haben Sie nur eine kleine Folge von Befehlen zum letzten Snapshot von ihr erstelltem Zustand anzuwenden, um den aktuellen Zustand zu erhalten. Dies geht auf Kosten ganze Staaten auswendig zu lernen, die für sehr große Anwendungen nicht möglich sein, aber Sie können wählen, nur einen Satz des Staates Snapshot zu optimieren.

Answer 2

Auch im Auge behalten, dass Python Funktionen erstklassige Objekte sind, die sehr glatt machen kann das Command-Muster Implementierung:

actions = []

def do_action1(arg1, arg2):
    # .. do the action ..

    # remember we did the action:
    actions.append(do_action1, (arg1, arg2))

def do_action2(arg1, arg2):
    # .. do the action ..
    actions.append(do_action2, (arg1, arg2))

def replay_actions():
    for fn, args in actions:
        fn(*args)