Fix crashes with invisible Outliners on fullscreen or window closing
[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_kdopbvh.h"
30 #include "BLI_math.h"
31 #include "BLI_utildefines.h"
32
33 #include "BKE_context.h"
34 #include "BKE_gpencil_modifier.h"
35 #include "BKE_layer.h"
36 #include "BKE_main.h"
37 #include "BKE_modifier.h"
38 #include "BKE_object.h"
39 #include "BKE_paint.h"
40 #include "BKE_report.h"
41 #include "BKE_scene.h"
42
43 #include "WM_api.h"
44 #include "WM_types.h"
45
46 #include "RNA_access.h"
47
48 #include "DEG_depsgraph.h"
49 #include "DEG_depsgraph_query.h"
50
51 #include "ED_armature.h"
52 #include "ED_gpencil.h"
53 #include "ED_screen.h"
54 #include "ED_transform_snap_object_context.h"
55 #include "ED_undo.h"
56 #include "ED_view3d.h"
57
58 #include "WM_toolsystem.h"
59
60 #include "ED_object.h" /* own include */
61 #include "object_intern.h"
62
63 /* -------------------------------------------------------------------- */
64 /** \name High Level Mode Operations
65  *
66  * \{ */
67
68 static const char *object_mode_op_string(eObjectMode mode)
69 {
70   if (mode & OB_MODE_EDIT) {
71     return "OBJECT_OT_editmode_toggle";
72   }
73   if (mode == OB_MODE_SCULPT) {
74     return "SCULPT_OT_sculptmode_toggle";
75   }
76   if (mode == OB_MODE_VERTEX_PAINT) {
77     return "PAINT_OT_vertex_paint_toggle";
78   }
79   if (mode == OB_MODE_WEIGHT_PAINT) {
80     return "PAINT_OT_weight_paint_toggle";
81   }
82   if (mode == OB_MODE_TEXTURE_PAINT) {
83     return "PAINT_OT_texture_paint_toggle";
84   }
85   if (mode == OB_MODE_PARTICLE_EDIT) {
86     return "PARTICLE_OT_particle_edit_toggle";
87   }
88   if (mode == OB_MODE_POSE) {
89     return "OBJECT_OT_posemode_toggle";
90   }
91   if (mode == OB_MODE_EDIT_GPENCIL) {
92     return "GPENCIL_OT_editmode_toggle";
93   }
94   if (mode == OB_MODE_PAINT_GPENCIL) {
95     return "GPENCIL_OT_paintmode_toggle";
96   }
97   if (mode == OB_MODE_SCULPT_GPENCIL) {
98     return "GPENCIL_OT_sculptmode_toggle";
99   }
100   if (mode == OB_MODE_WEIGHT_GPENCIL) {
101     return "GPENCIL_OT_weightmode_toggle";
102   }
103   if (mode == OB_MODE_VERTEX_GPENCIL) {
104     return "GPENCIL_OT_vertexmode_toggle";
105   }
106   return NULL;
107 }
108
109 /**
110  * Checks the mode to be set is compatible with the object
111  * should be made into a generic function
112  */
113 bool ED_object_mode_compat_test(const Object *ob, eObjectMode mode)
114 {
115   if (ob) {
116     if (mode == OB_MODE_OBJECT) {
117       return true;
118     }
119
120     switch (ob->type) {
121       case OB_MESH:
122         if (mode & (OB_MODE_EDIT | OB_MODE_SCULPT | OB_MODE_VERTEX_PAINT | OB_MODE_WEIGHT_PAINT |
123                     OB_MODE_TEXTURE_PAINT | OB_MODE_PARTICLE_EDIT)) {
124           return true;
125         }
126         break;
127       case OB_CURVE:
128       case OB_SURF:
129       case OB_FONT:
130       case OB_MBALL:
131         if (mode & OB_MODE_EDIT) {
132           return true;
133         }
134         break;
135       case OB_LATTICE:
136         if (mode & (OB_MODE_EDIT | OB_MODE_WEIGHT_PAINT)) {
137           return true;
138         }
139         break;
140       case OB_ARMATURE:
141         if (mode & (OB_MODE_EDIT | OB_MODE_POSE)) {
142           return true;
143         }
144         break;
145       case OB_GPENCIL:
146         if (mode & (OB_MODE_EDIT | OB_MODE_EDIT_GPENCIL | OB_MODE_PAINT_GPENCIL |
147                     OB_MODE_SCULPT_GPENCIL | OB_MODE_WEIGHT_GPENCIL | OB_MODE_VERTEX_GPENCIL)) {
148           return true;
149         }
150         break;
151     }
152   }
153
154   return false;
155 }
156
157 /**
158  * Sets the mode to a compatible state (use before entering the mode).
159  *
160  * This is so each mode's exec function can call
161  */
162 bool ED_object_mode_compat_set(bContext *C, Object *ob, eObjectMode mode, ReportList *reports)
163 {
164   bool ok;
165   if (!ELEM(ob->mode, mode, OB_MODE_OBJECT)) {
166     const char *opstring = object_mode_op_string(ob->mode);
167
168     WM_operator_name_call(C, opstring, WM_OP_EXEC_REGION_WIN, NULL);
169     ok = ELEM(ob->mode, mode, OB_MODE_OBJECT);
170     if (!ok) {
171       wmOperatorType *ot = WM_operatortype_find(opstring, false);
172       BKE_reportf(reports, RPT_ERROR, "Unable to execute '%s', error changing modes", ot->name);
173     }
174   }
175   else {
176     ok = true;
177   }
178
179   return ok;
180 }
181
182 /** \} */
183
184 /* -------------------------------------------------------------------- */
185 /** \name Generic Mode Enter/Exit
186  *
187  * Supports exiting a mode without it being in the current context.
188  * This could be done for entering modes too if it's needed.
189  *
190  * \{ */
191
192 bool ED_object_mode_set_ex(bContext *C, eObjectMode mode, bool use_undo, ReportList *reports)
193 {
194   wmWindowManager *wm = CTX_wm_manager(C);
195   ViewLayer *view_layer = CTX_data_view_layer(C);
196   Object *ob = OBACT(view_layer);
197   if (ob == NULL) {
198     return (mode == OB_MODE_OBJECT);
199   }
200
201   if ((ob->type == OB_GPENCIL) && (mode == OB_MODE_EDIT)) {
202     mode = OB_MODE_EDIT_GPENCIL;
203   }
204
205   if (ob->mode == mode) {
206     return true;
207   }
208
209   if (!ED_object_mode_compat_test(ob, mode)) {
210     return false;
211   }
212
213   const char *opstring = object_mode_op_string((mode == OB_MODE_OBJECT) ? ob->mode : mode);
214   wmOperatorType *ot = WM_operatortype_find(opstring, false);
215
216   if (!use_undo) {
217     wm->op_undo_depth++;
218   }
219   WM_operator_name_call_ptr(C, ot, WM_OP_EXEC_REGION_WIN, NULL);
220   if (!use_undo) {
221     wm->op_undo_depth--;
222   }
223
224   if (ob->mode != mode) {
225     BKE_reportf(reports, RPT_ERROR, "Unable to execute '%s', error changing modes", ot->name);
226     return false;
227   }
228
229   return true;
230 }
231
232 bool ED_object_mode_set(bContext *C, eObjectMode mode)
233 {
234   /* Don't do undo push by default, since this may be called by lower level code. */
235   return ED_object_mode_set_ex(C, mode, true, NULL);
236 }
237
238 /**
239  * Use for changing works-paces or changing active object.
240  * Caller can check #OB_MODE_ALL_MODE_DATA to test if this needs to be run.
241  */
242 static bool ed_object_mode_generic_exit_ex(struct Main *bmain,
243                                            struct Depsgraph *depsgraph,
244                                            struct Scene *scene,
245                                            struct Object *ob,
246                                            bool only_test)
247 {
248   BLI_assert((bmain == NULL) == only_test);
249   if (ob->mode & OB_MODE_EDIT) {
250     if (BKE_object_is_in_editmode(ob)) {
251       if (only_test) {
252         return true;
253       }
254       ED_object_editmode_exit_ex(bmain, scene, ob, EM_FREEDATA);
255     }
256   }
257   else if (ob->mode & OB_MODE_VERTEX_PAINT) {
258     if (ob->sculpt && (ob->sculpt->mode_type == OB_MODE_VERTEX_PAINT)) {
259       if (only_test) {
260         return true;
261       }
262       ED_object_vpaintmode_exit_ex(ob);
263     }
264   }
265   else if (ob->mode & OB_MODE_WEIGHT_PAINT) {
266     if (ob->sculpt && (ob->sculpt->mode_type == OB_MODE_WEIGHT_PAINT)) {
267       if (only_test) {
268         return true;
269       }
270       ED_object_wpaintmode_exit_ex(ob);
271     }
272   }
273   else if (ob->mode & OB_MODE_SCULPT) {
274     if (ob->sculpt && (ob->sculpt->mode_type == OB_MODE_SCULPT)) {
275       if (only_test) {
276         return true;
277       }
278       ED_object_sculptmode_exit_ex(bmain, depsgraph, scene, ob);
279     }
280   }
281   else if (ob->mode & OB_MODE_POSE) {
282     if (ob->pose != NULL) {
283       if (only_test) {
284         return true;
285       }
286       ED_object_posemode_exit_ex(bmain, ob);
287     }
288   }
289   else if (ob->mode & OB_MODE_TEXTURE_PAINT) {
290     if (only_test) {
291       return true;
292     }
293     ED_object_texture_paint_mode_exit_ex(bmain, scene, ob);
294   }
295   else if (ob->mode & OB_MODE_PARTICLE_EDIT) {
296     if (only_test) {
297       return true;
298     }
299     ED_object_particle_edit_mode_exit_ex(scene, ob);
300   }
301   else if (ob->type == OB_GPENCIL) {
302     /* Accounted for above. */
303     BLI_assert((ob->mode & OB_MODE_OBJECT) == 0);
304     if (only_test) {
305       return true;
306     }
307     ED_object_gpencil_exit(bmain, ob);
308   }
309   else {
310     if (only_test) {
311       return false;
312     }
313     BLI_assert((ob->mode & OB_MODE_ALL_MODE_DATA) == 0);
314   }
315
316   return false;
317 }
318
319 /* When locked, it's almost impossible to select the pose-object
320  * then the mesh-object to enter weight paint mode.
321  * Even when the object mode is not locked this is inconvenient - so allow in either case.
322  *
323  * In this case move our pose object in/out of pose mode.
324  * This is in fits with the convention of selecting multiple objects and entering a mode.
325  */
326 static void ed_object_posemode_set_for_weight_paint_ex(bContext *C,
327                                                        Main *bmain,
328                                                        Object *ob_arm,
329                                                        const bool is_mode_set)
330 {
331   View3D *v3d = CTX_wm_view3d(C);
332   ViewLayer *view_layer = CTX_data_view_layer(C);
333
334   if (ob_arm != NULL) {
335     const Base *base_arm = BKE_view_layer_base_find(view_layer, ob_arm);
336     if (base_arm && BASE_VISIBLE(v3d, base_arm)) {
337       if (is_mode_set) {
338         if ((ob_arm->mode & OB_MODE_POSE) != 0) {
339           ED_object_posemode_exit_ex(bmain, ob_arm);
340         }
341       }
342       else {
343         /* Only check selected status when entering weight-paint mode
344          * because we may have multiple armature objects.
345          * Selecting one will de-select the other, which would leave it in pose-mode
346          * when exiting weight paint mode. While usable, this looks like inconsistent
347          * behavior from a user perspective. */
348         if (base_arm->flag & BASE_SELECTED) {
349           if ((ob_arm->mode & OB_MODE_POSE) == 0) {
350             ED_object_posemode_enter_ex(bmain, ob_arm);
351           }
352         }
353       }
354     }
355   }
356 }
357
358 void ED_object_posemode_set_for_weight_paint(bContext *C,
359                                              Main *bmain,
360                                              Object *ob,
361                                              const bool is_mode_set)
362 {
363   if (ob->type == OB_GPENCIL) {
364     GpencilVirtualModifierData virtualModifierData;
365     GpencilModifierData *md = BKE_gpencil_modifiers_get_virtual_modifierlist(ob,
366                                                                              &virtualModifierData);
367     for (; md; md = md->next) {
368       if (md->type == eGpencilModifierType_Armature) {
369         ArmatureGpencilModifierData *amd = (ArmatureGpencilModifierData *)md;
370         Object *ob_arm = amd->object;
371         ed_object_posemode_set_for_weight_paint_ex(C, bmain, ob_arm, is_mode_set);
372       }
373     }
374   }
375   else {
376     VirtualModifierData virtualModifierData;
377     ModifierData *md = BKE_modifiers_get_virtual_modifierlist(ob, &virtualModifierData);
378     for (; md; md = md->next) {
379       if (md->type == eModifierType_Armature) {
380         ArmatureModifierData *amd = (ArmatureModifierData *)md;
381         Object *ob_arm = amd->object;
382         ed_object_posemode_set_for_weight_paint_ex(C, bmain, ob_arm, is_mode_set);
383       }
384     }
385   }
386 }
387
388 void ED_object_mode_generic_exit(struct Main *bmain,
389                                  struct Depsgraph *depsgraph,
390                                  struct Scene *scene,
391                                  struct Object *ob)
392 {
393   ed_object_mode_generic_exit_ex(bmain, depsgraph, scene, ob, false);
394 }
395
396 bool ED_object_mode_generic_has_data(struct Depsgraph *depsgraph, struct Object *ob)
397 {
398   return ed_object_mode_generic_exit_ex(NULL, depsgraph, NULL, ob, true);
399 }
400
401 /** \} */
402
403 /* -------------------------------------------------------------------- */
404 /** \name Switch Object
405  *
406  * Enters the same mode of the current active object in another object,
407  * leaving the mode of the current object.
408  * \{ */
409
410 static bool object_switch_object_poll(bContext *C)
411 {
412
413   if (!U.experimental.use_switch_object_operator) {
414     return false;
415   }
416
417   if (!CTX_wm_region_view3d(C)) {
418     return false;
419   }
420   const Object *ob = CTX_data_active_object(C);
421   return ob && (ob->mode & (OB_MODE_EDIT | OB_MODE_SCULPT));
422 }
423
424 static int object_switch_object_invoke(bContext *C, wmOperator *op, const wmEvent *event)
425 {
426   ARegion *region = CTX_wm_region(C);
427   Scene *scene = CTX_data_scene(C);
428   ViewLayer *view_layer = CTX_data_view_layer(C);
429
430   Base *base_dst = ED_view3d_give_base_under_cursor(C, event->mval);
431
432   if (base_dst == NULL) {
433     return OPERATOR_CANCELLED;
434   }
435
436   Object *ob_dst = base_dst->object;
437   Object *ob_src = CTX_data_active_object(C);
438
439   if (ob_dst == ob_src) {
440     return OPERATOR_CANCELLED;
441   }
442
443   const eObjectMode last_mode = (eObjectMode)ob_src->mode;
444   if (!ED_object_mode_compat_test(ob_dst, last_mode)) {
445     return OPERATOR_CANCELLED;
446   }
447
448   int retval = OPERATOR_CANCELLED;
449
450   ED_undo_group_begin(C);
451
452   if (ED_object_mode_set_ex(C, OB_MODE_OBJECT, true, op->reports)) {
453     Object *ob_dst_orig = DEG_get_original_object(ob_dst);
454     Base *base = BKE_view_layer_base_find(view_layer, ob_dst_orig);
455     BKE_view_layer_base_deselect_all(view_layer);
456     BKE_view_layer_base_select_and_set_active(view_layer, base);
457     DEG_id_tag_update(&scene->id, ID_RECALC_SELECT);
458
459     ED_undo_push(C, "Change Active");
460
461     ob_dst_orig = DEG_get_original_object(ob_dst);
462     ED_object_mode_set_ex(C, last_mode, true, op->reports);
463
464     /* Update the viewport rotation origin to the mouse cursor. */
465     if (last_mode & OB_MODE_ALL_PAINT) {
466       float global_loc[3];
467       if (ED_view3d_autodist_simple(region, event->mval, global_loc, 0, NULL)) {
468         UnifiedPaintSettings *ups = &scene->toolsettings->unified_paint_settings;
469         copy_v3_v3(ups->average_stroke_accum, global_loc);
470         ups->average_stroke_counter = 1;
471         ups->last_stroke_valid = true;
472       }
473     }
474
475     WM_event_add_notifier(C, NC_SCENE | ND_OB_SELECT, scene);
476     WM_toolsystem_update_from_context_view3d(C);
477     retval = OPERATOR_FINISHED;
478   }
479
480   ED_undo_group_end(C);
481
482   return retval;
483 }
484
485 void OBJECT_OT_switch_object(wmOperatorType *ot)
486 {
487   /* identifiers */
488   ot->name = "Switch Object";
489   ot->idname = "OBJECT_OT_switch_object";
490   ot->description =
491       "Switches the active object and assigns the same mode to a new one under the mouse cursor, "
492       "leaving the active mode in the current one";
493
494   /* api callbacks */
495   ot->invoke = object_switch_object_invoke;
496   ot->poll = object_switch_object_poll;
497
498   /* Undo push is handled by the operator. */
499   ot->flag = OPTYPE_REGISTER;
500 }
501
502 /** \} */