undo/redo mostly done i think

src/undo.rs

@@ -1,16 +1,22 @@
 use bevy::prelude::*;
 
-use crate::{CreateShape, ShapeData};
+use crate::ui::SelectedItem;
+use crate::{CreateShape, ShapeData, ImageData};
 
 #[derive(Debug, Clone)]
 pub enum UndoItem {
     Base,
     CreateShape { entity: Entity },
+    DeleteShape { sd: ShapeData, transform: Transform },
+    MoveItem { shape: Entity, from: Vec2, to: Vec2 },
     MoveDot { shape_data: Entity, dot: Entity, from: Vec2, to: Vec2 },
-    MoveShape { shape: Entity, from: Vec2, to: Vec2 },
     Rotate { entity: Entity, from: f32, to: f32 },
     NameChange { entity: Entity, from: String },
-    DeleteShape { name: String, shape: CreateShape, edges: Vec<Vec2>, transform: Transform, color: Color, note: String },
+    NoteChange { entity: Entity, from: String },
+    ChangeZ { entity: Entity, from: f32, to: f32 },
+    ReScale { entity: Entity, from: Vec2, to: Vec2 },
+    CreateImage { entity: Entity },
+    DeleteImage { id: ImageData, transform: Transform, handle: Handle<Image> },
 }
 pub struct UndoStack {
     items: Vec<UndoItem>,
@@ -67,9 +73,11 @@ impl UndoStack {
 pub fn undo_redo_sys(
     mut coms: Commands,
     mut stack: ResMut<UndoStack>,
+    mut inspector: ResMut<SelectedItem>,
     keyboard: Res<Input<KeyCode>>,
     mut shapes: Query<&mut ShapeData>,
     mut transforms: Query<&mut Transform>,
+    mut images: Query<(&mut ImageData, &Handle<Image>)>,
 ) {
     if keyboard.just_pressed(KeyCode::Z) && keyboard.pressed(KeyCode::LControl) {
         let item = if keyboard.pressed(KeyCode::LShift) { stack.unpop() } else { stack.pop() };
@@ -79,10 +87,13 @@ pub fn undo_redo_sys(
                 UndoItem::CreateShape { entity } => {
                     bevy::log::error!("NOT IMPLEMENTED : CreateShape");
                 },
-                UndoItem::MoveDot { shape_data, dot, from, to } => {
-                    bevy::log::error!("NOT IMPLEMENTED : MoveDot");
+                UndoItem::DeleteShape {
+                    sd,
+                    transform,
+                } => {
+                    bevy::log::error!("NOT IMPLEMENTED : DeleteShape");
                 },
-                UndoItem::MoveShape { shape, from, to } => {
+                UndoItem::MoveItem { shape, from, to } => {
                     if let Ok(mut t) = transforms.get_mut(*shape) {
                         t.translation = from.extend(t.translation.z);
                     }
@@ -90,6 +101,9 @@ pub fn undo_redo_sys(
                     *from = *to;
                     *to = t;
                 },
+                UndoItem::MoveDot { shape_data, dot, from, to } => {
+                    bevy::log::error!("NOT IMPLEMENTED : MoveDot");
+                },
                 UndoItem::Rotate { entity, from, to } => {
                     if let Ok(mut t) = transforms.get_mut(*entity) {
                         t.rotation = Quat::from_rotation_z(from.to_radians());
@@ -102,17 +116,57 @@ pub fn undo_redo_sys(
                     if let Ok(mut sd) = shapes.get_mut(*entity) {
                         std::mem::swap(&mut sd.name, from);
                     }
+                    else if let Ok((mut id, _)) = images.get_mut(*entity) {
+                        std::mem::swap(&mut id.name, from);
+                    }
                     // No need to update the item, so no need to replace
                 },
-                UndoItem::DeleteShape {
-                    name, 
-                    shape, 
-                    edges, 
-                    transform, 
-                    color, 
-                    note 
-                } => {
-                    bevy::log::error!("NOT IMPLEMENTED : DeleteShape");
+                UndoItem::ChangeZ { entity, from, to } => {
+                    if let Ok(mut t) = transforms.get_mut(*entity) {
+                        t.translation.z = *from;
+                    }
+                    let t = *from;
+                    *from = *to;
+                    *to = t;
+                },
+                UndoItem::ReScale { entity, from, to } => {
+                    if let Ok(mut t) = transforms.get_mut(*entity) {
+                        t.scale = from.extend(1.0);
+                    }
+                    let t = *from;
+                    *from = *to;
+                    *to = t;
+                },
+                UndoItem::CreateImage { entity } => {
+                    if let Ok((mut id, handle)) = images.get_mut(*entity) {
+                        let transform = transforms.get(*entity).map(|t| *t).unwrap_or(Transform::default());
+                        let mut nid = ImageData::default();
+                        std::mem::swap(&mut *id, &mut nid);
+
+                        coms.entity(*entity).despawn();
+                        *item = UndoItem::DeleteImage { id: nid, transform, handle: handle.clone() };
+                    }
+                },
+                UndoItem::DeleteImage { transform, handle, id } => {
+                    let mut nid = ImageData::default();
+                    std::mem::swap(id, &mut nid);
+
+                    let e = coms.spawn_bundle(SpriteBundle {
+                        texture: handle.clone(),
+                        transform: *transform,
+                        ..Default::default()
+                    })
+                    .insert(nid).id();
+
+                    *item = UndoItem::CreateImage { entity: e };
+                },
+                UndoItem::NoteChange { entity, from } => {
+                    if let Ok(mut sd) = shapes.get_mut(*entity) {
+                        std::mem::swap(&mut sd.note, from);
+                    }
+                    else if let Ok((mut id, _)) = images.get_mut(*entity) {
+                        std::mem::swap(&mut id.note, from);
+                    }
                 },
             }
         }