The undo/redo module provides support for undo/redo operations.
Enabling the module
To enable the plotting module, you can either hard-code the USE_UNDO_MODULE
option in your CMakeLists.txt
file by finding the following line:
option(USE_UNDO_MODULE "Use the undo module" OFF)
and modifying the line to look like this
option(USE_UNDO_MODULE "Use the undo module" ON)
Alternatively, you can also generate your project files using CMake options by running the following CMake command:
cmake .. -DCMAKE_BUILD_TYPE=RELEASE -DUSE_UNDO_MODULE=ON
Finally, update your uvproj.yaml
so that the undo_redo
key under enabled-modules
is set to true like this:
name: "MyProject"
version: "1.0.0.0"
engine-version: "1.0.0.0"
enabled-modules:
undo_redo: true
Next, in your source file, include the Modules.hpp
header in your components like this:
#include <Modules/Modules.hpp>
Event safety
The entire module is flagged as event safe at Post-begin
.
Using the Undo/Redo module
The module stores data in the Transaction
data type, as can be seen below:
struct UIMGUI_PUBLIC_API Transaction
{std::function<void(TransactionPayload&)> undofunc;
std::function<void(TransactionPayload&)> redofunc;
TransactionPayload payload; };
The 2 functions are the events to be called on undo and redo, respectively.
The payload
member is of type TransactionPayload
which is a simple struct storing a void*
for a buffer and its size like this:
struct UIMGUI_PUBLIC_API TransactionPayload
{void* payload;
size_t size;
};
So to push a transaction create a transaction, initialize the events and the payload and push it as an argument to the push
function like this:
Transaction transaction =
{"Undo", UVKLog::UVK_LOG_TYPE_NOTE); },
.undofunc = [](TransactionPayload&){ Logger::log("Redo", UVKLog::UVK_LOG_TYPE_NOTE); },
.redofunc = [](TransactionPayload&){ Logger::log(
.payload =
{ nullptr,
.payload = 0,
.size =
}
};
UImGui::StateTracker::push(transaction);
And now you have added an action that can be undone.
To undo or redo an action, simply call the undo
or redo
member functions of the StateTracker
class like this:
UImGui::StateTracker::undo(); UImGui::StateTracker::redo();
and you should get the appropriate output logged to the console.
Checking for the module
To check for the module at compile time, use the UIMGUI_UNDO_MODULE_ENABLED
macro.
Runtime checking can be done using the undo_redo
member of the ModuleSettings
struct. More info can be found here.
C API
The undo module contains a C API, which uses the standard C API development principles, as defined here. Here is how they differ:
TransactionPayload
is renamed toUImGui_TransactionPayload
- same contentpush
,undo
andredo
functions are prefixed withUImGui_StateTracker_
push
takesUImGui_CTransaction
instead ofTransaction
UImGui_CTransaction
instead ofTransaction
. It looks like this:typedef struct UIMGUI_PUBLIC_API UImGui_CTransaction { UImGui_CTransactionCallbackFun undoFunc; UImGui_CTransactionCallbackFun redoFunc; UImGui_TransactionPayload payload; } UImGui_CTransaction;
where UImGui_CTransactionCallbackFun
is a C function pointer of type void(UImGui_TransactionPayload*)
.
- Home
- Beginner content
- Install guide
- Creating and using the UI components
- The Instance
- The Init Info struct
- Additional features
- Custom type definitions
- C API development
- Config files and Folders
- Interfaces
- Internal Event safety
- Modules system
- I18N
- Plotting
- Knobs
- Spinners
- Toggles
- Text Utils
- Undo/Redo
- CLI Parser
- Theming
- OS
- Opening URLs and using file pickers
- Exec integration
- Fonts
- Unix
- DBus utilities
- XDG integration
- Collaborating with others
- Advanced content
- Loading dynamic libraries at runtime
- Understanding the library layout
- Compilation mode modifiers
- Adding plugin support to your application
- Production export and deployment
- Developer and contributor resources
- Misc