From e89dc91182a94e48ca9220a2fe075db680ddff04 Mon Sep 17 00:00:00 2001 From: Fox Caminiti Date: Tue, 16 Aug 2022 15:06:45 -0400 Subject: undo functional --- undo.cpp | 159 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++----- 1 file changed, 147 insertions(+), 12 deletions(-) (limited to 'undo.cpp') 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++; +} -- cgit v1.2.3