Cleanup: style, use braces for editors
[blender.git] / source / blender / editors / object / object_modes.c
1 /*
2  * This program is free software; you can redistribute it and/or
3  * modify it under the terms of the GNU General Public License
4  * as published by the Free Software Foundation; either version 2
5  * of the License, or (at your option) any later version.
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * along with this program; if not, write to the Free Software Foundation,
14  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
15  */
16
17 /** \file
18  * \ingroup edobj
19  *
20  * General utils to handle mode switching,
21  * actual mode switching logic is per-object type.
22  */
23
24 #include "DNA_gpencil_types.h"
25 #include "DNA_object_types.h"
26 #include "DNA_scene_types.h"
27 #include "DNA_workspace_types.h"
28
29 #include "BLI_utildefines.h"
30
31 #include "BKE_context.h"
32 #include "BKE_layer.h"
33 #include "BKE_object.h"
34 #include "BKE_paint.h"
35 #include "BKE_report.h"
36 #include "BKE_scene.h"
37
38 #include "WM_api.h"
39 #include "WM_types.h"
40
41 #include "RNA_access.h"
42
43 #include "DEG_depsgraph.h"
44
45 #include "ED_armature.h"
46 #include "ED_screen.h"
47
48 #include "ED_object.h" /* own include */
49
50 /* -------------------------------------------------------------------- */
51 /** \name High Level Mode Operations
52  *
53  * \{ */
54
55 static const char *object_mode_op_string(eObjectMode mode)
56 {
57   if (mode & OB_MODE_EDIT) {
58     return "OBJECT_OT_editmode_toggle";
59   }
60   if (mode == OB_MODE_SCULPT) {
61     return "SCULPT_OT_sculptmode_toggle";
62   }
63   if (mode == OB_MODE_VERTEX_PAINT) {
64     return "PAINT_OT_vertex_paint_toggle";
65   }
66   if (mode == OB_MODE_WEIGHT_PAINT) {
67     return "PAINT_OT_weight_paint_toggle";
68   }
69   if (mode == OB_MODE_TEXTURE_PAINT) {
70     return "PAINT_OT_texture_paint_toggle";
71   }
72   if (mode == OB_MODE_PARTICLE_EDIT) {
73     return "PARTICLE_OT_particle_edit_toggle";
74   }
75   if (mode == OB_MODE_POSE) {
76     return "OBJECT_OT_posemode_toggle";
77   }
78   if (mode == OB_MODE_EDIT_GPENCIL) {
79     return "GPENCIL_OT_editmode_toggle";
80   }
81   if (mode == OB_MODE_PAINT_GPENCIL) {
82     return "GPENCIL_OT_paintmode_toggle";
83   }
84   if (mode == OB_MODE_SCULPT_GPENCIL) {
85     return "GPENCIL_OT_sculptmode_toggle";
86   }
87   if (mode == OB_MODE_WEIGHT_GPENCIL) {
88     return "GPENCIL_OT_weightmode_toggle";
89   }
90   return NULL;
91 }
92
93 /**
94  * Checks the mode to be set is compatible with the object
95  * should be made into a generic function
96  */
97 bool ED_object_mode_compat_test(const Object *ob, eObjectMode mode)
98 {
99   if (ob) {
100     if (mode == OB_MODE_OBJECT) {
101       return true;
102     }
103
104     switch (ob->type) {
105       case OB_MESH:
106         if (mode & (OB_MODE_EDIT | OB_MODE_SCULPT | OB_MODE_VERTEX_PAINT | OB_MODE_WEIGHT_PAINT |
107                     OB_MODE_TEXTURE_PAINT | OB_MODE_PARTICLE_EDIT)) {
108           return true;
109         }
110         break;
111       case OB_CURVE:
112       case OB_SURF:
113       case OB_FONT:
114       case OB_MBALL:
115         if (mode & (OB_MODE_EDIT)) {
116           return true;
117         }
118         break;
119       case OB_LATTICE:
120         if (mode & (OB_MODE_EDIT | OB_MODE_WEIGHT_PAINT)) {
121           return true;
122         }
123         break;
124       case OB_ARMATURE:
125         if (mode & (OB_MODE_EDIT | OB_MODE_POSE)) {
126           return true;
127         }
128         break;
129       case OB_GPENCIL:
130         if (mode & (OB_MODE_EDIT | OB_MODE_EDIT_GPENCIL | OB_MODE_PAINT_GPENCIL |
131                     OB_MODE_SCULPT_GPENCIL | OB_MODE_WEIGHT_GPENCIL)) {
132           return true;
133         }
134         break;
135     }
136   }
137
138   return false;
139 }
140
141 /**
142  * Sets the mode to a compatible state (use before entering the mode).
143  *
144  * This is so each mode's exec function can call
145  */
146 bool ED_object_mode_compat_set(bContext *C, Object *ob, eObjectMode mode, ReportList *reports)
147 {
148   bool ok;
149   if (!ELEM(ob->mode, mode, OB_MODE_OBJECT)) {
150     const char *opstring = object_mode_op_string(ob->mode);
151
152     WM_operator_name_call(C, opstring, WM_OP_EXEC_REGION_WIN, NULL);
153     ok = ELEM(ob->mode, mode, OB_MODE_OBJECT);
154     if (!ok) {
155       wmOperatorType *ot = WM_operatortype_find(opstring, false);
156       BKE_reportf(reports, RPT_ERROR, "Unable to execute '%s', error changing modes", ot->name);
157     }
158   }
159   else {
160     ok = true;
161   }
162
163   return ok;
164 }
165
166 void ED_object_mode_toggle(bContext *C, eObjectMode mode)
167 {
168   if (mode != OB_MODE_OBJECT) {
169     const char *opstring = object_mode_op_string(mode);
170
171     if (opstring) {
172       wmOperatorType *ot = WM_operatortype_find(opstring, false);
173       if (ot->flag & OPTYPE_USE_EVAL_DATA) {
174         /* We need to force refresh of depsgraph after undo step,
175          * redoing the operator *may* rely on some valid evaluated data. */
176         struct Main *bmain = CTX_data_main(C);
177         Scene *scene = CTX_data_scene(C);
178         ViewLayer *view_layer = CTX_data_view_layer(C);
179         BKE_scene_view_layer_graph_evaluated_ensure(bmain, scene, view_layer);
180       }
181       WM_operator_name_call_ptr(C, ot, WM_OP_EXEC_REGION_WIN, NULL);
182     }
183   }
184 }
185
186 /* Wrapper for operator  */
187 void ED_object_mode_set(bContext *C, eObjectMode mode)
188 {
189   wmWindowManager *wm = CTX_wm_manager(C);
190   wm->op_undo_depth++;
191   /* needed so we don't do undo pushes. */
192   ED_object_mode_generic_enter(C, mode);
193   wm->op_undo_depth--;
194 }
195
196 void ED_object_mode_exit(bContext *C)
197 {
198   Depsgraph *depsgraph = CTX_data_depsgraph(C);
199   struct Main *bmain = CTX_data_main(C);
200   Scene *scene = CTX_data_scene(C);
201   ViewLayer *view_layer = CTX_data_view_layer(C);
202   FOREACH_OBJECT_BEGIN (view_layer, ob) {
203     if (ob->mode & OB_MODE_ALL_MODE_DATA) {
204       ED_object_mode_generic_exit(bmain, depsgraph, scene, ob);
205     }
206   }
207   FOREACH_OBJECT_END;
208 }
209
210 /** \} */
211
212 /* -------------------------------------------------------------------- */
213 /** \name Generic Mode Enter/Exit
214  *
215  * Supports exiting a mode without it being in the current context.
216  * This could be done for entering modes too if it's needed.
217  *
218  * \{ */
219
220 bool ED_object_mode_generic_enter(struct bContext *C, eObjectMode object_mode)
221 {
222   ViewLayer *view_layer = CTX_data_view_layer(C);
223   Object *ob = OBACT(view_layer);
224   if (ob == NULL) {
225     return (object_mode == OB_MODE_OBJECT);
226   }
227   if (ob->mode == object_mode) {
228     return true;
229   }
230   wmOperatorType *ot = WM_operatortype_find("OBJECT_OT_mode_set", false);
231   PointerRNA ptr;
232   WM_operator_properties_create_ptr(&ptr, ot);
233   RNA_enum_set(&ptr, "mode", object_mode);
234   WM_operator_name_call_ptr(C, ot, WM_OP_INVOKE_DEFAULT, &ptr);
235   WM_operator_properties_free(&ptr);
236   return (ob->mode == object_mode);
237 }
238
239 /**
240  * Use for changing works-paces or changing active object.
241  * Caller can check #OB_MODE_ALL_MODE_DATA to test if this needs to be run.
242  */
243 static bool ed_object_mode_generic_exit_ex(struct Main *bmain,
244                                            struct Depsgraph *depsgraph,
245                                            struct Scene *scene,
246                                            struct Object *ob,
247                                            bool only_test)
248 {
249   BLI_assert((bmain == NULL) == only_test);
250   if (ob->mode & OB_MODE_EDIT) {
251     if (BKE_object_is_in_editmode(ob)) {
252       if (only_test) {
253         return true;
254       }
255       ED_object_editmode_exit_ex(bmain, scene, ob, EM_FREEDATA);
256     }
257   }
258   else if (ob->mode & OB_MODE_VERTEX_PAINT) {
259     if (ob->sculpt && (ob->sculpt->mode_type == OB_MODE_VERTEX_PAINT)) {
260       if (only_test) {
261         return true;
262       }
263       ED_object_vpaintmode_exit_ex(ob);
264     }
265   }
266   else if (ob->mode & OB_MODE_WEIGHT_PAINT) {
267     if (ob->sculpt && (ob->sculpt->mode_type == OB_MODE_WEIGHT_PAINT)) {
268       if (only_test) {
269         return true;
270       }
271       ED_object_wpaintmode_exit_ex(ob);
272     }
273   }
274   else if (ob->mode & OB_MODE_SCULPT) {
275     if (ob->sculpt && (ob->sculpt->mode_type == OB_MODE_SCULPT)) {
276       if (only_test) {
277         return true;
278       }
279       ED_object_sculptmode_exit_ex(depsgraph, scene, ob);
280     }
281   }
282   else if (ob->mode & OB_MODE_POSE) {
283     if (ob->pose != NULL) {
284       if (only_test) {
285         return true;
286       }
287       ED_object_posemode_exit_ex(bmain, ob);
288     }
289   }
290   else {
291     if (only_test) {
292       return false;
293     }
294     BLI_assert((ob->mode & OB_MODE_ALL_MODE_DATA) == 0);
295   }
296
297   return false;
298 }
299
300 void ED_object_mode_generic_exit(struct Main *bmain,
301                                  struct Depsgraph *depsgraph,
302                                  struct Scene *scene,
303                                  struct Object *ob)
304 {
305   ed_object_mode_generic_exit_ex(bmain, depsgraph, scene, ob, false);
306 }
307
308 bool ED_object_mode_generic_has_data(struct Depsgraph *depsgraph, struct Object *ob)
309 {
310   return ed_object_mode_generic_exit_ex(NULL, depsgraph, NULL, ob, true);
311 }
312
313 /** \} */