undo functional

1 files changed, 147 insertions, 12 deletions

diff --git a/undo.cpp b/undo.cpp
index 7858f8d..3d70d49 100644
--- a/undo.cpp
+++ b/undo.cpp
@@ -7,10 +7,11 @@
 // We need to encode data that's able to go from A -> B as well as B -> A. Thus
 // for the ints I encode the difference instead of just whatever the last value
 // was. Strings currently just stores both.
-void Action_Change_Commit(memory *Memory, void *OriginalData, void *NewData, action_change_type ActionChange)
+void Action_Change_Commit(memory *Memory, void *DataAddress, void *OriginalData, void *NewData, action_change_type ActionChange)
 {
+    Memory->Action.Entry[Memory->Action.Index].NumberOfActions++;
     void *UndoEntry = AllocateMemory(Memory, sizeof(void *), P_UndoBuffer);
-    *(ptrsize *)UndoEntry = (ptrsize)OriginalData;
+    *(ptrsize *)UndoEntry = (ptrsize)DataAddress;
     void *Data = AllocateMemory(Memory, sizeof(action_change_type), P_UndoBuffer);
     *(action_change_type *)Data = ActionChange;
     switch (ActionChange)
@@ -22,7 +23,7 @@ void Action_Change_Commit(memory *Memory, void *OriginalData, void *NewData, act
             uint16 Difference = NewValue - OriginalValue;
             void *Data = AllocateMemory(Memory, sizeof(uint16), P_UndoBuffer);
             *(uint16 *)Data = Difference;
-            *(uint16 *)OriginalData = *(uint16 *)NewData;
+            *(uint16 *)DataAddress = *(uint16 *)NewData;
         } break;
         case action_change_i16:
         {
@@ -31,7 +32,7 @@ void Action_Change_Commit(memory *Memory, void *OriginalData, void *NewData, act
             int16 Difference = NewValue - OriginalValue;
             void *Data = AllocateMemory(Memory, sizeof(int16), P_UndoBuffer);
             *(int16 *)Data = Difference;
-            *(int16 *)OriginalData = *(int16 *)NewData;
+            *(int16 *)DataAddress = *(int16 *)NewData;
         } break;
         case action_change_u32:
         {
@@ -40,7 +41,7 @@ void Action_Change_Commit(memory *Memory, void *OriginalData, void *NewData, act
             uint32 Difference = NewValue - OriginalValue;
             void *Data = AllocateMemory(Memory, sizeof(uint32), P_UndoBuffer);
             *(uint32 *)Data = Difference;
-            *(uint32 *)OriginalData = *(uint32 *)NewData;
+            *(uint32 *)DataAddress = *(uint32 *)NewData;
         } break;
         case action_change_i32:
         {
@@ -49,7 +50,7 @@ void Action_Change_Commit(memory *Memory, void *OriginalData, void *NewData, act
             int32 Difference = NewValue - OriginalValue;
             void *Data = AllocateMemory(Memory, sizeof(int32), P_UndoBuffer);
             *(int32 *)Data = Difference;
-            *(int32 *)OriginalData = *(int32 *)NewData;
+            *(int32 *)DataAddress = *(int32 *)NewData;
         } break;
         case action_change_r32:
         {
@@ -58,7 +59,7 @@ void Action_Change_Commit(memory *Memory, void *OriginalData, void *NewData, act
             real32 Difference = NewValue - OriginalValue;
             void *Data = AllocateMemory(Memory, sizeof(real32), P_UndoBuffer);
             *(real32 *)Data = Difference;
-            *(real32 *)OriginalData = *(real32 *)NewData;
+            *(real32 *)DataAddress = *(real32 *)NewData;
         } break;
         case action_change_u64:
         {
@@ -67,7 +68,7 @@ void Action_Change_Commit(memory *Memory, void *OriginalData, void *NewData, act
             uint64 Difference = NewValue - OriginalValue;
             void *Data = AllocateMemory(Memory, sizeof(uint64), P_UndoBuffer);
             *(uint64 *)Data = Difference;
-            *(uint64 *)OriginalData = *(uint64 *)NewData;
+            *(uint64 *)DataAddress = *(uint64 *)NewData;
         } break;
         case action_change_ptr:
         {
@@ -76,7 +77,7 @@ void Action_Change_Commit(memory *Memory, void *OriginalData, void *NewData, act
             ptrsize Difference = NewValue - OriginalValue;
             void *Data = AllocateMemory(Memory, sizeof(ptrsize), P_UndoBuffer);
             *(ptrsize *)Data = Difference;
-            *(ptrsize *)OriginalData = *(ptrsize *)NewData;
+            *(ptrsize *)DataAddress = *(ptrsize *)NewData;
         } break;
         case action_change_string:
         {
@@ -84,18 +85,43 @@ void Action_Change_Commit(memory *Memory, void *OriginalData, void *NewData, act
             CopyStrings(Data, OriginalData);
             Data = AllocateMemory(Memory, STRING_SIZE, P_UndoBuffer);
             CopyStrings(Data, NewData);
-            CopyStrings(OriginalData, NewData);
+            CopyStrings(DataAddress, NewData);
         } break;
     }
     Data = AllocateMemory(Memory, sizeof(action_change_type), P_UndoBuffer);
     *(action_change_type *)Data = ActionChange;
 }
 
+void Action_Entry_Begin(memory *Memory, action_entry_type Type, char *Name)
+{
+    Memory->Action.Entry[Memory->Action.Index].Name = Name;
+    Memory->Action.Entry[Memory->Action.Index].Type = Type;
+}
+
+void Action_Entry_Begin2(memory *Memory, action_entry_type Type, char *Name, char *Name2)
+{
+    Memory->Action.Entry[Memory->Action.Index].Name = Name;
+    Memory->Action.Entry[Memory->Action.Index].Type = Type;
+    Memory->Action.Entry[Memory->Action.Index + 1].Name = Name2;
+    Memory->Action.Entry[Memory->Action.Index + 1].Type = Type;
+}
+
+void Action_Entry_SetPointer(memory *Memory, void *Data)
+{
+    Memory->Action.Entry[Memory->Action.Index].ExtraPointer = Data;
+}
+
+void Action_Entry_End(memory *Memory)
+{
+    Memory->Action.Index++;
+    Memory->Action.NumberOfEntries++;
+}
+
 // TODO(fox): Maybe take the extra lines to separate the incrementing of the
 // address from the variable assignment to improve legibility.
 
 // The pointer is unwinded.
-void Action_Undo(memory *Memory) {
+void Action_Change_Undo(memory *Memory) {
     memory_table *Table = &Memory->Slot[P_UndoBuffer];
     uint8 *LastPos = (uint8 *)Table->Address + Table->CurrentPosition;
     action_change_type *ActionType = (action_change_type *)LastPos - 1;
@@ -109,6 +135,41 @@ void Action_Undo(memory *Memory) {
             void *Address = (void *)*(ptrsize *)TableAddress;
             *(uint16 *)Address -= *Difference;
         } break;
+        case action_change_i16:
+        {
+            int16 *Difference = (int16 *)ActionType - 1;
+            TableAddress = (uint8 *)Difference - sizeof(ptrsize) - sizeof(action_change_type);
+            void *Address = (void *)*(ptrsize *)TableAddress;
+            *(int16 *)Address -= *Difference;
+        } break;
+        case action_change_u32:
+        {
+            uint32 *Difference = (uint32 *)ActionType - 1;
+            TableAddress = (uint8 *)Difference - sizeof(ptrsize) - sizeof(action_change_type);
+            void *Address = (void *)*(ptrsize *)TableAddress;
+            *(uint32 *)Address -= *Difference;
+        } break;
+        case action_change_i32:
+        {
+            int32 *Difference = (int32 *)ActionType - 1;
+            TableAddress = (uint8 *)Difference - sizeof(ptrsize) - sizeof(action_change_type);
+            void *Address = (void *)*(ptrsize *)TableAddress;
+            *(int32 *)Address -= *Difference;
+        } break;
+        case action_change_r32:
+        {
+            real32 *Difference = (real32 *)ActionType - 1;
+            TableAddress = (uint8 *)Difference - sizeof(ptrsize) - sizeof(action_change_type);
+            void *Address = (void *)*(ptrsize *)TableAddress;
+            *(real32 *)Address -= *Difference;
+        } break;
+        case action_change_u64:
+        {
+            uint64 *Difference = (uint64 *)ActionType - 1;
+            TableAddress = (uint8 *)Difference - sizeof(ptrsize) - sizeof(action_change_type);
+            void *Address = (void *)*(ptrsize *)TableAddress;
+            *(uint64 *)Address -= *Difference;
+        } break;
         case action_change_ptr:
         {
             ptrsize *Difference = (ptrsize *)ActionType - 1;
@@ -116,12 +177,17 @@ void Action_Undo(memory *Memory) {
             void *Address = (void *)*(ptrsize *)TableAddress;
             *(ptrsize *)Address -= *Difference;
         } break;
+        case action_change_string:
+        {
+            TableAddress = 0x0;
+            Assert(0);
+        } break;
     }
     Table->CurrentPosition = (TableAddress - (uint8 *)Table->Address);
 }
 
 // The pointer is rewinded.
-void Action_Redo(memory *Memory) {
+void Action_Change_Redo(memory *Memory) {
     memory_table *Table = &Memory->Slot[P_UndoBuffer];
     uint8 *LastPos = (uint8 *)Table->Address + Table->CurrentPosition;
     void *Address = (void *)*(ptrsize *)LastPos;
@@ -135,12 +201,81 @@ void Action_Redo(memory *Memory) {
             TableAddress = (uint8 *)Difference + sizeof(uint16) + sizeof(action_change_type);
             *(uint16 *)Address += *Difference;
         } break;
+        case action_change_i16:
+        {
+            int16 *Difference = (int16 *)(ActionType + 1);
+            TableAddress = (uint8 *)Difference + sizeof(int16) + sizeof(action_change_type);
+            *(int16 *)Address += *Difference;
+        } break;
+        case action_change_u32:
+        {
+            uint32 *Difference = (uint32 *)(ActionType + 1);
+            TableAddress = (uint8 *)Difference + sizeof(uint32) + sizeof(action_change_type);
+            *(uint32 *)Address += *Difference;
+        } break;
+        case action_change_i32:
+        {
+            int32 *Difference = (int32 *)(ActionType + 1);
+            TableAddress = (uint8 *)Difference + sizeof(int32) + sizeof(action_change_type);
+            *(int32 *)Address += *Difference;
+        } break;
+        case action_change_r32:
+        {
+            real32 *Difference = (real32 *)(ActionType + 1);
+            TableAddress = (uint8 *)Difference + sizeof(real32) + sizeof(action_change_type);
+            *(real32 *)Address += *Difference;
+        } break;
+        case action_change_u64:
+        {
+            uint64 *Difference = (uint64 *)(ActionType + 1);
+            TableAddress = (uint8 *)Difference + sizeof(uint64) + sizeof(action_change_type);
+            *(uint64 *)Address += *Difference;
+        } break;
         case action_change_ptr:
         {
             ptrsize *Difference = (ptrsize *)(ActionType + 1);
             TableAddress = (uint8 *)Difference + sizeof(ptrsize) + sizeof(action_change_type);
             *(ptrsize *)Address += *Difference;
         } break;
+        case action_change_string:
+        {
+            TableAddress = 0x0;
+            Assert(0);
+        } break;
     }
     Table->CurrentPosition = (TableAddress - (uint8 *)Table->Address);
 }
+
+void Action_Undo(memory *Memory) {
+    Memory->Action.Index--;
+    action_entry Entry = Memory->Action.Entry[Memory->Action.Index];
+    switch (Entry.Type)
+    {
+        case action_entry_layerinit:
+        {
+            AV_Dealloc((av_info *)*(ptrsize *)Entry.ExtraPointer);
+            *(ptrsize *)Entry.ExtraPointer = 0x0;   // what actually dereferences the pointer
+        } break;
+        case action_entry_default:
+        {
+        } break;
+    }
+    for (int i = 0; i < Entry.NumberOfActions; i++)
+        Action_Change_Undo(Memory);
+}
+
+void Action_Redo(memory *Memory) {
+    action_entry Entry = Memory->Action.Entry[Memory->Action.Index];
+    switch (Entry.Type)
+    {
+        case action_entry_layerinit:
+        {
+        } break;
+        case action_entry_default:
+        {
+        } break;
+    }
+    for (int i = 0; i < Entry.NumberOfActions; i++)
+        Action_Change_Redo(Memory);
+    Memory->Action.Index++;
+}