ArdaandClaude Opus 5.5
b98fe828da
Undo and redo now work against a connected device; each step is sent there through Sox. Deleting a component first reads its whole subtree back (config, unloaded children, links, place among siblings) so undo can recreate it; recreated components take new device ids, which the DOM elements pick up so later steps still reach them. Binary Buf config (a user's cred) is read with read_prop, since the cache decodes every Buf as a Str. Moves, tidy layout, and Properties / page editor / user edits record only what the device accepted. A step that does not fully reach the device warns and clears the history. History is also cleared on every view change in live mode, as opening a sheet rebuilds the DOM from the device. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
363 lines
12 KiB
Python
363 lines
12 KiB
Python
"""Undo/redo as a stack of reversible commands.
|
|
|
|
Commands own the DOM mutation in both directions; in live mode they also carry it to the
|
|
device, and raise LiveUndoError when it does not get there. Nothing here touches Tk: the view is
|
|
refreshed through a callback that main registers at startup, which also keeps the
|
|
import graph free of cycles (sax_file and wiresheet both push commands here).
|
|
"""
|
|
|
|
import app_state
|
|
import live_hooks
|
|
import palette
|
|
import schema
|
|
from sax_dom import remove_prop, restore_children, set_prop_value, update_meta_property
|
|
|
|
_undo_stack = []
|
|
_redo_stack = []
|
|
_saved_depth = 0 # len(_undo_stack) as of the last save
|
|
_refresh_view = None
|
|
|
|
|
|
def set_refresh_callback(callback):
|
|
"""Registers how the view should be rebuilt after an undo or redo."""
|
|
global _refresh_view
|
|
_refresh_view = callback
|
|
|
|
|
|
def _refresh():
|
|
if _refresh_view is not None:
|
|
_refresh_view()
|
|
|
|
# Undoing back to the last saved state should clear the dirty marker, not keep it lit.
|
|
if len(_undo_stack) == _saved_depth:
|
|
app_state.mark_clean()
|
|
else:
|
|
app_state.mark_dirty()
|
|
|
|
|
|
def push(command):
|
|
"""Records an already-applied command. Any redo history becomes unreachable."""
|
|
_undo_stack.append(command)
|
|
_redo_stack.clear()
|
|
|
|
|
|
def can_undo():
|
|
return bool(_undo_stack)
|
|
|
|
|
|
def can_redo():
|
|
return bool(_redo_stack)
|
|
|
|
|
|
class LiveUndoError(Exception):
|
|
"""A live command's undo or redo did not fully reach the device.
|
|
|
|
Raised with what did not happen; live_hooks.last_error holds why.
|
|
"""
|
|
|
|
|
|
def undo():
|
|
if not _undo_stack:
|
|
return None
|
|
command = _undo_stack.pop()
|
|
try:
|
|
command.undo()
|
|
except LiveUndoError as failure:
|
|
_abandon_history("Undo", failure)
|
|
return None
|
|
_redo_stack.append(command)
|
|
_refresh()
|
|
return command.label
|
|
|
|
|
|
def redo():
|
|
if not _redo_stack:
|
|
return None
|
|
command = _redo_stack.pop()
|
|
try:
|
|
command.redo()
|
|
except LiveUndoError as failure:
|
|
_abandon_history("Redo", failure)
|
|
return None
|
|
_undo_stack.append(command)
|
|
_refresh()
|
|
return command.label
|
|
|
|
|
|
def _abandon_history(title, failure):
|
|
"""After a step that did not reach the device, the history no longer matches it.
|
|
|
|
The device may hold part of the step, so neither direction can be trusted to land
|
|
where it says. History is dropped rather than replayed against a state it never saw.
|
|
"""
|
|
reset()
|
|
_refresh()
|
|
live_hooks.warn_failure(title, f"{failure}. Undo history was cleared")
|
|
|
|
|
|
def mark_saved():
|
|
"""Pins the current stack depth as the on-disk state."""
|
|
global _saved_depth
|
|
_saved_depth = len(_undo_stack)
|
|
|
|
|
|
def reset():
|
|
"""Drops all history, for when a different file is loaded."""
|
|
global _saved_depth
|
|
_undo_stack.clear()
|
|
_redo_stack.clear()
|
|
_saved_depth = 0
|
|
|
|
|
|
def reload_schema_registry():
|
|
"""Recompiles the slot registry after the <schema> block changed.
|
|
|
|
A failure is swallowed: undo and redo only ever land on a state that resolved once
|
|
already, so a missing manifest here means Sedona home moved underneath the session,
|
|
which the next action reports in its own words.
|
|
"""
|
|
palette.invalidate()
|
|
try:
|
|
schema.load_schema_kits_and_manifests()
|
|
except schema.MissingManifestError:
|
|
pass
|
|
|
|
|
|
class SchemaBlockCommand:
|
|
"""A change to the file's <schema> block, held as a before/after snapshot.
|
|
|
|
Kit entries decide which manifest describes which type, so the slot registry is
|
|
recompiled in both directions — a repinned kit can change a component's slots.
|
|
"""
|
|
|
|
def __init__(self, schema_element, before, after, label="update kits"):
|
|
# before/after: snapshots from sax_dom.snapshot_children
|
|
self.schema_element = schema_element
|
|
self.before = before
|
|
self.after = after
|
|
self.label = label
|
|
|
|
def undo(self):
|
|
restore_children(self.schema_element, self.before)
|
|
reload_schema_registry()
|
|
|
|
def redo(self):
|
|
restore_children(self.schema_element, self.after)
|
|
reload_schema_registry()
|
|
|
|
|
|
class MetaMoveCommand:
|
|
"""One or many components changing position, i.e. their packed meta x/y."""
|
|
|
|
def __init__(self, changes, label="move"):
|
|
# changes: list of (element, old_meta_val, new_x, new_y)
|
|
self.changes = changes
|
|
self.label = label
|
|
|
|
def undo(self):
|
|
for element, old_val, _, _ in self.changes:
|
|
meta_prop = element.find("prop[@name='meta']")
|
|
if meta_prop is not None and old_val is not None:
|
|
meta_prop.set("val", old_val)
|
|
|
|
def redo(self):
|
|
for element, old_val, new_x, new_y in self.changes:
|
|
update_meta_property(element, old_val, new_x, new_y)
|
|
|
|
|
|
def _meta_val(element):
|
|
meta_prop = element.find("prop[@name='meta']")
|
|
return meta_prop.get("val") if meta_prop is not None else None
|
|
|
|
|
|
class LiveMetaMoveCommand(MetaMoveCommand):
|
|
"""A move on the device: each new position is written there after the DOM takes it.
|
|
|
|
A box the device refuses goes back to where the device still has it.
|
|
"""
|
|
|
|
def undo(self):
|
|
before = [(element, _meta_val(element)) for element, *_ in self.changes]
|
|
super().undo()
|
|
self._send(before)
|
|
|
|
def redo(self):
|
|
before = [(element, _meta_val(element)) for element, *_ in self.changes]
|
|
super().redo()
|
|
self._send(before)
|
|
|
|
@staticmethod
|
|
def _send(before):
|
|
failures = []
|
|
for element, old_val in before:
|
|
new_val = _meta_val(element)
|
|
if new_val is None or new_val == old_val:
|
|
continue
|
|
if not live_hooks.live_set_prop_value(element, "meta", new_val):
|
|
failures.append(element.get("name", "?"))
|
|
if old_val is None:
|
|
remove_prop(element, "meta")
|
|
else:
|
|
set_prop_value(element, "meta", old_val)
|
|
if failures:
|
|
raise LiveUndoError(f"{', '.join(failures)} could not be moved on the device")
|
|
|
|
|
|
class SlotValueCommand:
|
|
"""One Save from the Properties dialog: every slot it changed, as one undoable step.
|
|
|
|
A change is recorded as the <prop>'s value before and after, with None standing for
|
|
"the file had no such prop". Undoing back to None removes the prop again rather than
|
|
writing the default out, so a component that only ever carried the props the file
|
|
shipped with still carries exactly those.
|
|
"""
|
|
|
|
def __init__(self, changes, label="edit properties"):
|
|
# changes: list of (element, prop_name, old_val_or_None, new_val_or_None)
|
|
self.changes = changes
|
|
self.label = label
|
|
|
|
def _apply(self, value_index):
|
|
for change in self.changes:
|
|
element, prop_name = change[0], change[1]
|
|
value = change[value_index]
|
|
if value is None:
|
|
remove_prop(element, prop_name)
|
|
else:
|
|
set_prop_value(element, prop_name, value)
|
|
|
|
def undo(self):
|
|
self._apply(2)
|
|
|
|
def redo(self):
|
|
self._apply(3)
|
|
|
|
|
|
class LiveSlotValueCommand(SlotValueCommand):
|
|
"""Slot edits on the device: each value is written there first, and only a value the
|
|
device took lands in the DOM, so the views never show what the device does not hold.
|
|
|
|
A DOM read from the device carries every slot, so a None side does not come up; one
|
|
that did would have nothing to send, and only the DOM would change.
|
|
"""
|
|
|
|
def _apply(self, value_index):
|
|
failures = []
|
|
for change in self.changes:
|
|
element, prop_name = change[0], change[1]
|
|
value = change[value_index]
|
|
if value is None:
|
|
remove_prop(element, prop_name)
|
|
continue
|
|
if not live_hooks.live_set_prop_value(element, prop_name, value):
|
|
failures.append(f"{element.get('name', '?')}.{prop_name}")
|
|
continue
|
|
set_prop_value(element, prop_name, value)
|
|
if failures:
|
|
raise LiveUndoError(f"{', '.join(failures)} could not be written to the device")
|
|
|
|
|
|
class AddComponentCommand:
|
|
"""Placing a component.
|
|
|
|
Nothing here touches <schema>. The kit a placement needs is declared when the file is
|
|
saved, from the component types actually in the DOM, so undoing a placement takes its
|
|
kit out of that reckoning without this command having to unwind anything.
|
|
"""
|
|
|
|
def __init__(self, parent, index, element, label="add"):
|
|
self.parent = parent
|
|
self.index = index
|
|
self.element = element
|
|
self.label = label
|
|
|
|
def undo(self):
|
|
if self.element in list(self.parent):
|
|
self.parent.remove(self.element)
|
|
|
|
def redo(self):
|
|
if self.element not in list(self.parent):
|
|
self.parent.insert(self.index, self.element)
|
|
|
|
|
|
class AddLinkCommand:
|
|
"""Adding a single link to the <links> section."""
|
|
|
|
def __init__(self, links_parent, link_element, label="add link"):
|
|
self.links_parent = links_parent
|
|
self.link_element = link_element
|
|
self.label = label
|
|
|
|
def undo(self):
|
|
if self.link_element in list(self.links_parent):
|
|
self.links_parent.remove(self.link_element)
|
|
|
|
def redo(self):
|
|
if self.link_element not in list(self.links_parent):
|
|
self.links_parent.append(self.link_element)
|
|
|
|
|
|
class DeleteLinkCommand:
|
|
"""Removing a single link from the <links> section."""
|
|
|
|
def __init__(self, links_parent, index, link_element, label="delete link"):
|
|
self.links_parent = links_parent
|
|
self.index = index
|
|
self.link_element = link_element
|
|
self.label = label
|
|
|
|
def undo(self):
|
|
if self.link_element not in list(self.links_parent):
|
|
self.links_parent.insert(self.index, self.link_element)
|
|
|
|
def redo(self):
|
|
if self.link_element in list(self.links_parent):
|
|
self.links_parent.remove(self.link_element)
|
|
|
|
|
|
class DeleteComponentCommand:
|
|
"""A cascading delete: the component subtree plus every link that referenced it."""
|
|
|
|
def __init__(self, parent, index, element, link_records, label="delete"):
|
|
# link_records: list of (links_parent, index, link_element)
|
|
self.parent = parent
|
|
self.index = index
|
|
self.element = element
|
|
self.link_records = link_records
|
|
self.label = label
|
|
|
|
def undo(self):
|
|
self.parent.insert(self.index, self.element)
|
|
# Ascending order so each link lands back on its original index.
|
|
for links_parent, index, link in sorted(self.link_records, key=lambda r: r[1]):
|
|
links_parent.insert(index, link)
|
|
|
|
def redo(self):
|
|
for links_parent, _, link in self.link_records:
|
|
if link in list(links_parent):
|
|
links_parent.remove(link)
|
|
if self.element in list(self.parent):
|
|
self.parent.remove(self.element)
|
|
|
|
|
|
class RenameComponentCommand:
|
|
"""A rename, plus every link whose path ran through the component's old name."""
|
|
|
|
def __init__(self, element, old_name, new_name, link_changes, label="rename"):
|
|
# link_changes: list of (link_element, attr, old_value, new_value)
|
|
self.element = element
|
|
self.old_name = old_name
|
|
self.new_name = new_name
|
|
self.link_changes = link_changes
|
|
self.label = label
|
|
|
|
def undo(self):
|
|
self.element.set("name", self.old_name)
|
|
for link, attr, old_value, _ in self.link_changes:
|
|
link.set(attr, old_value)
|
|
|
|
def redo(self):
|
|
self.element.set("name", self.new_name)
|
|
for link, attr, _, new_value in self.link_changes:
|
|
link.set(attr, new_value)
|