1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
|
/*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software Foundation,
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
/** \file
* \ingroup editors
*/
#pragma once
#include "BLI_compiler_attrs.h"
#ifdef __cplusplus
extern "C" {
#endif
struct Base;
struct CLG_LogRef;
struct Object;
struct UndoStack;
struct ViewLayer;
struct bContext;
struct wmOperator;
struct wmOperatorType;
/* undo.c */
/**
* Run from the main event loop, basic checks that undo is left in a correct state.
*/
bool ED_undo_is_state_valid(struct bContext *C);
void ED_undo_group_begin(struct bContext *C);
void ED_undo_group_end(struct bContext *C);
void ED_undo_push(struct bContext *C, const char *str);
void ED_undo_push_op(struct bContext *C, struct wmOperator *op);
void ED_undo_grouped_push(struct bContext *C, const char *str);
void ED_undo_grouped_push_op(struct bContext *C, struct wmOperator *op);
void ED_undo_pop_op(struct bContext *C, struct wmOperator *op);
void ED_undo_pop(struct bContext *C);
void ED_undo_redo(struct bContext *C);
void ED_OT_undo(struct wmOperatorType *ot);
void ED_OT_undo_push(struct wmOperatorType *ot);
void ED_OT_redo(struct wmOperatorType *ot);
void ED_OT_undo_redo(struct wmOperatorType *ot);
void ED_OT_undo_history(struct wmOperatorType *ot);
/**
* UI callbacks should call this rather than calling WM_operator_repeat() themselves.
*/
int ED_undo_operator_repeat(struct bContext *C, struct wmOperator *op);
/**
* Convenience since UI callbacks use this mostly.
*/
void ED_undo_operator_repeat_cb(struct bContext *C, void *arg_op, void *arg_unused);
void ED_undo_operator_repeat_cb_evt(struct bContext *C, void *arg_op, int arg_unused);
/**
* Name optionally, function used to check for operator redo panel.
*/
bool ED_undo_is_valid(const struct bContext *C, const char *undoname);
bool ED_undo_is_memfile_compatible(const struct bContext *C);
/* Unfortunate workaround for limits mixing undo systems. */
/**
* When a property of ID changes, return false.
*
* This is to avoid changes to a property making undo pushes
* which are ignored by the undo-system.
* For example, changing a brush property isn't stored by sculpt-mode undo steps.
* This workaround is needed until the limitation is removed, see: T61948.
*/
bool ED_undo_is_legacy_compatible_for_property(struct bContext *C, struct ID *id);
/**
* Load all our objects from `object_array` into edit-mode, clear everything else.
*/
void ED_undo_object_editmode_restore_helper(struct bContext *C,
struct Object **object_array,
uint object_array_len,
uint object_array_stride);
struct Object **ED_undo_editmode_objects_from_view_layer(struct ViewLayer *view_layer,
uint *r_len);
struct Base **ED_undo_editmode_bases_from_view_layer(struct ViewLayer *view_layer, uint *r_len);
/**
* Ideally we won't access the stack directly,
* this is needed for modes which handle undo themselves (bypassing #ED_undo_push).
*
* Using global isn't great, this just avoids doing inline,
* causing 'BKE_global.h' & 'BKE_main.h' includes.
*/
struct UndoStack *ED_undo_stack_get(void);
/* helpers */
void ED_undo_object_set_active_or_warn(struct Scene *scene,
struct ViewLayer *view_layer,
struct Object *ob,
const char *info,
struct CLG_LogRef *log);
/* undo_system_types.c */
void ED_undosys_type_init(void);
void ED_undosys_type_free(void);
/* memfile_undo.c */
struct MemFile *ED_undosys_stack_memfile_get_active(struct UndoStack *ustack);
/**
* If the last undo step is a memfile one, find the first #MemFileChunk matching given ID
* (using its session UUID), and tag it as "changed in the future".
*
* Since non-memfile undo-steps cannot automatically set this flag in the previous step as done
* with memfile ones, this has to be called manually by relevant undo code.
*
* \note Only current known case for this is undoing a switch from Object to Sculpt mode (see
* T82388).
*
* \note Calling this ID by ID is not optimal, as it will loop over all #MemFile.chunks until it
* finds the expected one. If this becomes an issue we'll have to add a mapping from session UUID
* to first #MemFileChunk in #MemFile itself
* (currently we only do that in #MemFileWriteData when writing a new step).
*/
void ED_undosys_stack_memfile_id_changed_tag(struct UndoStack *ustack, struct ID *id);
#ifdef __cplusplus
}
#endif
|
