Cleanup: style, use braces for editors
[blender.git] / source / blender / editors / util / ed_util.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  * The Original Code is Copyright (C) 2008 Blender Foundation.
17  * All rights reserved.
18  */
19
20 /** \file
21  * \ingroup edutil
22  */
23
24 #include <stdlib.h>
25 #include <string.h>
26 #include <math.h>
27
28 #include "MEM_guardedalloc.h"
29
30 #include "DNA_armature_types.h"
31 #include "DNA_mesh_types.h"
32 #include "DNA_object_types.h"
33 #include "DNA_screen_types.h"
34 #include "DNA_space_types.h"
35 #include "DNA_scene_types.h"
36 #include "DNA_packedFile_types.h"
37
38 #include "BLI_utildefines.h"
39 #include "BLI_string.h"
40 #include "BLI_path_util.h"
41
42 #include "BLT_translation.h"
43
44 #include "BKE_context.h"
45 #include "BKE_global.h"
46 #include "BKE_layer.h"
47 #include "BKE_main.h"
48 #include "BKE_multires.h"
49 #include "BKE_object.h"
50 #include "BKE_packedFile.h"
51 #include "BKE_paint.h"
52 #include "BKE_screen.h"
53 #include "BKE_undo_system.h"
54 #include "BKE_workspace.h"
55 #include "BKE_material.h"
56
57 #include "ED_armature.h"
58 #include "ED_buttons.h"
59 #include "ED_image.h"
60 #include "ED_mesh.h"
61 #include "ED_node.h"
62 #include "ED_object.h"
63 #include "ED_outliner.h"
64 #include "ED_paint.h"
65 #include "ED_space_api.h"
66 #include "ED_util.h"
67
68 #include "GPU_immediate.h"
69 #include "GPU_state.h"
70
71 #include "UI_interface.h"
72 #include "UI_resources.h"
73
74 #include "WM_types.h"
75 #include "WM_api.h"
76 #include "RNA_access.h"
77
78 /* ********* general editor util funcs, not BKE stuff please! ********* */
79
80 void ED_editors_init_for_undo(Main *bmain)
81 {
82   wmWindowManager *wm = bmain->wm.first;
83   for (wmWindow *win = wm->windows.first; win; win = win->next) {
84     ViewLayer *view_layer = WM_window_get_active_view_layer(win);
85     Base *base = BASACT(view_layer);
86     if (base != NULL) {
87       Object *ob = base->object;
88       if (ob->mode & OB_MODE_TEXTURE_PAINT) {
89         Scene *scene = WM_window_get_active_scene(win);
90
91         BKE_texpaint_slots_refresh_object(scene, ob);
92         BKE_paint_proj_mesh_data_check(scene, ob, NULL, NULL, NULL, NULL);
93       }
94     }
95   }
96 }
97
98 void ED_editors_init(bContext *C)
99 {
100   struct Depsgraph *depsgraph = CTX_data_depsgraph(C);
101   Main *bmain = CTX_data_main(C);
102   Scene *scene = CTX_data_scene(C);
103   wmWindowManager *wm = CTX_wm_manager(C);
104
105   /* This is called during initialization, so we don't want to store any reports */
106   ReportList *reports = CTX_wm_reports(C);
107   int reports_flag_prev = reports->flag & ~RPT_STORE;
108
109   SWAP(int, reports->flag, reports_flag_prev);
110
111   /* Don't do undo pushes when calling an operator. */
112   wm->op_undo_depth++;
113
114   /* toggle on modes for objects that were saved with these enabled. for
115    * e.g. linked objects we have to ensure that they are actually the
116    * active object in this scene. */
117   Object *obact = CTX_data_active_object(C);
118   if (obact != NULL) {
119     for (Object *ob = bmain->objects.first; ob; ob = ob->id.next) {
120       int mode = ob->mode;
121       if (mode == OB_MODE_OBJECT) {
122         continue;
123       }
124       else if (BKE_object_has_mode_data(ob, mode)) {
125         continue;
126       }
127       else if (ob->type == OB_GPENCIL) {
128         /* For multi-edit mode we may already have mode data.
129          * (grease pencil does not need it) */
130         continue;
131       }
132
133       ID *ob_data = ob->data;
134       ob->mode = OB_MODE_OBJECT;
135       if ((ob->type == obact->type) && !ID_IS_LINKED(ob) && !(ob_data && ID_IS_LINKED(ob_data))) {
136         if (mode == OB_MODE_EDIT) {
137           ED_object_editmode_enter_ex(bmain, scene, ob, 0);
138         }
139         else if (mode == OB_MODE_POSE) {
140           ED_object_posemode_enter_ex(bmain, ob);
141         }
142         else if (mode & OB_MODE_ALL_SCULPT) {
143           if (obact == ob) {
144             if (mode == OB_MODE_SCULPT) {
145               ED_object_sculptmode_enter_ex(bmain, depsgraph, scene, ob, true, reports);
146             }
147             else if (mode == OB_MODE_VERTEX_PAINT) {
148               ED_object_vpaintmode_enter_ex(bmain, depsgraph, wm, scene, ob);
149             }
150             else if (mode == OB_MODE_WEIGHT_PAINT) {
151               ED_object_wpaintmode_enter_ex(bmain, depsgraph, wm, scene, ob);
152             }
153             else {
154               BLI_assert(0);
155             }
156           }
157           else {
158             /* Create data for non-active objects which need it for
159              * mode-switching but don't yet support multi-editing. */
160             if (mode & OB_MODE_ALL_SCULPT) {
161               ob->mode = mode;
162               BKE_object_sculpt_data_create(ob);
163             }
164           }
165         }
166         else {
167           /* TODO(campbell): avoid operator calls. */
168           if (obact == ob) {
169             ED_object_mode_toggle(C, mode);
170           }
171         }
172       }
173     }
174   }
175
176   /* image editor paint mode */
177   if (scene) {
178     ED_space_image_paint_update(bmain, wm, scene);
179   }
180
181   SWAP(int, reports->flag, reports_flag_prev);
182   wm->op_undo_depth--;
183 }
184
185 /* frees all editmode stuff */
186 void ED_editors_exit(Main *bmain, bool do_undo_system)
187 {
188   if (!bmain) {
189     return;
190   }
191
192   /* frees all editmode undos */
193   if (do_undo_system && G_MAIN->wm.first) {
194     wmWindowManager *wm = G_MAIN->wm.first;
195     /* normally we don't check for NULL undo stack,
196      * do here since it may run in different context. */
197     if (wm->undo_stack) {
198       BKE_undosys_stack_destroy(wm->undo_stack);
199       wm->undo_stack = NULL;
200     }
201   }
202
203   for (Object *ob = bmain->objects.first; ob; ob = ob->id.next) {
204     if (ob->type == OB_MESH) {
205       Mesh *me = ob->data;
206       if (me->edit_mesh) {
207         EDBM_mesh_free(me->edit_mesh);
208         MEM_freeN(me->edit_mesh);
209         me->edit_mesh = NULL;
210       }
211     }
212     else if (ob->type == OB_ARMATURE) {
213       bArmature *arm = ob->data;
214       if (arm->edbo) {
215         ED_armature_edit_free(ob->data);
216       }
217     }
218   }
219
220   /* global in meshtools... */
221   ED_mesh_mirror_spatial_table(NULL, NULL, NULL, NULL, 'e');
222   ED_mesh_mirror_topo_table(NULL, NULL, 'e');
223 }
224
225 /* flush any temp data from object editing to DNA before writing files,
226  * rendering, copying, etc. */
227 bool ED_editors_flush_edits(Main *bmain, bool for_render)
228 {
229   bool has_edited = false;
230   Object *ob;
231
232   /* loop through all data to find edit mode or object mode, because during
233    * exiting we might not have a context for edit object and multiple sculpt
234    * objects can exist at the same time */
235   for (ob = bmain->objects.first; ob; ob = ob->id.next) {
236     if (ob->mode & OB_MODE_SCULPT) {
237       /* Don't allow flushing while in the middle of a stroke (frees data in use).
238        * Auto-save prevents this from happening but scripts
239        * may cause a flush on saving: T53986. */
240       if ((ob->sculpt && ob->sculpt->cache) == 0) {
241         /* flush multires changes (for sculpt) */
242         multires_force_update(ob);
243         has_edited = true;
244
245         if (for_render) {
246           /* flush changes from dynamic topology sculpt */
247           BKE_sculptsession_bm_to_me_for_render(ob);
248         }
249         else {
250           /* Set reorder=false so that saving the file doesn't reorder
251            * the BMesh's elements */
252           BKE_sculptsession_bm_to_me(ob, false);
253         }
254       }
255     }
256     else if (ob->mode & OB_MODE_EDIT) {
257       /* get editmode results */
258       has_edited = true;
259       ED_object_editmode_load(bmain, ob);
260     }
261   }
262
263   return has_edited;
264 }
265
266 /* ***** XXX: functions are using old blender names, cleanup later ***** */
267
268 /* now only used in 2d spaces, like time, ipo, nla, sima... */
269 /* XXX shift/ctrl not configurable */
270 void apply_keyb_grid(
271     int shift, int ctrl, float *val, float fac1, float fac2, float fac3, int invert)
272 {
273   /* fac1 is for 'nothing', fac2 for CTRL, fac3 for SHIFT */
274   if (invert) {
275     ctrl = !ctrl;
276   }
277
278   if (ctrl && shift) {
279     if (fac3 != 0.0f) {
280       *val = fac3 * floorf(*val / fac3 + 0.5f);
281     }
282   }
283   else if (ctrl) {
284     if (fac2 != 0.0f) {
285       *val = fac2 * floorf(*val / fac2 + 0.5f);
286     }
287   }
288   else {
289     if (fac1 != 0.0f) {
290       *val = fac1 * floorf(*val / fac1 + 0.5f);
291     }
292   }
293 }
294
295 void unpack_menu(bContext *C,
296                  const char *opname,
297                  const char *id_name,
298                  const char *abs_name,
299                  const char *folder,
300                  struct PackedFile *pf)
301 {
302   Main *bmain = CTX_data_main(C);
303   PointerRNA props_ptr;
304   uiPopupMenu *pup;
305   uiLayout *layout;
306   char line[FILE_MAX + 100];
307   wmOperatorType *ot = WM_operatortype_find(opname, 1);
308
309   pup = UI_popup_menu_begin(C, IFACE_("Unpack File"), ICON_NONE);
310   layout = UI_popup_menu_layout(pup);
311
312   uiItemFullO_ptr(
313       layout, ot, IFACE_("Remove Pack"), ICON_NONE, NULL, WM_OP_EXEC_DEFAULT, 0, &props_ptr);
314   RNA_enum_set(&props_ptr, "method", PF_REMOVE);
315   RNA_string_set(&props_ptr, "id", id_name);
316
317   if (G.relbase_valid) {
318     char local_name[FILE_MAXDIR + FILE_MAX], fi[FILE_MAX];
319
320     BLI_split_file_part(abs_name, fi, sizeof(fi));
321     BLI_snprintf(local_name, sizeof(local_name), "//%s/%s", folder, fi);
322     if (!STREQ(abs_name, local_name)) {
323       switch (checkPackedFile(BKE_main_blendfile_path(bmain), local_name, pf)) {
324         case PF_NOFILE:
325           BLI_snprintf(line, sizeof(line), IFACE_("Create %s"), local_name);
326           uiItemFullO_ptr(layout, ot, line, ICON_NONE, NULL, WM_OP_EXEC_DEFAULT, 0, &props_ptr);
327           RNA_enum_set(&props_ptr, "method", PF_WRITE_LOCAL);
328           RNA_string_set(&props_ptr, "id", id_name);
329
330           break;
331         case PF_EQUAL:
332           BLI_snprintf(line, sizeof(line), IFACE_("Use %s (identical)"), local_name);
333           //uiItemEnumO_ptr(layout, ot, line, 0, "method", PF_USE_LOCAL);
334           uiItemFullO_ptr(layout, ot, line, ICON_NONE, NULL, WM_OP_EXEC_DEFAULT, 0, &props_ptr);
335           RNA_enum_set(&props_ptr, "method", PF_USE_LOCAL);
336           RNA_string_set(&props_ptr, "id", id_name);
337
338           break;
339         case PF_DIFFERS:
340           BLI_snprintf(line, sizeof(line), IFACE_("Use %s (differs)"), local_name);
341           //uiItemEnumO_ptr(layout, ot, line, 0, "method", PF_USE_LOCAL);
342           uiItemFullO_ptr(layout, ot, line, ICON_NONE, NULL, WM_OP_EXEC_DEFAULT, 0, &props_ptr);
343           RNA_enum_set(&props_ptr, "method", PF_USE_LOCAL);
344           RNA_string_set(&props_ptr, "id", id_name);
345
346           BLI_snprintf(line, sizeof(line), IFACE_("Overwrite %s"), local_name);
347           //uiItemEnumO_ptr(layout, ot, line, 0, "method", PF_WRITE_LOCAL);
348           uiItemFullO_ptr(layout, ot, line, ICON_NONE, NULL, WM_OP_EXEC_DEFAULT, 0, &props_ptr);
349           RNA_enum_set(&props_ptr, "method", PF_WRITE_LOCAL);
350           RNA_string_set(&props_ptr, "id", id_name);
351           break;
352       }
353     }
354   }
355
356   switch (checkPackedFile(BKE_main_blendfile_path(bmain), abs_name, pf)) {
357     case PF_NOFILE:
358       BLI_snprintf(line, sizeof(line), IFACE_("Create %s"), abs_name);
359       //uiItemEnumO_ptr(layout, ot, line, 0, "method", PF_WRITE_ORIGINAL);
360       uiItemFullO_ptr(layout, ot, line, ICON_NONE, NULL, WM_OP_EXEC_DEFAULT, 0, &props_ptr);
361       RNA_enum_set(&props_ptr, "method", PF_WRITE_ORIGINAL);
362       RNA_string_set(&props_ptr, "id", id_name);
363       break;
364     case PF_EQUAL:
365       BLI_snprintf(line, sizeof(line), IFACE_("Use %s (identical)"), abs_name);
366       //uiItemEnumO_ptr(layout, ot, line, 0, "method", PF_USE_ORIGINAL);
367       uiItemFullO_ptr(layout, ot, line, ICON_NONE, NULL, WM_OP_EXEC_DEFAULT, 0, &props_ptr);
368       RNA_enum_set(&props_ptr, "method", PF_USE_ORIGINAL);
369       RNA_string_set(&props_ptr, "id", id_name);
370       break;
371     case PF_DIFFERS:
372       BLI_snprintf(line, sizeof(line), IFACE_("Use %s (differs)"), abs_name);
373       //uiItemEnumO_ptr(layout, ot, line, 0, "method", PF_USE_ORIGINAL);
374       uiItemFullO_ptr(layout, ot, line, ICON_NONE, NULL, WM_OP_EXEC_DEFAULT, 0, &props_ptr);
375       RNA_enum_set(&props_ptr, "method", PF_USE_ORIGINAL);
376       RNA_string_set(&props_ptr, "id", id_name);
377
378       BLI_snprintf(line, sizeof(line), IFACE_("Overwrite %s"), abs_name);
379       //uiItemEnumO_ptr(layout, ot, line, 0, "method", PF_WRITE_ORIGINAL);
380       uiItemFullO_ptr(layout, ot, line, ICON_NONE, NULL, WM_OP_EXEC_DEFAULT, 0, &props_ptr);
381       RNA_enum_set(&props_ptr, "method", PF_WRITE_ORIGINAL);
382       RNA_string_set(&props_ptr, "id", id_name);
383       break;
384   }
385
386   UI_popup_menu_end(C, pup);
387 }
388
389 /* ********************* generic callbacks for drawcall api *********************** */
390
391 /**
392  * Callback that draws a line between the mouse and a position given as the initial argument.
393  */
394 void ED_region_draw_mouse_line_cb(const bContext *C, ARegion *ar, void *arg_info)
395 {
396   wmWindow *win = CTX_wm_window(C);
397   const float *mval_src = (float *)arg_info;
398   const float mval_dst[2] = {
399       win->eventstate->x - ar->winrct.xmin,
400       win->eventstate->y - ar->winrct.ymin,
401   };
402
403   const uint shdr_pos = GPU_vertformat_attr_add(
404       immVertexFormat(), "pos", GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
405
406   GPU_line_width(1.0f);
407
408   immBindBuiltinProgram(GPU_SHADER_2D_LINE_DASHED_UNIFORM_COLOR);
409
410   float viewport_size[4];
411   GPU_viewport_size_get_f(viewport_size);
412   immUniform2f("viewport_size", viewport_size[2] / UI_DPI_FAC, viewport_size[3] / UI_DPI_FAC);
413
414   immUniform1i("colors_len", 0); /* "simple" mode */
415   immUniformThemeColor(TH_VIEW_OVERLAY);
416   immUniform1f("dash_width", 6.0f);
417   immUniform1f("dash_factor", 0.5f);
418
419   immBegin(GPU_PRIM_LINES, 2);
420   immVertex2fv(shdr_pos, mval_src);
421   immVertex2fv(shdr_pos, mval_dst);
422   immEnd();
423
424   immUnbindProgram();
425 }
426
427 /**
428  * Use to free ID references within runtime data (stored outside of DNA)
429  *
430  * \param new_id: may be NULL to unlink \a old_id.
431  */
432 void ED_spacedata_id_remap(struct ScrArea *sa, struct SpaceLink *sl, ID *old_id, ID *new_id)
433 {
434   SpaceType *st = BKE_spacetype_from_id(sl->spacetype);
435
436   if (st && st->id_remap) {
437     st->id_remap(sa, sl, old_id, new_id);
438   }
439 }
440
441 static int ed_flush_edits_exec(bContext *C, wmOperator *UNUSED(op))
442 {
443   Main *bmain = CTX_data_main(C);
444   ED_editors_flush_edits(bmain, false);
445   return OPERATOR_FINISHED;
446 }
447
448 void ED_OT_flush_edits(wmOperatorType *ot)
449 {
450   /* identifiers */
451   ot->name = "Flush Edits";
452   ot->description = "Flush edit data from active editing modes";
453   ot->idname = "ED_OT_flush_edits";
454
455   /* api callbacks */
456   ot->exec = ed_flush_edits_exec;
457
458   /* flags */
459   ot->flag = OPTYPE_INTERNAL;
460 }