Struct EditorUndoRedoManager

pub struct EditorUndoRedoManager { /* private fields */ }

Expand description

Godot class EditorUndoRedoManager.

Inherits Object.

Related symbols:

editor_undo_redo_manager: sidecar module with related enum/flag types
SignalsOfEditorUndoRedoManager: signal collection

§Not instantiable

This class cannot be constructed. Obtain Gd<EditorUndoRedoManager> instances via Godot APIs.

§Final class

This class is final, meaning you cannot inherit from it, and it comes without I* interface trait. It is still possible that other Godot classes inherit from it, but that is limited to the engine itself.

§Godot docs

EditorUndoRedoManager is a manager for UndoRedo objects associated with edited scenes. Each scene has its own undo history and EditorUndoRedoManager ensures that each action performed in the editor gets associated with a proper scene. For actions not related to scenes (ProjectSettings edits, external resources, etc.), a separate global history is used.

The usage is mostly the same as UndoRedo. You create and commit actions and the manager automatically decides under-the-hood what scenes it belongs to. The scene is deduced based on the first operation in an action, using the object from the operation. The rules are as follows:

If the object is a Node, use the currently edited scene;
If the object is a built-in resource, use the scene from its path;
If the object is external resource or anything else, use global history.

This guessing can sometimes yield false results, so you can provide a custom context object when creating an action.

EditorUndoRedoManager is intended to be used by Godot editor plugins. You can obtain it using get_undo_redo. For non-editor uses or plugins that don’t need to integrate with the editor’s undo history, use UndoRedo instead.

The manager’s API is mostly the same as in UndoRedo, so you can refer to its documentation for more examples. The main difference is that EditorUndoRedoManager uses object + method name for actions, instead of Callable.

Implementations§

§

impl EditorUndoRedoManager

pub fn create_action(&mut self, name: impl AsArg<GString>)

To set the default parameters, use create_action_ex and its builder methods. See the book for detailed usage instructions. Create a new action. After this is called, do all your calls to add_do_method, add_undo_method, add_do_property, and add_undo_property, then commit the action with commit_action.

The way actions are merged is dictated by the merge_mode argument.

If custom_context object is provided, it will be used for deducing target history (instead of using the first operation).

The way undo operation are ordered in actions is dictated by backward_undo_ops. When backward_undo_ops is false undo option are ordered in the same order they were added. Which means the first operation to be added will be the first to be undone.

If mark_unsaved is false, the action will not mark the history as unsaved. This is useful for example for actions that change a selection, or a setting that will be saved automatically. Otherwise, this should be left to true if the action requires saving by the user or if it can cause data loss when left unsaved.

pub fn create_action_ex<'ex>( &'ex mut self, name: impl AsArg<GString> + 'ex, ) -> ExCreateAction<'ex>

Create a new action. After this is called, do all your calls to add_do_method, add_undo_method, add_do_property, and add_undo_property, then commit the action with commit_action.

The way actions are merged is dictated by the merge_mode argument.

If custom_context object is provided, it will be used for deducing target history (instead of using the first operation).

The way undo operation are ordered in actions is dictated by backward_undo_ops. When backward_undo_ops is false undo option are ordered in the same order they were added. Which means the first operation to be added will be the first to be undone.

If mark_unsaved is false, the action will not mark the history as unsaved. This is useful for example for actions that change a selection, or a setting that will be saved automatically. Otherwise, this should be left to true if the action requires saving by the user or if it can cause data loss when left unsaved.

pub fn commit_action(&mut self)

To set the default parameters, use commit_action_ex and its builder methods. See the book for detailed usage instructions. Commits the action. If execute is true (default), all “do” methods/properties are called/set when this function is called.

pub fn commit_action_ex<'ex>(&'ex mut self) -> ExCommitAction<'ex>

Commits the action. If execute is true (default), all “do” methods/properties are called/set when this function is called.

pub fn is_committing_action(&self) -> bool

Returns true if the EditorUndoRedoManager is currently committing the action, i.e. running its “do” method or property change (see commit_action).

pub fn force_fixed_history(&mut self)

Forces the next operation (e.g. add_do_method) to use the action’s history rather than guessing it from the object. This is sometimes needed when a history can’t be correctly determined, like for a nested resource that doesn’t have a path yet.

This method should only be used when absolutely necessary, otherwise it might cause invalid history state. For most of complex cases, the custom_context parameter of create_action is sufficient.

pub fn add_do_method( &mut self, object: impl AsArg<Option<Gd<Object>>>, method: impl AsArg<StringName>, varargs: &[Variant], )

Register a method that will be called when the action is committed (i.e. the “do” action).

If this is the first operation, the object will be used to deduce target undo history.

§Panics

This is a varcall method, meaning parameters and return values are passed as Variant. It can detect call failures and will panic in such a case.

pub fn try_add_do_method( &mut self, object: impl AsArg<Option<Gd<Object>>>, method: impl AsArg<StringName>, varargs: &[Variant], ) -> Result<(), CallError>

§Return type

This is a varcall method, meaning parameters and return values are passed as Variant. It can detect call failures and will return Err in such a case.

pub fn add_undo_method( &mut self, object: impl AsArg<Option<Gd<Object>>>, method: impl AsArg<StringName>, varargs: &[Variant], )

Register a method that will be called when the action is undone (i.e. the “undo” action).

If this is the first operation, the object will be used to deduce target undo history.

§Panics

This is a varcall method, meaning parameters and return values are passed as Variant. It can detect call failures and will panic in such a case.

pub fn try_add_undo_method( &mut self, object: impl AsArg<Option<Gd<Object>>>, method: impl AsArg<StringName>, varargs: &[Variant], ) -> Result<(), CallError>

§Return type

This is a varcall method, meaning parameters and return values are passed as Variant. It can detect call failures and will return Err in such a case.

pub fn add_do_property( &mut self, object: impl AsArg<Option<Gd<Object>>>, property: impl AsArg<StringName>, value: &Variant, )

Register a property value change for “do”.

If this is the first operation, the object will be used to deduce target undo history.

pub fn add_undo_property( &mut self, object: impl AsArg<Option<Gd<Object>>>, property: impl AsArg<StringName>, value: &Variant, )

Register a property value change for “undo”.

If this is the first operation, the object will be used to deduce target undo history.

pub fn add_do_reference(&mut self, object: impl AsArg<Option<Gd<Object>>>)

Register a reference for “do” that will be erased if the “do” history is lost. This is useful mostly for new nodes created for the “do” call. Do not use for resources.

pub fn add_undo_reference(&mut self, object: impl AsArg<Option<Gd<Object>>>)

Register a reference for “undo” that will be erased if the “undo” history is lost. This is useful mostly for nodes removed with the “do” call (not the “undo” call!).

pub fn get_object_history_id( &self, object: impl AsArg<Option<Gd<Object>>>, ) -> i32

Returns the history ID deduced from the given object. It can be used with get_history_undo_redo.

pub fn get_history_undo_redo(&self, id: i32) -> Option<Gd<UndoRedo>>

Returns the UndoRedo object associated with the given history id.

id above 0 are mapped to the opened scene tabs (but it doesn’t match their order). id of 0 or lower have special meaning (see [enum SpecialHistory]).

Best used with get_object_history_id. This method is only provided in case you need some more advanced methods of UndoRedo (but keep in mind that directly operating on the UndoRedo object might affect editor’s stability).

pub fn clear_history(&mut self)

To set the default parameters, use clear_history_ex and its builder methods. See the book for detailed usage instructions. Clears the given undo history. You can clear history for a specific scene, global history, or for all histories at once (except SpecialHistory::REMOTE_HISTORY) if id is SpecialHistory::INVALID_HISTORY.

If increase_version is true, the undo history version will be increased, marking it as unsaved. Useful for operations that modify the scene, but don’t support undo.

var scene_root = EditorInterface.get_edited_scene_root()
var undo_redo = EditorInterface.get_editor_undo_redo()
undo_redo.clear_history(undo_redo.get_object_history_id(scene_root))

Note: If you want to mark an edited scene as unsaved without clearing its history, use mark_scene_as_unsaved instead.

pub fn clear_history_ex<'ex>(&'ex mut self) -> ExClearHistory<'ex>

Clears the given undo history. You can clear history for a specific scene, global history, or for all histories at once (except SpecialHistory::REMOTE_HISTORY) if id is SpecialHistory::INVALID_HISTORY.

If increase_version is true, the undo history version will be increased, marking it as unsaved. Useful for operations that modify the scene, but don’t support undo.

var scene_root = EditorInterface.get_edited_scene_root()
var undo_redo = EditorInterface.get_editor_undo_redo()
undo_redo.clear_history(undo_redo.get_object_history_id(scene_root))

Note: If you want to mark an edited scene as unsaved without clearing its history, use mark_scene_as_unsaved instead.

Methods from Deref<Target = Object>§

pub fn get_script(&self) -> Option<Gd<Script>>

pub fn set_script(&mut self, script: impl AsArg<Option<Gd<Script>>>)

pub fn connect( &mut self, signal: impl AsArg<StringName>, callable: &Callable, ) -> Error

pub fn connect_flags( &mut self, signal: impl AsArg<StringName>, callable: &Callable, flags: ConnectFlags, ) -> Error

pub fn get_class(&self) -> GString

Returns the object’s built-in class name, as a String. See also is_class.

Note: This method ignores class_name declarations. If this object’s script has defined a class_name, the base, built-in class name is returned instead.

pub fn is_class(&self, class: impl AsArg<GString>) -> bool

Returns true if the object inherits from the given class. See also get_class.

var sprite2d = Sprite2D.new()
sprite2d.is_class("Sprite2D") # Returns true
sprite2d.is_class("Node")     # Returns true
sprite2d.is_class("Node3D")   # Returns false

Note: This method ignores class_name declarations in the object’s script.

pub fn set(&mut self, property: impl AsArg<StringName>, value: &Variant)

Assigns value to the given property. If the property does not exist or the given value’s type doesn’t match, nothing happens.

var node = Node2D.new()
node.set("global_scale", Vector2(8, 2.5))
print(node.global_scale) # Prints (8.0, 2.5)

Note: In C#, property must be in snake_case when referring to built-in Godot properties. Prefer using the names exposed in the PropertyName class to avoid allocating a new StringName on each call.

pub fn get(&self, property: impl AsArg<StringName>) -> Variant

Returns the Variant value of the given property. If the property does not exist, this method returns null.

var node = Node2D.new()
node.rotation = 1.5
var a = node.get("rotation") # a is 1.5

Note: In C#, property must be in snake_case when referring to built-in Godot properties. Prefer using the names exposed in the PropertyName class to avoid allocating a new StringName on each call.

pub fn set_indexed( &mut self, property_path: impl AsArg<NodePath>, value: &Variant, )

Assigns a new value to the property identified by the property_path. The path should be a NodePath relative to this object, and can use the colon character (:) to access nested properties.

var node = Node2D.new()
node.set_indexed("position", Vector2(42, 0))
node.set_indexed("position:y", -10)
print(node.position) # Prints (42.0, -10.0)

Note: In C#, property_path must be in snake_case when referring to built-in Godot properties. Prefer using the names exposed in the PropertyName class to avoid allocating a new StringName on each call.

pub fn get_indexed(&self, property_path: impl AsArg<NodePath>) -> Variant

Gets the object’s property indexed by the given property_path. The path should be a NodePath relative to the current object and can use the colon character (:) to access nested properties.

Examples: "position:x" or "material:next_pass:blend_mode".

var node = Node2D.new()
node.position = Vector2(5, -10)
var a = node.get_indexed("position")   # a is Vector2(5, -10)
var b = node.get_indexed("position:y") # b is -10

Note: In C#, property_path must be in snake_case when referring to built-in Godot properties. Prefer using the names exposed in the PropertyName class to avoid allocating a new StringName on each call.

Note: This method does not support actual paths to nodes in the SceneTree, only sub-property paths. In the context of nodes, use get_node_and_resource instead.

pub fn get_property_list(&self) -> Array<Dictionary<Variant, Variant>>

Returns the object’s property list as an Array of dictionaries. Each Dictionary contains the following entries:

name is the property’s name, as a String;
class_name is an empty StringName, unless the property is VariantType::OBJECT and it inherits from a class;
type is the property’s type, as an int (see [enum Variant.Type]);
hint is how the property is meant to be edited (see [enum PropertyHint]);
hint_string depends on the hint (see [enum PropertyHint]);
usage is a combination of [enum PropertyUsageFlags].

Note: In GDScript, all class members are treated as properties. In C# and GDExtension, it may be necessary to explicitly mark class members as Godot properties using decorators or attributes.

pub fn get_method_list(&self) -> Array<Dictionary<Variant, Variant>>

Returns this object’s methods and their signatures as an Array of dictionaries. Each Dictionary contains the following entries:

name is the name of the method, as a String;
args is an Array of dictionaries representing the arguments;
default_args is the default arguments as an Array of variants;
flags is a combination of [enum MethodFlags];
id is the method’s internal identifier int;
return is the returned value, as a Dictionary;

Note: The dictionaries of args and return are formatted identically to the results of get_property_list, although not all entries are used.

pub fn property_can_revert(&self, property: impl AsArg<StringName>) -> bool

Returns true if the given property has a custom default value. Use property_get_revert to get the property’s default value.

Note: This method is used by the Inspector dock to display a revert icon. The object must implement [method _property_can_revert] to customize the default value. If [method _property_can_revert] is not implemented, this method returns false.

pub fn property_get_revert(&self, property: impl AsArg<StringName>) -> Variant

Returns the custom default value of the given property. Use property_can_revert to check if the property has a custom default value.

Note: This method is used by the Inspector dock to display a revert icon. The object must implement [method _property_get_revert] to customize the default value. If [method _property_get_revert] is not implemented, this method returns null.

pub fn set_meta(&mut self, name: impl AsArg<StringName>, value: &Variant)

Adds or changes the entry name inside the object’s metadata. The metadata value can be any Variant, although some types cannot be serialized correctly.

If value is null, the entry is removed. This is the equivalent of using remove_meta. See also has_meta and get_meta.

Note: A metadata’s name must be a valid identifier as per is_valid_identifier method.