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