Revert "UI: use correct singular and plural nouns in report messages"
[blender.git] / source / blender / editors / space_image / image_ops.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) 2001-2002 by NaN Holding BV.
17  * All rights reserved.
18  */
19
20 /** \file
21  * \ingroup spimage
22  */
23
24 #include <stddef.h>
25 #include <string.h>
26 #include <fcntl.h>
27 #include <stdlib.h>
28 #include <errno.h>
29 #ifndef WIN32
30 #  include <unistd.h>
31 #else
32 #  include <io.h>
33 #endif
34
35 #include "MEM_guardedalloc.h"
36
37 #include "BLI_blenlib.h"
38 #include "BLI_ghash.h"
39 #include "BLI_math.h"
40 #include "BLI_string.h"
41 #include "BLI_utildefines.h"
42
43 #include "BLT_translation.h"
44
45 #include "DNA_camera_types.h"
46 #include "DNA_object_types.h"
47 #include "DNA_node_types.h"
48 #include "DNA_packedFile_types.h"
49 #include "DNA_scene_types.h"
50 #include "DNA_screen_types.h"
51
52 #include "BKE_colortools.h"
53 #include "BKE_context.h"
54 #include "BKE_icons.h"
55 #include "BKE_image.h"
56 #include "BKE_image_save.h"
57 #include "BKE_global.h"
58 #include "BKE_library.h"
59 #include "BKE_main.h"
60 #include "BKE_packedFile.h"
61 #include "BKE_paint.h"
62 #include "BKE_report.h"
63 #include "BKE_screen.h"
64 #include "BKE_scene.h"
65
66 #include "DEG_depsgraph.h"
67
68 #include "GPU_draw.h"
69 #include "GPU_state.h"
70 #include "GPU_immediate.h"
71
72 #include "IMB_colormanagement.h"
73 #include "IMB_imbuf.h"
74 #include "IMB_imbuf_types.h"
75 #include "IMB_moviecache.h"
76 #include "intern/openexr/openexr_multi.h"
77
78 #include "RE_pipeline.h"
79
80 #include "RNA_access.h"
81 #include "RNA_define.h"
82 #include "RNA_enum_types.h"
83
84 #include "ED_image.h"
85 #include "ED_mask.h"
86 #include "ED_paint.h"
87 #include "ED_render.h"
88 #include "ED_screen.h"
89 #include "ED_space_api.h"
90 #include "ED_uvedit.h"
91 #include "ED_util.h"
92
93 #include "UI_interface.h"
94 #include "UI_resources.h"
95 #include "UI_view2d.h"
96
97 #include "WM_api.h"
98 #include "WM_types.h"
99
100 #include "PIL_time.h"
101
102 #include "RE_engine.h"
103
104 #include "image_intern.h"
105
106 /* -------------------------------------------------------------------- */
107 /** \name View Navigation Utilities
108  * \{ */
109
110 static void sima_zoom_set(
111     SpaceImage *sima, ARegion *ar, float zoom, const float location[2], const bool zoom_to_pos)
112 {
113   float oldzoom = sima->zoom;
114   int width, height;
115
116   sima->zoom = zoom;
117
118   if (sima->zoom < 0.1f || sima->zoom > 4.0f) {
119     /* check zoom limits */
120     ED_space_image_get_size(sima, &width, &height);
121
122     width *= sima->zoom;
123     height *= sima->zoom;
124
125     if ((width < 4) && (height < 4) && sima->zoom < oldzoom) {
126       sima->zoom = oldzoom;
127     }
128     else if (BLI_rcti_size_x(&ar->winrct) <= sima->zoom) {
129       sima->zoom = oldzoom;
130     }
131     else if (BLI_rcti_size_y(&ar->winrct) <= sima->zoom) {
132       sima->zoom = oldzoom;
133     }
134   }
135
136   if (zoom_to_pos && location) {
137     float aspx, aspy, w, h;
138
139     ED_space_image_get_size(sima, &width, &height);
140     ED_space_image_get_aspect(sima, &aspx, &aspy);
141
142     w = width * aspx;
143     h = height * aspy;
144
145     sima->xof += ((location[0] - 0.5f) * w - sima->xof) * (sima->zoom - oldzoom) / sima->zoom;
146     sima->yof += ((location[1] - 0.5f) * h - sima->yof) * (sima->zoom - oldzoom) / sima->zoom;
147   }
148 }
149
150 static void sima_zoom_set_factor(
151     SpaceImage *sima, ARegion *ar, float zoomfac, const float location[2], const bool zoom_to_pos)
152 {
153   sima_zoom_set(sima, ar, sima->zoom * zoomfac, location, zoom_to_pos);
154 }
155
156 /**
157  * Fits the view to the bounds exactly, caller should add margin if needed.
158  */
159 static void sima_zoom_set_from_bounds(SpaceImage *sima, ARegion *ar, const rctf *bounds)
160 {
161   int image_size[2];
162   float aspx, aspy;
163
164   ED_space_image_get_size(sima, &image_size[0], &image_size[1]);
165   ED_space_image_get_aspect(sima, &aspx, &aspy);
166
167   image_size[0] = image_size[0] * aspx;
168   image_size[1] = image_size[1] * aspy;
169
170   /* adjust offset and zoom */
171   sima->xof = roundf((BLI_rctf_cent_x(bounds) - 0.5f) * image_size[0]);
172   sima->yof = roundf((BLI_rctf_cent_y(bounds) - 0.5f) * image_size[1]);
173
174   float size_xy[2], size;
175   size_xy[0] = BLI_rcti_size_x(&ar->winrct) / (BLI_rctf_size_x(bounds) * image_size[0]);
176   size_xy[1] = BLI_rcti_size_y(&ar->winrct) / (BLI_rctf_size_y(bounds) * image_size[1]);
177
178   size = min_ff(size_xy[0], size_xy[1]);
179   CLAMP_MAX(size, 100.0f);
180
181   sima_zoom_set(sima, ar, size, NULL, false);
182 }
183
184 static Image *image_from_context(const bContext *C)
185 {
186   /* Edit image is set by templates used throughout the interface, so image
187    * operations work outside the image editor. */
188   Image *ima = CTX_data_pointer_get_type(C, "edit_image", &RNA_Image).data;
189
190   if (ima) {
191     return ima;
192   }
193   else {
194     /* Image editor. */
195     SpaceImage *sima = CTX_wm_space_image(C);
196     return (sima) ? sima->image : NULL;
197   }
198 }
199
200 static ImageUser *image_user_from_context(const bContext *C)
201 {
202   /* Edit image user is set by templates used throughout the interface, so
203    * image operations work outside the image editor. */
204   ImageUser *iuser = CTX_data_pointer_get_type(C, "edit_image_user", &RNA_ImageUser).data;
205
206   if (iuser) {
207     return iuser;
208   }
209   else {
210     /* Image editor. */
211     SpaceImage *sima = CTX_wm_space_image(C);
212     return (sima) ? &sima->iuser : NULL;
213   }
214 }
215
216 static bool image_from_context_has_data_poll(bContext *C)
217 {
218   Image *ima = image_from_context(C);
219   ImageUser *iuser = image_user_from_context(C);
220
221   if (ima == NULL) {
222     return false;
223   }
224
225   void *lock;
226   ImBuf *ibuf = BKE_image_acquire_ibuf(ima, iuser, &lock);
227   const bool has_buffer = (ibuf && (ibuf->rect || ibuf->rect_float));
228   BKE_image_release_ibuf(ima, ibuf, lock);
229   return has_buffer;
230 }
231
232 /**
233  * Use this when the image buffer is accessed without the image user.
234  */
235 static bool image_from_contect_has_data_poll_no_image_user(bContext *C)
236 {
237   Image *ima = image_from_context(C);
238
239   return BKE_image_has_ibuf(ima, NULL);
240 }
241
242 static bool image_not_packed_poll(bContext *C)
243 {
244   /* Do not run 'replace' on packed images, it does not give user expected results at all. */
245   Image *ima = image_from_context(C);
246   return (ima && BLI_listbase_is_empty(&ima->packedfiles));
247 }
248
249 bool space_image_main_region_poll(bContext *C)
250 {
251   SpaceImage *sima = CTX_wm_space_image(C);
252   /* XXX ARegion *ar = CTX_wm_region(C); */
253
254   if (sima) {
255     return true; /* XXX (ar && ar->type->regionid == RGN_TYPE_WINDOW); */
256   }
257   return false;
258 }
259
260 /* For IMAGE_OT_curves_point_set to avoid sampling when in uv smooth mode or editmode */
261 static bool space_image_main_area_not_uv_brush_poll(bContext *C)
262 {
263   SpaceImage *sima = CTX_wm_space_image(C);
264   Scene *scene = CTX_data_scene(C);
265   ToolSettings *toolsettings = scene->toolsettings;
266
267   if (sima && !toolsettings->uvsculpt && (CTX_data_edit_object(C) == NULL)) {
268     return 1;
269   }
270
271   return 0;
272 }
273
274 static bool image_sample_poll(bContext *C)
275 {
276   SpaceImage *sima = CTX_wm_space_image(C);
277   if (sima == NULL) {
278     return false;
279   }
280
281   Object *obedit = CTX_data_edit_object(C);
282   if (obedit) {
283     /* Disable when UV editing so it doesn't swallow all click events
284      * (use for setting cursor). */
285     if (ED_space_image_show_uvedit(sima, obedit)) {
286       return false;
287     }
288   }
289   else if (sima->mode != SI_MODE_VIEW) {
290     return false;
291   }
292
293   return true;
294 }
295
296 /** \} */
297
298 /* -------------------------------------------------------------------- */
299 /** \name View Pan Operator
300  * \{ */
301
302 typedef struct ViewPanData {
303   float x, y;
304   float xof, yof;
305   int event_type;
306   bool own_cursor;
307 } ViewPanData;
308
309 static void image_view_pan_init(bContext *C, wmOperator *op, const wmEvent *event)
310 {
311   wmWindow *win = CTX_wm_window(C);
312   SpaceImage *sima = CTX_wm_space_image(C);
313   ViewPanData *vpd;
314
315   op->customdata = vpd = MEM_callocN(sizeof(ViewPanData), "ImageViewPanData");
316
317   /* Grab will be set when running from gizmo. */
318   vpd->own_cursor = (win->grabcursor == 0);
319   if (vpd->own_cursor) {
320     WM_cursor_modal_set(win, WM_CURSOR_NSEW_SCROLL);
321   }
322
323   vpd->x = event->x;
324   vpd->y = event->y;
325   vpd->xof = sima->xof;
326   vpd->yof = sima->yof;
327   vpd->event_type = event->type;
328
329   WM_event_add_modal_handler(C, op);
330 }
331
332 static void image_view_pan_exit(bContext *C, wmOperator *op, bool cancel)
333 {
334   SpaceImage *sima = CTX_wm_space_image(C);
335   ViewPanData *vpd = op->customdata;
336
337   if (cancel) {
338     sima->xof = vpd->xof;
339     sima->yof = vpd->yof;
340     ED_region_tag_redraw(CTX_wm_region(C));
341   }
342
343   if (vpd->own_cursor) {
344     WM_cursor_modal_restore(CTX_wm_window(C));
345   }
346   MEM_freeN(op->customdata);
347 }
348
349 static int image_view_pan_exec(bContext *C, wmOperator *op)
350 {
351   SpaceImage *sima = CTX_wm_space_image(C);
352   float offset[2];
353
354   RNA_float_get_array(op->ptr, "offset", offset);
355   sima->xof += offset[0];
356   sima->yof += offset[1];
357
358   ED_region_tag_redraw(CTX_wm_region(C));
359
360   return OPERATOR_FINISHED;
361 }
362
363 static int image_view_pan_invoke(bContext *C, wmOperator *op, const wmEvent *event)
364 {
365   if (event->type == MOUSEPAN) {
366     SpaceImage *sima = CTX_wm_space_image(C);
367     float offset[2];
368
369     offset[0] = (event->prevx - event->x) / sima->zoom;
370     offset[1] = (event->prevy - event->y) / sima->zoom;
371     RNA_float_set_array(op->ptr, "offset", offset);
372
373     image_view_pan_exec(C, op);
374     return OPERATOR_FINISHED;
375   }
376   else {
377     image_view_pan_init(C, op, event);
378     return OPERATOR_RUNNING_MODAL;
379   }
380 }
381
382 static int image_view_pan_modal(bContext *C, wmOperator *op, const wmEvent *event)
383 {
384   SpaceImage *sima = CTX_wm_space_image(C);
385   ViewPanData *vpd = op->customdata;
386   float offset[2];
387
388   switch (event->type) {
389     case MOUSEMOVE:
390       sima->xof = vpd->xof;
391       sima->yof = vpd->yof;
392       offset[0] = (vpd->x - event->x) / sima->zoom;
393       offset[1] = (vpd->y - event->y) / sima->zoom;
394       RNA_float_set_array(op->ptr, "offset", offset);
395       image_view_pan_exec(C, op);
396       break;
397     default:
398       if (event->type == vpd->event_type && event->val == KM_RELEASE) {
399         image_view_pan_exit(C, op, false);
400         return OPERATOR_FINISHED;
401       }
402       break;
403   }
404
405   return OPERATOR_RUNNING_MODAL;
406 }
407
408 static void image_view_pan_cancel(bContext *C, wmOperator *op)
409 {
410   image_view_pan_exit(C, op, true);
411 }
412
413 void IMAGE_OT_view_pan(wmOperatorType *ot)
414 {
415   /* identifiers */
416   ot->name = "Pan View";
417   ot->idname = "IMAGE_OT_view_pan";
418   ot->description = "Pan the view";
419
420   /* api callbacks */
421   ot->exec = image_view_pan_exec;
422   ot->invoke = image_view_pan_invoke;
423   ot->modal = image_view_pan_modal;
424   ot->cancel = image_view_pan_cancel;
425   ot->poll = space_image_main_region_poll;
426
427   /* flags */
428   ot->flag = OPTYPE_BLOCKING | OPTYPE_GRAB_CURSOR_XY | OPTYPE_LOCK_BYPASS;
429
430   /* properties */
431   RNA_def_float_vector(ot->srna,
432                        "offset",
433                        2,
434                        NULL,
435                        -FLT_MAX,
436                        FLT_MAX,
437                        "Offset",
438                        "Offset in floating point units, 1.0 is the width and height of the image",
439                        -FLT_MAX,
440                        FLT_MAX);
441 }
442
443 /** \} */
444
445 /* -------------------------------------------------------------------- */
446 /** \name View Zoom Operator
447  * \{ */
448
449 typedef struct ViewZoomData {
450   float origx, origy;
451   float zoom;
452   int event_type;
453   float location[2];
454
455   /* needed for continuous zoom */
456   wmTimer *timer;
457   double timer_lastdraw;
458   bool own_cursor;
459
460   /* */
461   SpaceImage *sima;
462   ARegion *ar;
463 } ViewZoomData;
464
465 static void image_view_zoom_init(bContext *C, wmOperator *op, const wmEvent *event)
466 {
467   wmWindow *win = CTX_wm_window(C);
468   SpaceImage *sima = CTX_wm_space_image(C);
469   ARegion *ar = CTX_wm_region(C);
470   ViewZoomData *vpd;
471
472   op->customdata = vpd = MEM_callocN(sizeof(ViewZoomData), "ImageViewZoomData");
473
474   /* Grab will be set when running from gizmo. */
475   vpd->own_cursor = (win->grabcursor == 0);
476   if (vpd->own_cursor) {
477     WM_cursor_modal_set(win, WM_CURSOR_NSEW_SCROLL);
478   }
479
480   vpd->origx = event->x;
481   vpd->origy = event->y;
482   vpd->zoom = sima->zoom;
483   vpd->event_type = event->type;
484
485   UI_view2d_region_to_view(
486       &ar->v2d, event->mval[0], event->mval[1], &vpd->location[0], &vpd->location[1]);
487
488   if (U.viewzoom == USER_ZOOM_CONT) {
489     /* needs a timer to continue redrawing */
490     vpd->timer = WM_event_add_timer(CTX_wm_manager(C), CTX_wm_window(C), TIMER, 0.01f);
491     vpd->timer_lastdraw = PIL_check_seconds_timer();
492   }
493
494   vpd->sima = sima;
495   vpd->ar = ar;
496
497   WM_event_add_modal_handler(C, op);
498 }
499
500 static void image_view_zoom_exit(bContext *C, wmOperator *op, bool cancel)
501 {
502   SpaceImage *sima = CTX_wm_space_image(C);
503   ViewZoomData *vpd = op->customdata;
504
505   if (cancel) {
506     sima->zoom = vpd->zoom;
507     ED_region_tag_redraw(CTX_wm_region(C));
508   }
509
510   if (vpd->timer) {
511     WM_event_remove_timer(CTX_wm_manager(C), vpd->timer->win, vpd->timer);
512   }
513
514   if (vpd->own_cursor) {
515     WM_cursor_modal_restore(CTX_wm_window(C));
516   }
517   MEM_freeN(op->customdata);
518 }
519
520 static int image_view_zoom_exec(bContext *C, wmOperator *op)
521 {
522   SpaceImage *sima = CTX_wm_space_image(C);
523   ARegion *ar = CTX_wm_region(C);
524
525   sima_zoom_set_factor(sima, ar, RNA_float_get(op->ptr, "factor"), NULL, false);
526
527   ED_region_tag_redraw(ar);
528
529   return OPERATOR_FINISHED;
530 }
531
532 enum {
533   VIEW_PASS = 0,
534   VIEW_APPLY,
535   VIEW_CONFIRM,
536 };
537
538 static int image_view_zoom_invoke(bContext *C, wmOperator *op, const wmEvent *event)
539 {
540   if (event->type == MOUSEZOOM || event->type == MOUSEPAN) {
541     SpaceImage *sima = CTX_wm_space_image(C);
542     ARegion *ar = CTX_wm_region(C);
543     float delta, factor, location[2];
544
545     UI_view2d_region_to_view(&ar->v2d, event->mval[0], event->mval[1], &location[0], &location[1]);
546
547     delta = event->prevx - event->x + event->prevy - event->y;
548
549     if (U.uiflag & USER_ZOOM_INVERT) {
550       delta *= -1;
551     }
552
553     factor = 1.0f + delta / 300.0f;
554     RNA_float_set(op->ptr, "factor", factor);
555     const bool use_cursor_init = RNA_boolean_get(op->ptr, "use_cursor_init");
556     sima_zoom_set(sima,
557                   ar,
558                   sima->zoom * factor,
559                   location,
560                   (use_cursor_init && (U.uiflag & USER_ZOOM_TO_MOUSEPOS)));
561     ED_region_tag_redraw(ar);
562
563     return OPERATOR_FINISHED;
564   }
565   else {
566     image_view_zoom_init(C, op, event);
567     return OPERATOR_RUNNING_MODAL;
568   }
569 }
570
571 static void image_zoom_apply(ViewZoomData *vpd,
572                              wmOperator *op,
573                              const int x,
574                              const int y,
575                              const short viewzoom,
576                              const short zoom_invert,
577                              const bool zoom_to_pos)
578 {
579   float factor;
580   float delta;
581
582   if (viewzoom != USER_ZOOM_SCALE) {
583     if (U.uiflag & USER_ZOOM_HORIZ) {
584       delta = (float)(x - vpd->origx);
585     }
586     else {
587       delta = (float)(y - vpd->origy);
588     }
589   }
590   else {
591     delta = x - vpd->origx + y - vpd->origy;
592   }
593
594   delta /= U.pixelsize;
595
596   if (zoom_invert) {
597     delta = -delta;
598   }
599
600   if (viewzoom == USER_ZOOM_CONT) {
601     double time = PIL_check_seconds_timer();
602     float time_step = (float)(time - vpd->timer_lastdraw);
603     float zfac;
604
605     /* oldstyle zoom */
606     zfac = 1.0f + ((delta / 20.0f) * time_step);
607     vpd->timer_lastdraw = time;
608     /* this is the final zoom, but instead make it into a factor */
609     factor = (vpd->sima->zoom * zfac) / vpd->zoom;
610   }
611   else {
612     factor = 1.0f + delta / 300.0f;
613   }
614
615   RNA_float_set(op->ptr, "factor", factor);
616   sima_zoom_set(vpd->sima, vpd->ar, vpd->zoom * factor, vpd->location, zoom_to_pos);
617   ED_region_tag_redraw(vpd->ar);
618 }
619
620 static int image_view_zoom_modal(bContext *C, wmOperator *op, const wmEvent *event)
621 {
622   ViewZoomData *vpd = op->customdata;
623   short event_code = VIEW_PASS;
624
625   /* execute the events */
626   if (event->type == TIMER && event->customdata == vpd->timer) {
627     /* continuous zoom */
628     event_code = VIEW_APPLY;
629   }
630   else if (event->type == MOUSEMOVE) {
631     event_code = VIEW_APPLY;
632   }
633   else if (event->type == vpd->event_type && event->val == KM_RELEASE) {
634     event_code = VIEW_CONFIRM;
635   }
636
637   if (event_code == VIEW_APPLY) {
638     const bool use_cursor_init = RNA_boolean_get(op->ptr, "use_cursor_init");
639     image_zoom_apply(vpd,
640                      op,
641                      event->x,
642                      event->y,
643                      U.viewzoom,
644                      (U.uiflag & USER_ZOOM_INVERT) != 0,
645                      (use_cursor_init && (U.uiflag & USER_ZOOM_TO_MOUSEPOS)));
646   }
647   else if (event_code == VIEW_CONFIRM) {
648     image_view_zoom_exit(C, op, false);
649     return OPERATOR_FINISHED;
650   }
651
652   return OPERATOR_RUNNING_MODAL;
653 }
654
655 static void image_view_zoom_cancel(bContext *C, wmOperator *op)
656 {
657   image_view_zoom_exit(C, op, true);
658 }
659
660 void IMAGE_OT_view_zoom(wmOperatorType *ot)
661 {
662   PropertyRNA *prop;
663
664   /* identifiers */
665   ot->name = "Zoom View";
666   ot->idname = "IMAGE_OT_view_zoom";
667   ot->description = "Zoom in/out the image";
668
669   /* api callbacks */
670   ot->exec = image_view_zoom_exec;
671   ot->invoke = image_view_zoom_invoke;
672   ot->modal = image_view_zoom_modal;
673   ot->cancel = image_view_zoom_cancel;
674   ot->poll = space_image_main_region_poll;
675
676   /* flags */
677   ot->flag = OPTYPE_BLOCKING | OPTYPE_GRAB_CURSOR_XY | OPTYPE_LOCK_BYPASS;
678
679   /* properties */
680   prop = RNA_def_float(ot->srna,
681                        "factor",
682                        0.0f,
683                        -FLT_MAX,
684                        FLT_MAX,
685                        "Factor",
686                        "Zoom factor, values higher than 1.0 zoom in, lower values zoom out",
687                        -FLT_MAX,
688                        FLT_MAX);
689   RNA_def_property_flag(prop, PROP_HIDDEN);
690
691   WM_operator_properties_use_cursor_init(ot);
692 }
693
694 #ifdef WITH_INPUT_NDOF
695
696 /** \} */
697
698 /* -------------------------------------------------------------------- */
699 /** \name NDOF Operator
700  * \{ */
701
702 /* Combined pan/zoom from a 3D mouse device.
703  * Z zooms, XY pans
704  * "view" (not "paper") control -- user moves the viewpoint, not the image being viewed
705  * that explains the negative signs in the code below
706  */
707
708 static int image_view_ndof_invoke(bContext *C, wmOperator *UNUSED(op), const wmEvent *event)
709 {
710   if (event->type != NDOF_MOTION) {
711     return OPERATOR_CANCELLED;
712   }
713   else {
714     SpaceImage *sima = CTX_wm_space_image(C);
715     ARegion *ar = CTX_wm_region(C);
716     float pan_vec[3];
717
718     const wmNDOFMotionData *ndof = event->customdata;
719     const float speed = NDOF_PIXELS_PER_SECOND;
720
721     WM_event_ndof_pan_get(ndof, pan_vec, true);
722
723     mul_v2_fl(pan_vec, (speed * ndof->dt) / sima->zoom);
724     pan_vec[2] *= -ndof->dt;
725
726     sima_zoom_set_factor(sima, ar, 1.0f + pan_vec[2], NULL, false);
727     sima->xof += pan_vec[0];
728     sima->yof += pan_vec[1];
729
730     ED_region_tag_redraw(ar);
731
732     return OPERATOR_FINISHED;
733   }
734 }
735
736 void IMAGE_OT_view_ndof(wmOperatorType *ot)
737 {
738   /* identifiers */
739   ot->name = "NDOF Pan/Zoom";
740   ot->idname = "IMAGE_OT_view_ndof";
741   ot->description = "Use a 3D mouse device to pan/zoom the view";
742
743   /* api callbacks */
744   ot->invoke = image_view_ndof_invoke;
745   ot->poll = space_image_main_region_poll;
746
747   /* flags */
748   ot->flag = OPTYPE_LOCK_BYPASS;
749 }
750
751 /** \} */
752
753 #endif /* WITH_INPUT_NDOF */
754
755 /* -------------------------------------------------------------------- */
756 /** \name View All Operator
757  * \{ */
758
759 /* Updates the fields of the View2D member of the SpaceImage struct.
760  * Default behavior is to reset the position of the image and set the zoom to 1
761  * If the image will not fit within the window rectangle, the zoom is adjusted */
762
763 static int image_view_all_exec(bContext *C, wmOperator *op)
764 {
765   SpaceImage *sima;
766   ARegion *ar;
767   float aspx, aspy, zoomx, zoomy, w, h;
768   int width, height;
769   const bool fit_view = RNA_boolean_get(op->ptr, "fit_view");
770
771   /* retrieve state */
772   sima = CTX_wm_space_image(C);
773   ar = CTX_wm_region(C);
774
775   ED_space_image_get_size(sima, &width, &height);
776   ED_space_image_get_aspect(sima, &aspx, &aspy);
777
778   w = width * aspx;
779   h = height * aspy;
780
781   /* check if the image will fit in the image with (zoom == 1) */
782   width = BLI_rcti_size_x(&ar->winrct) + 1;
783   height = BLI_rcti_size_y(&ar->winrct) + 1;
784
785   if (fit_view) {
786     const int margin = 5; /* margin from border */
787
788     zoomx = (float)width / (w + 2 * margin);
789     zoomy = (float)height / (h + 2 * margin);
790
791     sima_zoom_set(sima, ar, min_ff(zoomx, zoomy), NULL, false);
792   }
793   else {
794     if ((w >= width || h >= height) && (width > 0 && height > 0)) {
795       zoomx = (float)width / w;
796       zoomy = (float)height / h;
797
798       /* find the zoom value that will fit the image in the image space */
799       sima_zoom_set(sima, ar, 1.0f / power_of_2(1.0f / min_ff(zoomx, zoomy)), NULL, false);
800     }
801     else {
802       sima_zoom_set(sima, ar, 1.0f, NULL, false);
803     }
804   }
805
806   sima->xof = sima->yof = 0.0f;
807
808   ED_region_tag_redraw(ar);
809
810   return OPERATOR_FINISHED;
811 }
812
813 void IMAGE_OT_view_all(wmOperatorType *ot)
814 {
815   PropertyRNA *prop;
816
817   /* identifiers */
818   ot->name = "View All";
819   ot->idname = "IMAGE_OT_view_all";
820   ot->description = "View the entire image";
821
822   /* api callbacks */
823   ot->exec = image_view_all_exec;
824   ot->poll = space_image_main_region_poll;
825
826   /* flags */
827   ot->flag = OPTYPE_LOCK_BYPASS;
828
829   /* properties */
830   prop = RNA_def_boolean(ot->srna, "fit_view", 0, "Fit View", "Fit frame to the viewport");
831   RNA_def_property_flag(prop, PROP_SKIP_SAVE);
832 }
833
834 /** \} */
835
836 /* -------------------------------------------------------------------- */
837 /** \name Center View To Cursor Operator
838  * \{ */
839
840 static int view_center_cursor_exec(bContext *C, wmOperator *UNUSED(op))
841 {
842   SpaceImage *sima = CTX_wm_space_image(C);
843   ARegion *ar = CTX_wm_region(C);
844
845   ED_image_view_center_to_point(sima, sima->cursor[0], sima->cursor[1]);
846
847   ED_region_tag_redraw(ar);
848
849   return OPERATOR_FINISHED;
850 }
851
852 void IMAGE_OT_view_center_cursor(wmOperatorType *ot)
853 {
854   /* identifiers */
855   ot->name = "Center View to Cursor";
856   ot->description = "Center the view so that the cursor is in the middle of the view";
857   ot->idname = "IMAGE_OT_view_center_cursor";
858
859   /* api callbacks */
860   ot->exec = view_center_cursor_exec;
861   ot->poll = ED_space_image_cursor_poll;
862 }
863
864 /** \} */
865
866 /* -------------------------------------------------------------------- */
867 /** \name View Selected Operator
868  * \{ */
869
870 static int image_view_selected_exec(bContext *C, wmOperator *UNUSED(op))
871 {
872   SpaceImage *sima;
873   ARegion *ar;
874   Scene *scene;
875   ViewLayer *view_layer;
876   Object *obedit;
877   Image *ima;
878
879   /* retrieve state */
880   sima = CTX_wm_space_image(C);
881   ar = CTX_wm_region(C);
882   scene = CTX_data_scene(C);
883   view_layer = CTX_data_view_layer(C);
884   obedit = CTX_data_edit_object(C);
885
886   ima = ED_space_image(sima);
887
888   /* get bounds */
889   float min[2], max[2];
890   if (ED_space_image_show_uvedit(sima, obedit)) {
891     if (!ED_uvedit_minmax(scene, ima, obedit, min, max)) {
892       return OPERATOR_CANCELLED;
893     }
894   }
895   else if (ED_space_image_check_show_maskedit(sima, view_layer)) {
896     if (!ED_mask_selected_minmax(C, min, max)) {
897       return OPERATOR_CANCELLED;
898     }
899   }
900   rctf bounds = {
901       .xmin = min[0],
902       .ymin = min[1],
903       .xmax = max[0],
904       .ymax = max[1],
905   };
906
907   /* add some margin */
908   BLI_rctf_scale(&bounds, 1.4f);
909
910   sima_zoom_set_from_bounds(sima, ar, &bounds);
911
912   ED_region_tag_redraw(ar);
913
914   return OPERATOR_FINISHED;
915 }
916
917 static bool image_view_selected_poll(bContext *C)
918 {
919   return (space_image_main_region_poll(C) && (ED_operator_uvedit(C) || ED_operator_mask(C)));
920 }
921
922 void IMAGE_OT_view_selected(wmOperatorType *ot)
923 {
924   /* identifiers */
925   ot->name = "View Center";
926   ot->idname = "IMAGE_OT_view_selected";
927   ot->description = "View all selected UVs";
928
929   /* api callbacks */
930   ot->exec = image_view_selected_exec;
931   ot->poll = image_view_selected_poll;
932 }
933
934 /** \} */
935
936 /* -------------------------------------------------------------------- */
937 /** \name View Zoom In/Out Operator
938  * \{ */
939
940 static int image_view_zoom_in_exec(bContext *C, wmOperator *op)
941 {
942   SpaceImage *sima = CTX_wm_space_image(C);
943   ARegion *ar = CTX_wm_region(C);
944   float location[2];
945
946   RNA_float_get_array(op->ptr, "location", location);
947
948   sima_zoom_set_factor(
949       sima, ar, powf(2.0f, 1.0f / 3.0f), location, U.uiflag & USER_ZOOM_TO_MOUSEPOS);
950
951   ED_region_tag_redraw(ar);
952
953   return OPERATOR_FINISHED;
954 }
955
956 static int image_view_zoom_in_invoke(bContext *C, wmOperator *op, const wmEvent *event)
957 {
958   ARegion *ar = CTX_wm_region(C);
959   float location[2];
960
961   UI_view2d_region_to_view(&ar->v2d, event->mval[0], event->mval[1], &location[0], &location[1]);
962   RNA_float_set_array(op->ptr, "location", location);
963
964   return image_view_zoom_in_exec(C, op);
965 }
966
967 void IMAGE_OT_view_zoom_in(wmOperatorType *ot)
968 {
969   PropertyRNA *prop;
970
971   /* identifiers */
972   ot->name = "View Zoom In";
973   ot->idname = "IMAGE_OT_view_zoom_in";
974   ot->description = "Zoom in the image (centered around 2D cursor)";
975
976   /* api callbacks */
977   ot->invoke = image_view_zoom_in_invoke;
978   ot->exec = image_view_zoom_in_exec;
979   ot->poll = space_image_main_region_poll;
980
981   /* flags */
982   ot->flag = OPTYPE_LOCK_BYPASS;
983
984   /* properties */
985   prop = RNA_def_float_vector(ot->srna,
986                               "location",
987                               2,
988                               NULL,
989                               -FLT_MAX,
990                               FLT_MAX,
991                               "Location",
992                               "Cursor location in screen coordinates",
993                               -10.0f,
994                               10.0f);
995   RNA_def_property_flag(prop, PROP_HIDDEN);
996 }
997
998 static int image_view_zoom_out_exec(bContext *C, wmOperator *op)
999 {
1000   SpaceImage *sima = CTX_wm_space_image(C);
1001   ARegion *ar = CTX_wm_region(C);
1002   float location[2];
1003
1004   RNA_float_get_array(op->ptr, "location", location);
1005
1006   sima_zoom_set_factor(
1007       sima, ar, powf(0.5f, 1.0f / 3.0f), location, U.uiflag & USER_ZOOM_TO_MOUSEPOS);
1008
1009   ED_region_tag_redraw(ar);
1010
1011   return OPERATOR_FINISHED;
1012 }
1013
1014 static int image_view_zoom_out_invoke(bContext *C, wmOperator *op, const wmEvent *event)
1015 {
1016   ARegion *ar = CTX_wm_region(C);
1017   float location[2];
1018
1019   UI_view2d_region_to_view(&ar->v2d, event->mval[0], event->mval[1], &location[0], &location[1]);
1020   RNA_float_set_array(op->ptr, "location", location);
1021
1022   return image_view_zoom_out_exec(C, op);
1023 }
1024
1025 void IMAGE_OT_view_zoom_out(wmOperatorType *ot)
1026 {
1027   PropertyRNA *prop;
1028
1029   /* identifiers */
1030   ot->name = "View Zoom Out";
1031   ot->idname = "IMAGE_OT_view_zoom_out";
1032   ot->description = "Zoom out the image (centered around 2D cursor)";
1033
1034   /* api callbacks */
1035   ot->invoke = image_view_zoom_out_invoke;
1036   ot->exec = image_view_zoom_out_exec;
1037   ot->poll = space_image_main_region_poll;
1038
1039   /* flags */
1040   ot->flag = OPTYPE_LOCK_BYPASS;
1041
1042   /* properties */
1043   prop = RNA_def_float_vector(ot->srna,
1044                               "location",
1045                               2,
1046                               NULL,
1047                               -FLT_MAX,
1048                               FLT_MAX,
1049                               "Location",
1050                               "Cursor location in screen coordinates",
1051                               -10.0f,
1052                               10.0f);
1053   RNA_def_property_flag(prop, PROP_HIDDEN);
1054 }
1055
1056 /** \} */
1057
1058 /* -------------------------------------------------------------------- */
1059 /** \name View Zoom Ratio Operator
1060  * \{ */
1061
1062 static int image_view_zoom_ratio_exec(bContext *C, wmOperator *op)
1063 {
1064   SpaceImage *sima = CTX_wm_space_image(C);
1065   ARegion *ar = CTX_wm_region(C);
1066
1067   sima_zoom_set(sima, ar, RNA_float_get(op->ptr, "ratio"), NULL, false);
1068
1069   /* ensure pixel exact locations for draw */
1070   sima->xof = (int)sima->xof;
1071   sima->yof = (int)sima->yof;
1072
1073   ED_region_tag_redraw(ar);
1074
1075   return OPERATOR_FINISHED;
1076 }
1077
1078 void IMAGE_OT_view_zoom_ratio(wmOperatorType *ot)
1079 {
1080   /* identifiers */
1081   ot->name = "View Zoom Ratio";
1082   ot->idname = "IMAGE_OT_view_zoom_ratio";
1083   ot->description = "Set zoom ratio of the view";
1084
1085   /* api callbacks */
1086   ot->exec = image_view_zoom_ratio_exec;
1087   ot->poll = space_image_main_region_poll;
1088
1089   /* flags */
1090   ot->flag = OPTYPE_LOCK_BYPASS;
1091
1092   /* properties */
1093   RNA_def_float(ot->srna,
1094                 "ratio",
1095                 0.0f,
1096                 -FLT_MAX,
1097                 FLT_MAX,
1098                 "Ratio",
1099                 "Zoom ratio, 1.0 is 1:1, higher is zoomed in, lower is zoomed out",
1100                 -FLT_MAX,
1101                 FLT_MAX);
1102 }
1103
1104 /** \} */
1105
1106 /* -------------------------------------------------------------------- */
1107 /** \name View Border-Zoom Operator
1108  * \{ */
1109
1110 static int image_view_zoom_border_exec(bContext *C, wmOperator *op)
1111 {
1112   SpaceImage *sima = CTX_wm_space_image(C);
1113   ARegion *ar = CTX_wm_region(C);
1114   rctf bounds;
1115   const bool zoom_in = !RNA_boolean_get(op->ptr, "zoom_out");
1116
1117   WM_operator_properties_border_to_rctf(op, &bounds);
1118
1119   UI_view2d_region_to_view_rctf(&ar->v2d, &bounds, &bounds);
1120
1121   const struct {
1122     float xof;
1123     float yof;
1124     float zoom;
1125   } sima_view_prev = {
1126       .xof = sima->xof,
1127       .yof = sima->yof,
1128       .zoom = sima->zoom,
1129   };
1130
1131   sima_zoom_set_from_bounds(sima, ar, &bounds);
1132
1133   /* zoom out */
1134   if (!zoom_in) {
1135     sima->xof = sima_view_prev.xof + (sima->xof - sima_view_prev.xof);
1136     sima->yof = sima_view_prev.yof + (sima->yof - sima_view_prev.yof);
1137     sima->zoom = sima_view_prev.zoom * (sima_view_prev.zoom / sima->zoom);
1138   }
1139
1140   ED_region_tag_redraw(ar);
1141
1142   return OPERATOR_FINISHED;
1143 }
1144
1145 void IMAGE_OT_view_zoom_border(wmOperatorType *ot)
1146 {
1147   /* identifiers */
1148   ot->name = "Zoom to Border";
1149   ot->description = "Zoom in the view to the nearest item contained in the border";
1150   ot->idname = "IMAGE_OT_view_zoom_border";
1151
1152   /* api callbacks */
1153   ot->invoke = WM_gesture_box_invoke;
1154   ot->exec = image_view_zoom_border_exec;
1155   ot->modal = WM_gesture_box_modal;
1156   ot->cancel = WM_gesture_box_cancel;
1157
1158   ot->poll = space_image_main_region_poll;
1159
1160   /* rna */
1161   WM_operator_properties_gesture_box_zoom(ot);
1162 }
1163
1164 /* load/replace/save callbacks */
1165 static void image_filesel(bContext *C, wmOperator *op, const char *path)
1166 {
1167   RNA_string_set(op->ptr, "filepath", path);
1168   WM_event_add_fileselect(C, op);
1169 }
1170
1171 /** \} */
1172
1173 /* -------------------------------------------------------------------- */
1174 /** \name Open Image Operator
1175  * \{ */
1176
1177 typedef struct ImageOpenData {
1178   PropertyPointerRNA pprop;
1179   ImageUser *iuser;
1180   ImageFormatData im_format;
1181 } ImageOpenData;
1182
1183 typedef struct ImageFrameRange {
1184   struct ImageFrameRange *next, *prev;
1185   ListBase frames;
1186   /**  The full path of the first file in the list of image files */
1187   char filepath[FILE_MAX];
1188 } ImageFrameRange;
1189
1190 typedef struct ImageFrame {
1191   struct ImageFrame *next, *prev;
1192   int framenr;
1193 } ImageFrame;
1194
1195 static void image_open_init(bContext *C, wmOperator *op)
1196 {
1197   ImageOpenData *iod;
1198   op->customdata = iod = MEM_callocN(sizeof(ImageOpenData), __func__);
1199   iod->iuser = CTX_data_pointer_get_type(C, "image_user", &RNA_ImageUser).data;
1200   UI_context_active_but_prop_get_templateID(C, &iod->pprop.ptr, &iod->pprop.prop);
1201 }
1202
1203 static void image_open_cancel(bContext *UNUSED(C), wmOperator *op)
1204 {
1205   MEM_freeN(op->customdata);
1206   op->customdata = NULL;
1207 }
1208
1209 /**
1210  * Get a list of frames from the list of image files matching the first file name sequence pattern.
1211  * \param ptr[in]: The RNA pointer containing the "directory" entry and "files" collection.
1212  * \param frames_all[out]: the list of frame numbers found in the files matching
1213  * the first one by name.
1214  */
1215 static void image_sequence_get_frame_ranges(PointerRNA *ptr, ListBase *frames_all)
1216 {
1217   char dir[FILE_MAXDIR];
1218   const bool do_frame_range = RNA_boolean_get(ptr, "use_sequence_detection");
1219   ImageFrameRange *frame_range = NULL;
1220
1221   RNA_string_get(ptr, "directory", dir);
1222   RNA_BEGIN (ptr, itemptr, "files") {
1223     char base_head[FILE_MAX], base_tail[FILE_MAX];
1224     char head[FILE_MAX], tail[FILE_MAX];
1225     unsigned short digits;
1226     char *filename = RNA_string_get_alloc(&itemptr, "name", NULL, 0);
1227     ImageFrame *frame = MEM_callocN(sizeof(ImageFrame), "image_frame");
1228
1229     /* use the first file in the list as base filename */
1230     frame->framenr = BLI_stringdec(filename, head, tail, &digits);
1231
1232     /* still in the same sequence */
1233     if (do_frame_range && (frame_range != NULL) && (STREQLEN(base_head, head, FILE_MAX)) &&
1234         (STREQLEN(base_tail, tail, FILE_MAX))) {
1235       /* pass */
1236     }
1237     else {
1238       /* start a new frame range */
1239       frame_range = MEM_callocN(sizeof(*frame_range), __func__);
1240       BLI_join_dirfile(frame_range->filepath, sizeof(frame_range->filepath), dir, filename);
1241       BLI_addtail(frames_all, frame_range);
1242
1243       BLI_strncpy(base_head, head, sizeof(base_head));
1244       BLI_strncpy(base_tail, tail, sizeof(base_tail));
1245     }
1246
1247     BLI_addtail(&frame_range->frames, frame);
1248     MEM_freeN(filename);
1249   }
1250   RNA_END;
1251 }
1252
1253 static int image_cmp_frame(const void *a, const void *b)
1254 {
1255   const ImageFrame *frame_a = a;
1256   const ImageFrame *frame_b = b;
1257
1258   if (frame_a->framenr < frame_b->framenr) {
1259     return -1;
1260   }
1261   if (frame_a->framenr > frame_b->framenr) {
1262     return 1;
1263   }
1264   return 0;
1265 }
1266
1267 /**
1268  * Return the start (offset) and the length of the sequence of
1269  * continuous frames in the list of frames.
1270  *
1271  * \param frames: [in] the list of frame numbers, as a side-effect the list is sorted.
1272  * \param ofs: [out] offset the first frame number in the sequence.
1273  * \return the number of contiguous frames in the sequence
1274  */
1275 static int image_sequence_get_len(ListBase *frames, int *ofs)
1276 {
1277   ImageFrame *frame;
1278
1279   BLI_listbase_sort(frames, image_cmp_frame);
1280
1281   frame = frames->first;
1282   if (frame) {
1283     int frame_curr = frame->framenr;
1284     (*ofs) = frame_curr;
1285     while (frame && (frame->framenr == frame_curr)) {
1286       frame_curr++;
1287       frame = frame->next;
1288     }
1289     return frame_curr - (*ofs);
1290   }
1291   *ofs = 0;
1292   return 0;
1293 }
1294
1295 static Image *image_open_single(Main *bmain,
1296                                 wmOperator *op,
1297                                 const char *filepath,
1298                                 const char *relbase,
1299                                 bool is_relative_path,
1300                                 bool use_multiview,
1301                                 int frame_seq_len)
1302 {
1303   bool exists = false;
1304   Image *ima = NULL;
1305
1306   errno = 0;
1307   ima = BKE_image_load_exists_ex(bmain, filepath, &exists);
1308
1309   if (!ima) {
1310     if (op->customdata) {
1311       MEM_freeN(op->customdata);
1312     }
1313     BKE_reportf(op->reports,
1314                 RPT_ERROR,
1315                 "Cannot read '%s': %s",
1316                 filepath,
1317                 errno ? strerror(errno) : TIP_("unsupported image format"));
1318     return NULL;
1319   }
1320
1321   if (!exists) {
1322     /* only image path after save, never ibuf */
1323     if (is_relative_path) {
1324       BLI_path_rel(ima->name, relbase);
1325     }
1326
1327     /* handle multiview images */
1328     if (use_multiview) {
1329       ImageOpenData *iod = op->customdata;
1330       ImageFormatData *imf = &iod->im_format;
1331
1332       ima->flag |= IMA_USE_VIEWS;
1333       ima->views_format = imf->views_format;
1334       *ima->stereo3d_format = imf->stereo3d_format;
1335     }
1336     else {
1337       ima->flag &= ~IMA_USE_VIEWS;
1338       BKE_image_free_views(ima);
1339     }
1340
1341     if ((frame_seq_len > 1) && (ima->source == IMA_SRC_FILE)) {
1342       ima->source = IMA_SRC_SEQUENCE;
1343     }
1344   }
1345
1346   return ima;
1347 }
1348
1349 static int image_open_exec(bContext *C, wmOperator *op)
1350 {
1351   Main *bmain = CTX_data_main(C);
1352   ScrArea *sa = CTX_wm_area(C);
1353   Scene *scene = CTX_data_scene(C);
1354   Object *obedit = CTX_data_edit_object(C);
1355   ImageUser *iuser = NULL;
1356   ImageOpenData *iod = op->customdata;
1357   Image *ima = NULL;
1358   char filepath[FILE_MAX];
1359   int frame_seq_len = 0;
1360   int frame_ofs = 1;
1361
1362   const bool is_relative_path = RNA_boolean_get(op->ptr, "relative_path");
1363   const bool use_multiview = RNA_boolean_get(op->ptr, "use_multiview");
1364
1365   if (!op->customdata) {
1366     image_open_init(C, op);
1367   }
1368
1369   RNA_string_get(op->ptr, "filepath", filepath);
1370
1371   if (RNA_struct_property_is_set(op->ptr, "directory") &&
1372       RNA_struct_property_is_set(op->ptr, "files")) {
1373     bool was_relative = BLI_path_is_rel(filepath);
1374     ListBase frame_ranges_all;
1375
1376     BLI_listbase_clear(&frame_ranges_all);
1377     image_sequence_get_frame_ranges(op->ptr, &frame_ranges_all);
1378     for (ImageFrameRange *frame_range = frame_ranges_all.first; frame_range;
1379          frame_range = frame_range->next) {
1380       int frame_range_ofs;
1381       int frame_range_seq_len = image_sequence_get_len(&frame_range->frames, &frame_range_ofs);
1382       BLI_freelistN(&frame_range->frames);
1383
1384       char filepath_range[FILE_MAX];
1385       BLI_strncpy(filepath_range, frame_range->filepath, sizeof(filepath_range));
1386
1387       if (was_relative) {
1388         BLI_path_rel(filepath_range, BKE_main_blendfile_path(bmain));
1389       }
1390
1391       Image *ima_range = image_open_single(bmain,
1392                                            op,
1393                                            filepath_range,
1394                                            BKE_main_blendfile_path(bmain),
1395                                            is_relative_path,
1396                                            use_multiview,
1397                                            frame_range_seq_len);
1398
1399       /* take the first image */
1400       if ((ima == NULL) && ima_range) {
1401         ima = ima_range;
1402         frame_seq_len = frame_range_seq_len;
1403         frame_ofs = frame_range_ofs;
1404       }
1405     }
1406     BLI_freelistN(&frame_ranges_all);
1407   }
1408   else {
1409     /* for drag & drop etc. */
1410     ima = image_open_single(
1411         bmain, op, filepath, BKE_main_blendfile_path(bmain), is_relative_path, use_multiview, 1);
1412   }
1413
1414   if (ima == NULL) {
1415     return OPERATOR_CANCELLED;
1416   }
1417
1418   /* hook into UI */
1419   iod = op->customdata;
1420
1421   if (iod->pprop.prop) {
1422     /* when creating new ID blocks, use is already 1, but RNA
1423      * pointer use also increases user, so this compensates it */
1424     id_us_min(&ima->id);
1425
1426     PointerRNA imaptr;
1427     RNA_id_pointer_create(&ima->id, &imaptr);
1428     RNA_property_pointer_set(&iod->pprop.ptr, iod->pprop.prop, imaptr, NULL);
1429     RNA_property_update(C, &iod->pprop.ptr, iod->pprop.prop);
1430   }
1431
1432   if (iod->iuser) {
1433     iuser = iod->iuser;
1434   }
1435   else if (sa && sa->spacetype == SPACE_IMAGE) {
1436     SpaceImage *sima = sa->spacedata.first;
1437     ED_space_image_set(bmain, sima, obedit, ima, false);
1438     iuser = &sima->iuser;
1439   }
1440   else {
1441     Tex *tex = CTX_data_pointer_get_type(C, "texture", &RNA_Texture).data;
1442     if (tex && tex->type == TEX_IMAGE) {
1443       iuser = &tex->iuser;
1444     }
1445
1446     if (iuser == NULL) {
1447       Camera *cam = CTX_data_pointer_get_type(C, "camera", &RNA_Camera).data;
1448       if (cam) {
1449         for (CameraBGImage *bgpic = cam->bg_images.first; bgpic; bgpic = bgpic->next) {
1450           if (bgpic->ima == ima) {
1451             iuser = &bgpic->iuser;
1452             break;
1453           }
1454         }
1455       }
1456     }
1457   }
1458
1459   /* initialize because of new image */
1460   if (iuser) {
1461     iuser->frames = frame_seq_len;
1462     iuser->sfra = 1;
1463     iuser->framenr = 1;
1464     if (ima->source == IMA_SRC_MOVIE) {
1465       iuser->offset = 0;
1466     }
1467     else {
1468       iuser->offset = frame_ofs - 1;
1469     }
1470     iuser->scene = scene;
1471     BKE_image_init_imageuser(ima, iuser);
1472   }
1473
1474   /* XXX BKE_packedfile_unpack_image frees image buffers */
1475   ED_preview_kill_jobs(CTX_wm_manager(C), bmain);
1476
1477   BKE_image_signal(bmain, ima, iuser, IMA_SIGNAL_RELOAD);
1478   WM_event_add_notifier(C, NC_IMAGE | NA_EDITED, ima);
1479
1480   MEM_freeN(op->customdata);
1481
1482   return OPERATOR_FINISHED;
1483 }
1484
1485 static int image_open_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
1486 {
1487   SpaceImage *sima = CTX_wm_space_image(C); /* XXX other space types can call */
1488   const char *path = U.textudir;
1489   Image *ima = NULL;
1490   Scene *scene = CTX_data_scene(C);
1491
1492   if (sima) {
1493     ima = sima->image;
1494   }
1495
1496   if (ima == NULL) {
1497     Tex *tex = CTX_data_pointer_get_type(C, "texture", &RNA_Texture).data;
1498     if (tex && tex->type == TEX_IMAGE) {
1499       ima = tex->ima;
1500     }
1501   }
1502
1503   if (ima == NULL) {
1504     PointerRNA ptr;
1505     PropertyRNA *prop;
1506
1507     /* hook into UI */
1508     UI_context_active_but_prop_get_templateID(C, &ptr, &prop);
1509
1510     if (prop) {
1511       PointerRNA oldptr;
1512       Image *oldima;
1513
1514       oldptr = RNA_property_pointer_get(&ptr, prop);
1515       oldima = (Image *)oldptr.owner_id;
1516       /* unlikely to fail but better avoid strange crash */
1517       if (oldima && GS(oldima->id.name) == ID_IM) {
1518         ima = oldima;
1519       }
1520     }
1521   }
1522
1523   if (ima) {
1524     path = ima->name;
1525   }
1526
1527   if (RNA_struct_property_is_set(op->ptr, "filepath")) {
1528     return image_open_exec(C, op);
1529   }
1530
1531   image_open_init(C, op);
1532
1533   /* show multiview save options only if scene has multiviews */
1534   PropertyRNA *prop;
1535   prop = RNA_struct_find_property(op->ptr, "show_multiview");
1536   RNA_property_boolean_set(op->ptr, prop, (scene->r.scemode & R_MULTIVIEW) != 0);
1537
1538   image_filesel(C, op, path);
1539
1540   return OPERATOR_RUNNING_MODAL;
1541 }
1542
1543 static bool image_open_draw_check_prop(PointerRNA *UNUSED(ptr),
1544                                        PropertyRNA *prop,
1545                                        void *UNUSED(user_data))
1546 {
1547   const char *prop_id = RNA_property_identifier(prop);
1548
1549   return !(STREQ(prop_id, "filepath") || STREQ(prop_id, "directory") ||
1550            STREQ(prop_id, "filename"));
1551 }
1552
1553 static void image_open_draw(bContext *UNUSED(C), wmOperator *op)
1554 {
1555   uiLayout *layout = op->layout;
1556   ImageOpenData *iod = op->customdata;
1557   ImageFormatData *imf = &iod->im_format;
1558   PointerRNA imf_ptr, ptr;
1559
1560   /* main draw call */
1561   RNA_pointer_create(NULL, op->type->srna, op->properties, &ptr);
1562   uiDefAutoButsRNA(
1563       layout, &ptr, image_open_draw_check_prop, NULL, NULL, UI_BUT_LABEL_ALIGN_NONE, false);
1564
1565   /* image template */
1566   RNA_pointer_create(NULL, &RNA_ImageFormatSettings, imf, &imf_ptr);
1567
1568   /* multiview template */
1569   if (RNA_boolean_get(op->ptr, "show_multiview")) {
1570     uiTemplateImageFormatViews(layout, &imf_ptr, op->ptr);
1571   }
1572 }
1573
1574 /* called by other space types too */
1575 void IMAGE_OT_open(wmOperatorType *ot)
1576 {
1577   /* identifiers */
1578   ot->name = "Open Image";
1579   ot->description = "Open image";
1580   ot->idname = "IMAGE_OT_open";
1581
1582   /* api callbacks */
1583   ot->exec = image_open_exec;
1584   ot->invoke = image_open_invoke;
1585   ot->cancel = image_open_cancel;
1586   ot->ui = image_open_draw;
1587
1588   /* flags */
1589   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
1590
1591   /* properties */
1592   WM_operator_properties_filesel(ot,
1593                                  FILE_TYPE_FOLDER | FILE_TYPE_IMAGE | FILE_TYPE_MOVIE,
1594                                  FILE_SPECIAL,
1595                                  FILE_OPENFILE,
1596                                  WM_FILESEL_FILEPATH | WM_FILESEL_DIRECTORY | WM_FILESEL_FILES |
1597                                      WM_FILESEL_RELPATH,
1598                                  FILE_DEFAULTDISPLAY,
1599                                  FILE_SORT_ALPHA);
1600
1601   RNA_def_boolean(
1602       ot->srna,
1603       "use_sequence_detection",
1604       true,
1605       "Detect Sequences",
1606       "Automatically detect animated sequences in selected images (based on file names)");
1607 }
1608
1609 /** \} */
1610
1611 /* -------------------------------------------------------------------- */
1612 /** \name Match Movie Length Operator
1613  * \{ */
1614
1615 static int image_match_len_exec(bContext *C, wmOperator *UNUSED(op))
1616 {
1617   Scene *scene = CTX_data_scene(C);
1618   Image *ima = image_from_context(C);
1619   ImageUser *iuser = image_user_from_context(C);
1620
1621   if (!ima || !iuser) {
1622     /* Try to get a Texture, or a SpaceImage from context... */
1623     Tex *tex = CTX_data_pointer_get_type(C, "texture", &RNA_Texture).data;
1624     if (tex && tex->type == TEX_IMAGE) {
1625       ima = tex->ima;
1626       iuser = &tex->iuser;
1627     }
1628   }
1629
1630   if (!ima || !iuser || !BKE_image_has_anim(ima)) {
1631     return OPERATOR_CANCELLED;
1632   }
1633
1634   struct anim *anim = ((ImageAnim *)ima->anims.first)->anim;
1635   if (!anim) {
1636     return OPERATOR_CANCELLED;
1637   }
1638   iuser->frames = IMB_anim_get_duration(anim, IMB_TC_RECORD_RUN);
1639   BKE_image_user_frame_calc(ima, iuser, scene->r.cfra);
1640
1641   return OPERATOR_FINISHED;
1642 }
1643
1644 /* called by other space types too */
1645 void IMAGE_OT_match_movie_length(wmOperatorType *ot)
1646 {
1647   /* identifiers */
1648   ot->name = "Match Movie Length";
1649   ot->description = "Set image's user's length to the one of this video";
1650   ot->idname = "IMAGE_OT_match_movie_length";
1651
1652   /* api callbacks */
1653   ot->exec = image_match_len_exec;
1654
1655   /* flags */
1656   /* Don't think we need undo for that. */
1657   ot->flag = OPTYPE_REGISTER | OPTYPE_INTERNAL /* | OPTYPE_UNDO */;
1658 }
1659
1660 /** \} */
1661
1662 /* -------------------------------------------------------------------- */
1663 /** \name Replace Image Operator
1664  * \{ */
1665
1666 static int image_replace_exec(bContext *C, wmOperator *op)
1667 {
1668   Main *bmain = CTX_data_main(C);
1669   SpaceImage *sima = CTX_wm_space_image(C);
1670   char str[FILE_MAX];
1671
1672   if (!sima->image) {
1673     return OPERATOR_CANCELLED;
1674   }
1675
1676   RNA_string_get(op->ptr, "filepath", str);
1677
1678   /* we cant do much if the str is longer then FILE_MAX :/ */
1679   BLI_strncpy(sima->image->name, str, sizeof(sima->image->name));
1680
1681   if (sima->image->source == IMA_SRC_GENERATED) {
1682     sima->image->source = IMA_SRC_FILE;
1683     BKE_image_signal(bmain, sima->image, &sima->iuser, IMA_SIGNAL_SRC_CHANGE);
1684   }
1685
1686   if (BLI_path_extension_check_array(str, imb_ext_movie)) {
1687     sima->image->source = IMA_SRC_MOVIE;
1688   }
1689   else {
1690     sima->image->source = IMA_SRC_FILE;
1691   }
1692
1693   /* XXX BKE_packedfile_unpack_image frees image buffers */
1694   ED_preview_kill_jobs(CTX_wm_manager(C), CTX_data_main(C));
1695
1696   BKE_icon_changed(BKE_icon_id_ensure(&sima->image->id));
1697   BKE_image_signal(bmain, sima->image, &sima->iuser, IMA_SIGNAL_RELOAD);
1698   WM_event_add_notifier(C, NC_IMAGE | NA_EDITED, sima->image);
1699
1700   return OPERATOR_FINISHED;
1701 }
1702
1703 static int image_replace_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
1704 {
1705   SpaceImage *sima = CTX_wm_space_image(C);
1706
1707   if (!sima->image) {
1708     return OPERATOR_CANCELLED;
1709   }
1710
1711   if (RNA_struct_property_is_set(op->ptr, "filepath")) {
1712     return image_replace_exec(C, op);
1713   }
1714
1715   if (!RNA_struct_property_is_set(op->ptr, "relative_path")) {
1716     RNA_boolean_set(op->ptr, "relative_path", BLI_path_is_rel(sima->image->name));
1717   }
1718
1719   image_filesel(C, op, sima->image->name);
1720
1721   return OPERATOR_RUNNING_MODAL;
1722 }
1723
1724 void IMAGE_OT_replace(wmOperatorType *ot)
1725 {
1726   /* identifiers */
1727   ot->name = "Replace Image";
1728   ot->idname = "IMAGE_OT_replace";
1729   ot->description = "Replace current image by another one from disk";
1730
1731   /* api callbacks */
1732   ot->exec = image_replace_exec;
1733   ot->invoke = image_replace_invoke;
1734   ot->poll = image_not_packed_poll;
1735
1736   /* flags */
1737   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
1738
1739   /* properties */
1740   WM_operator_properties_filesel(ot,
1741                                  FILE_TYPE_FOLDER | FILE_TYPE_IMAGE | FILE_TYPE_MOVIE,
1742                                  FILE_SPECIAL,
1743                                  FILE_OPENFILE,
1744                                  WM_FILESEL_FILEPATH | WM_FILESEL_RELPATH,
1745                                  FILE_DEFAULTDISPLAY,
1746                                  FILE_SORT_ALPHA);
1747 }
1748
1749 /** \} */
1750
1751 /* -------------------------------------------------------------------- */
1752 /** \name Save Image As Operator
1753  * \{ */
1754
1755 static char imtype_best_depth(ImBuf *ibuf, const char imtype)
1756 {
1757   const char depth_ok = BKE_imtype_valid_depths(imtype);
1758
1759   if (ibuf->rect_float) {
1760     if (depth_ok & R_IMF_CHAN_DEPTH_32) {
1761       return R_IMF_CHAN_DEPTH_32;
1762     }
1763     if (depth_ok & R_IMF_CHAN_DEPTH_24) {
1764       return R_IMF_CHAN_DEPTH_24;
1765     }
1766     if (depth_ok & R_IMF_CHAN_DEPTH_16) {
1767       return R_IMF_CHAN_DEPTH_16;
1768     }
1769     if (depth_ok & R_IMF_CHAN_DEPTH_12) {
1770       return R_IMF_CHAN_DEPTH_12;
1771     }
1772     return R_IMF_CHAN_DEPTH_8;
1773   }
1774   else {
1775     if (depth_ok & R_IMF_CHAN_DEPTH_8) {
1776       return R_IMF_CHAN_DEPTH_8;
1777     }
1778     if (depth_ok & R_IMF_CHAN_DEPTH_12) {
1779       return R_IMF_CHAN_DEPTH_12;
1780     }
1781     if (depth_ok & R_IMF_CHAN_DEPTH_16) {
1782       return R_IMF_CHAN_DEPTH_16;
1783     }
1784     if (depth_ok & R_IMF_CHAN_DEPTH_24) {
1785       return R_IMF_CHAN_DEPTH_24;
1786     }
1787     if (depth_ok & R_IMF_CHAN_DEPTH_32) {
1788       return R_IMF_CHAN_DEPTH_32;
1789     }
1790     return R_IMF_CHAN_DEPTH_8; /* fallback, should not get here */
1791   }
1792 }
1793
1794 static int image_save_options_init(Main *bmain,
1795                                    ImageSaveOptions *opts,
1796                                    Image *ima,
1797                                    ImageUser *iuser,
1798                                    const bool guess_path,
1799                                    const bool save_as_render)
1800 {
1801   void *lock;
1802   ImBuf *ibuf = BKE_image_acquire_ibuf(ima, iuser, &lock);
1803
1804   if (ibuf) {
1805     Scene *scene = opts->scene;
1806     bool is_depth_set = false;
1807
1808     if (ELEM(ima->type, IMA_TYPE_R_RESULT, IMA_TYPE_COMPOSITE)) {
1809       /* imtype */
1810       opts->im_format = scene->r.im_format;
1811       is_depth_set = true;
1812       if (!BKE_image_is_multiview(ima)) {
1813         /* In case multiview is disabled,
1814          * render settings would be invalid for render result in this area. */
1815         opts->im_format.stereo3d_format = *ima->stereo3d_format;
1816         opts->im_format.views_format = ima->views_format;
1817       }
1818     }
1819     else {
1820       if (ima->source == IMA_SRC_GENERATED) {
1821         opts->im_format.imtype = R_IMF_IMTYPE_PNG;
1822         opts->im_format.compress = ibuf->foptions.quality;
1823         opts->im_format.planes = ibuf->planes;
1824       }
1825       else {
1826         BKE_imbuf_to_image_format(&opts->im_format, ibuf);
1827       }
1828
1829       /* use the multiview image settings as the default */
1830       opts->im_format.stereo3d_format = *ima->stereo3d_format;
1831       opts->im_format.views_format = ima->views_format;
1832     }
1833
1834     ///* XXX - this is lame, we need to make these available too! */
1835     // opts->subimtype = scene->r.subimtype;
1836
1837     BLI_strncpy(opts->filepath, ibuf->name, sizeof(opts->filepath));
1838
1839     /* sanitize all settings */
1840
1841     /* unlikely but just in case */
1842     if (ELEM(opts->im_format.planes, R_IMF_PLANES_BW, R_IMF_PLANES_RGB, R_IMF_PLANES_RGBA) == 0) {
1843       opts->im_format.planes = R_IMF_PLANES_RGBA;
1844     }
1845
1846     /* depth, account for float buffer and format support */
1847     if (is_depth_set == false) {
1848       opts->im_format.depth = imtype_best_depth(ibuf, opts->im_format.imtype);
1849     }
1850
1851     /* some formats don't use quality so fallback to scenes quality */
1852     if (opts->im_format.quality == 0) {
1853       opts->im_format.quality = scene->r.im_format.quality;
1854     }
1855
1856     /* check for empty path */
1857     if (guess_path && opts->filepath[0] == 0) {
1858       const bool is_prev_save = !STREQ(G.ima, "//");
1859       if (save_as_render) {
1860         if (is_prev_save) {
1861           BLI_strncpy(opts->filepath, G.ima, sizeof(opts->filepath));
1862         }
1863         else {
1864           BLI_strncpy(opts->filepath, "//untitled", sizeof(opts->filepath));
1865           BLI_path_abs(opts->filepath, BKE_main_blendfile_path(bmain));
1866         }
1867       }
1868       else {
1869         BLI_snprintf(opts->filepath, sizeof(opts->filepath), "//%s", ima->id.name + 2);
1870         BLI_path_make_safe(opts->filepath);
1871         BLI_path_abs(opts->filepath, is_prev_save ? G.ima : BKE_main_blendfile_path(bmain));
1872       }
1873     }
1874
1875     /* color management */
1876     BKE_color_managed_display_settings_copy(&opts->im_format.display_settings,
1877                                             &scene->display_settings);
1878     BKE_color_managed_view_settings_copy(&opts->im_format.view_settings, &scene->view_settings);
1879   }
1880
1881   BKE_image_release_ibuf(ima, ibuf, lock);
1882
1883   return (ibuf != NULL);
1884 }
1885
1886 static void image_save_options_from_op(Main *bmain, ImageSaveOptions *opts, wmOperator *op)
1887 {
1888   if (op->customdata) {
1889     BKE_color_managed_view_settings_free(&opts->im_format.view_settings);
1890
1891     opts->im_format = *(ImageFormatData *)op->customdata;
1892   }
1893
1894   if (RNA_struct_property_is_set(op->ptr, "filepath")) {
1895     RNA_string_get(op->ptr, "filepath", opts->filepath);
1896     BLI_path_abs(opts->filepath, BKE_main_blendfile_path(bmain));
1897   }
1898 }
1899
1900 static void image_save_options_to_op(ImageSaveOptions *opts, wmOperator *op)
1901 {
1902   if (op->customdata) {
1903     BKE_color_managed_view_settings_free(&((ImageFormatData *)op->customdata)->view_settings);
1904
1905     *(ImageFormatData *)op->customdata = opts->im_format;
1906   }
1907
1908   RNA_string_set(op->ptr, "filepath", opts->filepath);
1909 }
1910
1911 static bool save_image_op(const bContext *C, wmOperator *op, ImageSaveOptions *opts)
1912 {
1913   Main *bmain = CTX_data_main(C);
1914   Image *ima = image_from_context(C);
1915   ImageUser *iuser = image_user_from_context(C);
1916
1917   opts->relative = (RNA_struct_find_property(op->ptr, "relative_path") &&
1918                     RNA_boolean_get(op->ptr, "relative_path"));
1919   opts->save_copy = (RNA_struct_find_property(op->ptr, "copy") &&
1920                      RNA_boolean_get(op->ptr, "copy"));
1921   opts->save_as_render = (RNA_struct_find_property(op->ptr, "save_as_render") &&
1922                           RNA_boolean_get(op->ptr, "save_as_render"));
1923
1924   WM_cursor_wait(1);
1925
1926   bool ok = BKE_image_save(op->reports, bmain, ima, iuser, opts);
1927
1928   WM_cursor_wait(0);
1929
1930   /* Remember file path for next save. */
1931   BLI_strncpy(G.ima, opts->filepath, sizeof(G.ima));
1932
1933   WM_event_add_notifier(C, NC_IMAGE | NA_EDITED, ima);
1934
1935   return ok;
1936 }
1937
1938 static void image_save_as_free(wmOperator *op)
1939 {
1940   if (op->customdata) {
1941     ImageFormatData *im_format = (ImageFormatData *)op->customdata;
1942     BKE_color_managed_view_settings_free(&im_format->view_settings);
1943
1944     MEM_freeN(op->customdata);
1945     op->customdata = NULL;
1946   }
1947 }
1948
1949 static int image_save_as_exec(bContext *C, wmOperator *op)
1950 {
1951   Main *bmain = CTX_data_main(C);
1952   Scene *scene = CTX_data_scene(C);
1953   Image *image = image_from_context(C);
1954   ImageUser *iuser = image_user_from_context(C);
1955   ImageSaveOptions opts;
1956
1957   BKE_image_save_options_init(&opts, bmain, scene);
1958
1959   /* just in case to initialize values,
1960    * these should be set on invoke or by the caller. */
1961   image_save_options_init(bmain, &opts, image, iuser, false, false);
1962
1963   image_save_options_from_op(bmain, &opts, op);
1964   opts.do_newpath = true;
1965
1966   save_image_op(C, op, &opts);
1967
1968   if (opts.save_copy == false) {
1969     BKE_image_free_packedfiles(image);
1970   }
1971
1972   image_save_as_free(op);
1973
1974   return OPERATOR_FINISHED;
1975 }
1976
1977 static bool image_save_as_check(bContext *UNUSED(C), wmOperator *op)
1978 {
1979   ImageFormatData *imf = op->customdata;
1980   return WM_operator_filesel_ensure_ext_imtype(op, imf);
1981 }
1982
1983 static int image_save_as_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
1984 {
1985   Main *bmain = CTX_data_main(C);
1986   Image *ima = image_from_context(C);
1987   ImageUser *iuser = image_user_from_context(C);
1988   Scene *scene = CTX_data_scene(C);
1989   ImageSaveOptions opts;
1990   PropertyRNA *prop;
1991   const bool save_as_render = (ima->source == IMA_SRC_VIEWER);
1992
1993   if (RNA_struct_property_is_set(op->ptr, "filepath")) {
1994     return image_save_as_exec(C, op);
1995   }
1996
1997   BKE_image_save_options_init(&opts, bmain, scene);
1998
1999   if (image_save_options_init(bmain, &opts, ima, iuser, true, save_as_render) == 0) {
2000     return OPERATOR_CANCELLED;
2001   }
2002   image_save_options_to_op(&opts, op);
2003
2004   /* enable save_copy by default for render results */
2005   if (ELEM(ima->type, IMA_TYPE_R_RESULT, IMA_TYPE_COMPOSITE) &&
2006       !RNA_struct_property_is_set(op->ptr, "copy")) {
2007     RNA_boolean_set(op->ptr, "copy", true);
2008   }
2009
2010   RNA_boolean_set(op->ptr, "save_as_render", save_as_render);
2011
2012   op->customdata = MEM_mallocN(sizeof(opts.im_format), __func__);
2013   memcpy(op->customdata, &opts.im_format, sizeof(opts.im_format));
2014
2015   /* show multiview save options only if image has multiviews */
2016   prop = RNA_struct_find_property(op->ptr, "show_multiview");
2017   RNA_property_boolean_set(op->ptr, prop, BKE_image_is_multiview(ima));
2018   prop = RNA_struct_find_property(op->ptr, "use_multiview");
2019   RNA_property_boolean_set(op->ptr, prop, BKE_image_is_multiview(ima));
2020
2021   image_filesel(C, op, opts.filepath);
2022
2023   return OPERATOR_RUNNING_MODAL;
2024 }
2025
2026 static void image_save_as_cancel(bContext *UNUSED(C), wmOperator *op)
2027 {
2028   image_save_as_free(op);
2029 }
2030
2031 static bool image_save_as_draw_check_prop(PointerRNA *ptr,
2032                                           PropertyRNA *prop,
2033                                           void *UNUSED(user_data))
2034 {
2035   const char *prop_id = RNA_property_identifier(prop);
2036
2037   return !(STREQ(prop_id, "filepath") || STREQ(prop_id, "directory") ||
2038            STREQ(prop_id, "filename") ||
2039            /* when saving a copy, relative path has no effect */
2040            ((STREQ(prop_id, "relative_path")) && RNA_boolean_get(ptr, "copy")));
2041 }
2042
2043 static void image_save_as_draw(bContext *UNUSED(C), wmOperator *op)
2044 {
2045   uiLayout *layout = op->layout;
2046   ImageFormatData *imf = op->customdata;
2047   PointerRNA imf_ptr, ptr;
2048   const bool is_multiview = RNA_boolean_get(op->ptr, "show_multiview");
2049
2050   /* image template */
2051   RNA_pointer_create(NULL, &RNA_ImageFormatSettings, imf, &imf_ptr);
2052   uiTemplateImageSettings(layout, &imf_ptr, false);
2053
2054   /* main draw call */
2055   RNA_pointer_create(NULL, op->type->srna, op->properties, &ptr);
2056   uiDefAutoButsRNA(
2057       layout, &ptr, image_save_as_draw_check_prop, NULL, NULL, UI_BUT_LABEL_ALIGN_NONE, false);
2058
2059   /* multiview template */
2060   if (is_multiview) {
2061     uiTemplateImageFormatViews(layout, &imf_ptr, op->ptr);
2062   }
2063 }
2064
2065 static bool image_save_as_poll(bContext *C)
2066 {
2067   if (!image_from_context_has_data_poll(C)) {
2068     return false;
2069   }
2070
2071   if (G.is_rendering) {
2072     /* no need to NULL check here */
2073     Image *ima = image_from_context(C);
2074
2075     if (ima->source == IMA_SRC_VIEWER) {
2076       CTX_wm_operator_poll_msg_set(C, "can't save image while rendering");
2077       return false;
2078     }
2079   }
2080
2081   return true;
2082 }
2083
2084 void IMAGE_OT_save_as(wmOperatorType *ot)
2085 {
2086   /* identifiers */
2087   ot->name = "Save As Image";
2088   ot->idname = "IMAGE_OT_save_as";
2089   ot->description = "Save the image with another name and/or settings";
2090
2091   /* api callbacks */
2092   ot->exec = image_save_as_exec;
2093   ot->check = image_save_as_check;
2094   ot->invoke = image_save_as_invoke;
2095   ot->cancel = image_save_as_cancel;
2096   ot->ui = image_save_as_draw;
2097   ot->poll = image_save_as_poll;
2098
2099   /* flags */
2100   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
2101
2102   /* properties */
2103   RNA_def_boolean(ot->srna,
2104                   "save_as_render",
2105                   0,
2106                   "Save As Render",
2107                   "Apply render part of display transform when saving byte image");
2108   RNA_def_boolean(ot->srna,
2109                   "copy",
2110                   0,
2111                   "Copy",
2112                   "Create a new image file without modifying the current image in blender");
2113
2114   WM_operator_properties_filesel(ot,
2115                                  FILE_TYPE_FOLDER | FILE_TYPE_IMAGE | FILE_TYPE_MOVIE,
2116                                  FILE_SPECIAL,
2117                                  FILE_SAVE,
2118                                  WM_FILESEL_FILEPATH | WM_FILESEL_RELPATH | WM_FILESEL_SHOW_PROPS,
2119                                  FILE_DEFAULTDISPLAY,
2120                                  FILE_SORT_ALPHA);
2121 }
2122
2123 /** \} */
2124
2125 /* -------------------------------------------------------------------- */
2126 /** \name Save Image Operator
2127  * \{ */
2128
2129 static bool image_file_path_saveable(bContext *C, Image *ima, ImageUser *iuser)
2130 {
2131   /* Can always repack images. */
2132   if (BKE_image_has_packedfile(ima)) {
2133     return true;
2134   }
2135
2136   /* Test for valid filepath. */
2137   void *lock;
2138   ImBuf *ibuf = BKE_image_acquire_ibuf(ima, iuser, &lock);
2139   bool ret = false;
2140
2141   if (ibuf) {
2142     Main *bmain = CTX_data_main(C);
2143     char name[FILE_MAX];
2144     BLI_strncpy(name, ibuf->name, FILE_MAX);
2145     BLI_path_abs(name, BKE_main_blendfile_path(bmain));
2146
2147     if (BLI_exists(name) == false) {
2148       CTX_wm_operator_poll_msg_set(C, "image file not found");
2149     }
2150     else if (!BLI_file_is_writable(name)) {
2151       CTX_wm_operator_poll_msg_set(C, "image path can't be written to");
2152     }
2153     else if (!BKE_image_buffer_format_writable(ibuf)) {
2154       CTX_wm_operator_poll_msg_set(C, "image format is read-only");
2155     }
2156     else {
2157       ret = true;
2158     }
2159   }
2160
2161   BKE_image_release_ibuf(ima, ibuf, lock);
2162   return ret;
2163 }
2164
2165 static bool image_save_poll(bContext *C)
2166 {
2167   /* Can't save if there are no pixels. */
2168   if (image_from_context_has_data_poll(C) == false) {
2169     return false;
2170   }
2171
2172   Image *ima = image_from_context(C);
2173   ImageUser *iuser = image_user_from_context(C);
2174
2175   /* Images without a filepath will go to save as. */
2176   if (!BKE_image_has_filepath(ima)) {
2177     return true;
2178   }
2179
2180   /* Check if there is a valid file path and image format we can write. */
2181   return image_file_path_saveable(C, ima, iuser);
2182 }
2183
2184 static int image_save_exec(bContext *C, wmOperator *op)
2185 {
2186   Main *bmain = CTX_data_main(C);
2187   Image *image = image_from_context(C);
2188   ImageUser *iuser = image_user_from_context(C);
2189   Scene *scene = CTX_data_scene(C);
2190   ImageSaveOptions opts;
2191
2192   if (BKE_image_has_packedfile(image)) {
2193     /* Save packed files to memory. */
2194     BKE_image_memorypack(image);
2195     return OPERATOR_FINISHED;
2196   }
2197
2198   BKE_image_save_options_init(&opts, bmain, scene);
2199   if (image_save_options_init(bmain, &opts, image, iuser, false, false) == 0) {
2200     return OPERATOR_CANCELLED;
2201   }
2202   image_save_options_from_op(bmain, &opts, op);
2203
2204   if (BLI_exists(opts.filepath) && BLI_file_is_writable(opts.filepath)) {
2205     if (save_image_op(C, op, &opts)) {
2206       /* report since this can be called from key-shortcuts */
2207       BKE_reportf(op->reports, RPT_INFO, "Saved Image '%s'", opts.filepath);
2208     }
2209   }
2210   else {
2211     BKE_reportf(
2212         op->reports, RPT_ERROR, "Cannot save image, path '%s' is not writable", opts.filepath);
2213     return OPERATOR_CANCELLED;
2214   }
2215
2216   return OPERATOR_FINISHED;
2217 }
2218
2219 static int image_save_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
2220 {
2221   Image *ima = image_from_context(C);
2222
2223   if (!BKE_image_has_packedfile(ima) && !BKE_image_has_filepath(ima)) {
2224     WM_operator_name_call(C, "IMAGE_OT_save_as", WM_OP_INVOKE_DEFAULT, NULL);
2225     return OPERATOR_CANCELLED;
2226   }
2227   else {
2228     return image_save_exec(C, op);
2229   }
2230 }
2231
2232 void IMAGE_OT_save(wmOperatorType *ot)
2233 {
2234   /* identifiers */
2235   ot->name = "Save Image";
2236   ot->idname = "IMAGE_OT_save";
2237   ot->description = "Save the image with current name and settings";
2238
2239   /* api callbacks */
2240   ot->exec = image_save_exec;
2241   ot->invoke = image_save_invoke;
2242   ot->poll = image_save_poll;
2243
2244   /* flags */
2245   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
2246 }
2247
2248 /** \} */
2249
2250 /* -------------------------------------------------------------------- */
2251 /** \name Save Sequence Operator
2252  * \{ */
2253
2254 static int image_save_sequence_exec(bContext *C, wmOperator *op)
2255 {
2256   Main *bmain = CTX_data_main(C);
2257   Image *image = image_from_context(C);
2258   ImBuf *ibuf, *first_ibuf = NULL;
2259   int tot = 0;
2260   char di[FILE_MAX];
2261   struct MovieCacheIter *iter;
2262
2263   if (image == NULL) {
2264     return OPERATOR_CANCELLED;
2265   }
2266
2267   if (image->source != IMA_SRC_SEQUENCE) {
2268     BKE_report(op->reports, RPT_ERROR, "Can only save sequence on image sequences");
2269     return OPERATOR_CANCELLED;
2270   }
2271
2272   if (image->type == IMA_TYPE_MULTILAYER) {
2273     BKE_report(op->reports, RPT_ERROR, "Cannot save multilayer sequences");
2274     return OPERATOR_CANCELLED;
2275   }
2276
2277   /* get total dirty buffers and first dirty buffer which is used for menu */
2278   ibuf = NULL;
2279   if (image->cache != NULL) {
2280     iter = IMB_moviecacheIter_new(image->cache);
2281     while (!IMB_moviecacheIter_done(iter)) {
2282       ibuf = IMB_moviecacheIter_getImBuf(iter);
2283       if (ibuf->userflags & IB_BITMAPDIRTY) {
2284         if (first_ibuf == NULL) {
2285           first_ibuf = ibuf;
2286         }
2287         tot++;
2288       }
2289       IMB_moviecacheIter_step(iter);
2290     }
2291     IMB_moviecacheIter_free(iter);
2292   }
2293
2294   if (tot == 0) {
2295     BKE_report(op->reports, RPT_WARNING, "No images have been changed");
2296     return OPERATOR_CANCELLED;
2297   }
2298
2299   /* get a filename for menu */
2300   BLI_split_dir_part(first_ibuf->name, di, sizeof(di));
2301   BKE_reportf(op->reports, RPT_INFO, "%d image(s) will be saved in %s", tot, di);
2302
2303   iter = IMB_moviecacheIter_new(image->cache);
2304   while (!IMB_moviecacheIter_done(iter)) {
2305     ibuf = IMB_moviecacheIter_getImBuf(iter);
2306
2307     if (ibuf->userflags & IB_BITMAPDIRTY) {
2308       char name[FILE_MAX];
2309       BLI_strncpy(name, ibuf->name, sizeof(name));
2310
2311       BLI_path_abs(name, BKE_main_blendfile_path(bmain));
2312
2313       if (0 == IMB_saveiff(ibuf, name, IB_rect | IB_zbuf | IB_zbuffloat)) {
2314         BKE_reportf(op->reports, RPT_ERROR, "Could not write image: %s", strerror(errno));
2315         break;
2316       }
2317
2318       BKE_reportf(op->reports, RPT_INFO, "Saved %s", ibuf->name);
2319       ibuf->userflags &= ~IB_BITMAPDIRTY;
2320     }
2321
2322     IMB_moviecacheIter_step(iter);
2323   }
2324   IMB_moviecacheIter_free(iter);
2325
2326   return OPERATOR_FINISHED;
2327 }
2328
2329 void IMAGE_OT_save_sequence(wmOperatorType *ot)
2330 {
2331   /* identifiers */
2332   ot->name = "Save Sequence";
2333   ot->idname = "IMAGE_OT_save_sequence";
2334   ot->description = "Save a sequence of images";
2335
2336   /* api callbacks */
2337   ot->exec = image_save_sequence_exec;
2338   ot->poll = image_from_context_has_data_poll;
2339
2340   /* flags */
2341   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
2342 }
2343
2344 /** \} */
2345
2346 /* -------------------------------------------------------------------- */
2347 /** \name Save All Operator
2348  * \{ */
2349
2350 static bool image_should_be_saved_when_modified(Image *ima)
2351 {
2352   return !ELEM(ima->type, IMA_TYPE_R_RESULT, IMA_TYPE_COMPOSITE);
2353 }
2354
2355 static bool image_should_be_saved(Image *ima, bool *is_format_writable)
2356 {
2357   if (BKE_image_is_dirty_writable(ima, is_format_writable) &&
2358       (ima->source == IMA_SRC_FILE || ima->source == IMA_SRC_GENERATED)) {
2359     return image_should_be_saved_when_modified(ima);
2360   }
2361   else {
2362     return false;
2363   }
2364 }
2365
2366 static bool image_has_valid_path(Image *ima)
2367 {
2368   return strchr(ima->name, '\\') || strchr(ima->name, '/');
2369 }
2370
2371 bool ED_image_should_save_modified(const bContext *C)
2372 {
2373   ReportList reports;
2374   BKE_reports_init(&reports, RPT_STORE);
2375
2376   uint modified_images_count = ED_image_save_all_modified_info(C, &reports);
2377   bool should_save = modified_images_count || !BLI_listbase_is_empty(&reports.list);
2378
2379   BKE_reports_clear(&reports);
2380
2381   return should_save;
2382 }
2383
2384 int ED_image_save_all_modified_info(const bContext *C, ReportList *reports)
2385 {
2386   Main *bmain = CTX_data_main(C);
2387   GSet *unique_paths = BLI_gset_str_new(__func__);
2388
2389   int num_saveable_images = 0;
2390
2391   for (Image *ima = bmain->images.first; ima; ima = ima->id.next) {
2392     bool is_format_writable;
2393
2394     if (image_should_be_saved(ima, &is_format_writable)) {
2395       if (BKE_image_has_packedfile(ima) || (ima->source == IMA_SRC_GENERATED)) {
2396         if (ima->id.lib == NULL) {
2397           num_saveable_images++;
2398         }
2399         else {
2400           BKE_reportf(reports,
2401                       RPT_WARNING,
2402                       "Packed library image: %s from library %s can't be saved",
2403                       ima->id.name + 2,
2404                       ima->id.lib->name);
2405         }
2406       }
2407       else if (!is_format_writable) {
2408         BKE_reportf(reports,
2409                     RPT_WARNING,
2410                     "Image %s can't be saved automatically, must use a different file format",
2411                     ima->id.name + 2);
2412       }
2413       else {
2414         if (image_has_valid_path(ima)) {
2415           num_saveable_images++;
2416           if (BLI_gset_haskey(unique_paths, ima->name)) {
2417             BKE_reportf(reports,
2418                         RPT_WARNING,
2419                         "File path used by more than one saved image: %s",
2420                         ima->name);
2421           }
2422           else {
2423             BLI_gset_insert(unique_paths, BLI_strdup(ima->name));
2424           }
2425         }
2426         else {
2427           BKE_reportf(reports,
2428                       RPT_WARNING,
2429                       "Image %s can't be saved, no valid file path: %s",
2430                       ima->id.name + 2,
2431                       ima->name);
2432         }
2433       }
2434     }
2435   }
2436
2437   BLI_gset_free(unique_paths, MEM_freeN);
2438   return num_saveable_images;
2439 }
2440
2441 bool ED_image_save_all_modified(const bContext *C, ReportList *reports)
2442 {
2443   ED_image_save_all_modified_info(C, reports);
2444
2445   Main *bmain = CTX_data_main(C);
2446   bool ok = true;
2447
2448   for (Image *ima = bmain->images.first; ima; ima = ima->id.next) {
2449     bool is_format_writable;
2450
2451     if (image_should_be_saved(ima, &is_format_writable)) {
2452       if (BKE_image_has_packedfile(ima) || (ima->source == IMA_SRC_GENERATED)) {
2453         BKE_image_memorypack(ima);
2454       }
2455       else if (is_format_writable) {
2456         if (image_has_valid_path(ima)) {
2457           ImageSaveOptions opts;
2458           Scene *scene = CTX_data_scene(C);
2459           BKE_image_save_options_init(&opts, bmain, scene);
2460           if (image_save_options_init(bmain, &opts, ima, NULL, false, false)) {
2461             bool saved_successfully = BKE_image_save(reports, bmain, ima, NULL, &opts);
2462             ok = ok && saved_successfully;
2463           }
2464         }
2465       }
2466     }
2467   }
2468   return ok;
2469 }
2470
2471 static bool image_save_all_modified_poll(bContext *C)
2472 {
2473   int num_files = ED_image_save_all_modified_info(C, NULL);
2474   return num_files > 0;
2475 }
2476
2477 static int image_save_all_modified_exec(bContext *C, wmOperator *op)
2478 {
2479   ED_image_save_all_modified(C, op->reports);
2480   return OPERATOR_FINISHED;
2481 }
2482
2483 void IMAGE_OT_save_all_modified(wmOperatorType *ot)
2484 {
2485   /* identifiers */
2486   ot->name = "Save All Modified";
2487   ot->idname = "IMAGE_OT_save_all_modified";
2488   ot->description = "Save all modified images";
2489
2490   /* api callbacks */
2491   ot->exec = image_save_all_modified_exec;
2492   ot->poll = image_save_all_modified_poll;
2493
2494   /* flags */
2495   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
2496 }
2497
2498 /** \} */
2499
2500 /* -------------------------------------------------------------------- */
2501 /** \name Reload Image Operator
2502  * \{ */
2503
2504 static int image_reload_exec(bContext *C, wmOperator *UNUSED(op))
2505 {
2506   Main *bmain = CTX_data_main(C);
2507   Image *ima = image_from_context(C);
2508   ImageUser *iuser = image_user_from_context(C);
2509
2510   if (!ima) {
2511     return OPERATOR_CANCELLED;
2512   }
2513
2514   /* XXX BKE_packedfile_unpack_image frees image buffers */
2515   ED_preview_kill_jobs(CTX_wm_manager(C), CTX_data_main(C));
2516
2517   BKE_image_signal(bmain, ima, iuser, IMA_SIGNAL_RELOAD);
2518   DEG_id_tag_update(&ima->id, 0);
2519
2520   WM_event_add_notifier(C, NC_IMAGE | NA_EDITED, ima);
2521
2522   return OPERATOR_FINISHED;
2523 }
2524
2525 void IMAGE_OT_reload(wmOperatorType *ot)
2526 {
2527   /* identifiers */
2528   ot->name = "Reload Image";
2529   ot->idname = "IMAGE_OT_reload";
2530   ot->description = "Reload current image from disk";
2531
2532   /* api callbacks */
2533   ot->exec = image_reload_exec;
2534
2535   /* flags */
2536   ot->flag = OPTYPE_REGISTER; /* no undo, image buffer is not handled by undo */
2537 }
2538
2539 /** \} */
2540
2541 /* -------------------------------------------------------------------- */
2542 /** \name New Image Operator
2543  * \{ */
2544
2545 #define IMA_DEF_NAME N_("Untitled")
2546
2547 enum {
2548   GEN_CONTEXT_NONE = 0,
2549   GEN_CONTEXT_PAINT_CANVAS = 1,
2550   GEN_CONTEXT_PAINT_STENCIL = 2,
2551 };
2552
2553 typedef struct ImageNewData {
2554   PropertyPointerRNA pprop;
2555 } ImageNewData;
2556
2557 static ImageNewData *image_new_init(bContext *C, wmOperator *op)
2558 {
2559   if (op->customdata) {
2560     return op->customdata;
2561   }
2562
2563   ImageNewData *data = MEM_callocN(sizeof(ImageNewData), __func__);
2564   UI_context_active_but_prop_get_templateID(C, &data->pprop.ptr, &data->pprop.prop);
2565   op->customdata = data;
2566   return data;
2567 }
2568
2569 static void image_new_free(wmOperator *op)
2570 {
2571   if (op->customdata) {
2572     MEM_freeN(op->customdata);
2573     op->customdata = NULL;
2574   }
2575 }
2576
2577 static int image_new_exec(bContext *C, wmOperator *op)
2578 {
2579   SpaceImage *sima;
2580   Object *obedit;
2581   Image *ima;
2582   Main *bmain;
2583   PropertyRNA *prop;
2584   char name_buffer[MAX_ID_NAME - 2];
2585   const char *name;
2586   float color[4];
2587   int width, height, floatbuf, gen_type, alpha;
2588   int stereo3d;
2589
2590   /* retrieve state */
2591   sima = CTX_wm_space_image(C);
2592   obedit = CTX_data_edit_object(C);
2593   bmain = CTX_data_main(C);
2594
2595   prop = RNA_struct_find_property(op->ptr, "name");
2596   RNA_property_string_get(op->ptr, prop, name_buffer);
2597   if (!RNA_property_is_set(op->ptr, prop)) {
2598     /* Default value, we can translate! */
2599     name = DATA_(name_buffer);
2600   }
2601   else {
2602     name = name_buffer;
2603   }
2604   width = RNA_int_get(op->ptr, "width");
2605   height = RNA_int_get(op->ptr, "height");
2606   floatbuf = RNA_boolean_get(op->ptr, "float");
2607   gen_type = RNA_enum_get(op->ptr, "generated_type");
2608   RNA_float_get_array(op->ptr, "color", color);
2609   alpha = RNA_boolean_get(op->ptr, "alpha");
2610   stereo3d = RNA_boolean_get(op->ptr, "use_stereo_3d");
2611
2612   if (!alpha) {
2613     color[3] = 1.0f;
2614   }
2615
2616   ima = BKE_image_add_generated(
2617       bmain, width, height, name, alpha ? 32 : 24, floatbuf, gen_type, color, stereo3d, false);
2618
2619   if (!ima) {
2620     image_new_free(op);
2621     return OPERATOR_CANCELLED;
2622   }
2623
2624   /* hook into UI */
2625   ImageNewData *data = image_new_init(C, op);
2626
2627   if (data->pprop.prop) {
2628     /* when creating new ID blocks, use is already 1, but RNA
2629      * pointer use also increases user, so this compensates it */
2630     id_us_min(&ima->id);
2631
2632     PointerRNA imaptr;
2633     RNA_id_pointer_create(&ima->id, &imaptr);
2634     RNA_property_pointer_set(&data->pprop.ptr, data->pprop.prop, imaptr, NULL);
2635     RNA_property_update(C, &data->pprop.ptr, data->pprop.prop);
2636   }
2637   else if (sima) {
2638     ED_space_image_set(bmain, sima, obedit, ima, false);
2639   }
2640
2641   BKE_image_signal(bmain, ima, (sima) ? &sima->iuser : NULL, IMA_SIGNAL_USER_NEW_IMAGE);
2642
2643   WM_event_add_notifier(C, NC_IMAGE | NA_ADDED, ima);
2644
2645   image_new_free(op);
2646
2647   return OPERATOR_FINISHED;
2648 }
2649
2650 static int image_new_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
2651 {
2652   /* Get property in advance, it doesn't work after WM_operator_props_dialog_popup. */
2653   ImageNewData *data;
2654   op->customdata = data = MEM_callocN(sizeof(ImageNewData), __func__);
2655   UI_context_active_but_prop_get_templateID(C, &data->pprop.ptr, &data->pprop.prop);
2656
2657   /* Better for user feedback. */
2658   RNA_string_set(op->ptr, "name", DATA_(IMA_DEF_NAME));
2659   return WM_operator_props_dialog_popup(C, op, 300, 100);
2660 }
2661
2662 static void image_new_draw(bContext *UNUSED(C), wmOperator *op)
2663 {
2664   uiLayout *split, *col[2];
2665   uiLayout *layout = op->layout;
2666   PointerRNA ptr;
2667 #if 0
2668   Scene *scene = CTX_data_scene(C);
2669   const bool is_multiview = (scene->r.scemode & R_MULTIVIEW) != 0;
2670 #endif
2671
2672   RNA_pointer_create(NULL, op->type->srna, op->properties, &ptr);
2673
2674   /* copy of WM_operator_props_dialog_popup() layout */
2675
2676   split = uiLayoutSplit(layout, 0.5f, false);
2677   col[0] = uiLayoutColumn(split, false);
2678   col[1] = uiLayoutColumn(split, false);
2679
2680   uiItemL(col[0], IFACE_("Name"), ICON_NONE);
2681   uiItemR(col[1], &ptr, "name", 0, "", ICON_NONE);
2682
2683   uiItemL(col[0], IFACE_("Width"), ICON_NONE);
2684   uiItemR(col[1], &ptr, "width", 0, "", ICON_NONE);
2685
2686   uiItemL(col[0], IFACE_("Height"), ICON_NONE);
2687   uiItemR(col[1], &ptr, "height", 0, "", ICON_NONE);
2688
2689   uiItemL(col[0], IFACE_("Color"), ICON_NONE);
2690   uiItemR(col[1], &ptr, "color", 0, "", ICON_NONE);
2691
2692   uiItemL(col[0], "", ICON_NONE);
2693   uiItemR(col[1], &ptr, "alpha", 0, NULL, ICON_NONE);
2694
2695   uiItemL(col[0], IFACE_("Generated Type"), ICON_NONE);
2696   uiItemR(col[1], &ptr, "generated_type", 0, "", ICON_NONE);
2697
2698   uiItemL(col[0], "", ICON_NONE);
2699   uiItemR(col[1], &ptr, "float", 0, NULL, ICON_NONE);
2700
2701 #if 0
2702   if (is_multiview) {
2703     uiItemL(col[0], "", ICON_NONE);
2704     uiItemR(col[1], &ptr, "use_stereo_3d", 0, NULL, ICON_NONE);
2705   }
2706 #endif
2707 }
2708
2709 static void image_new_cancel(bContext *UNUSED(C), wmOperator *op)
2710 {
2711   image_new_free(op);
2712 }
2713
2714 void IMAGE_OT_new(wmOperatorType *ot)
2715 {
2716   PropertyRNA *prop;
2717   static float default_color[4] = {0.0f, 0.0f, 0.0f, 1.0f};
2718
2719   /* identifiers */
2720   ot->name = "New Image";
2721   ot->description = "Create a new image";
2722   ot->idname = "IMAGE_OT_new";
2723
2724   /* api callbacks */
2725   ot->exec = image_new_exec;
2726   ot->invoke = image_new_invoke;
2727   ot->ui = image_new_draw;
2728   ot->cancel = image_new_cancel;
2729
2730   /* flags */
2731   ot->flag = OPTYPE_UNDO;
2732
2733   /* properties */
2734   RNA_def_string(ot->srna, "name", IMA_DEF_NAME, MAX_ID_NAME - 2, "Name", "Image data-block name");
2735   prop = RNA_def_int(ot->srna, "width", 1024, 1, INT_MAX, "Width", "Image width", 1, 16384);
2736   RNA_def_property_subtype(prop, PROP_PIXEL);
2737   prop = RNA_def_int(ot->srna, "height", 1024, 1, INT_MAX, "Height", "Image height", 1, 16384);
2738   RNA_def_property_subtype(prop, PROP_PIXEL);
2739   prop = RNA_def_float_color(
2740       ot->srna, "color", 4, NULL, 0.0f, FLT_MAX, "Color", "Default fill color", 0.0f, 1.0f);
2741   RNA_def_property_subtype(prop, PROP_COLOR_GAMMA);
2742   RNA_def_property_float_array_default(prop, default_color);
2743   RNA_def_boolean(ot->srna, "alpha", 1, "Alpha", "Create an image with an alpha channel");
2744   RNA_def_enum(ot->srna,
2745                "generated_type",
2746                rna_enum_image_generated_type_items,
2747                IMA_GENTYPE_BLANK,
2748                "Generated Type",
2749                "Fill the image with a grid for UV map testing");
2750   RNA_def_boolean(
2751       ot->srna, "float", 0, "32 bit Float", "Create image with 32 bit floating point bit depth");
2752   RNA_def_property_flag(prop, PROP_HIDDEN);
2753   prop = RNA_def_boolean(
2754       ot->srna, "use_stereo_3d", 0, "Stereo 3D", "Create an image with left and right views");
2755   RNA_def_property_flag(prop, PROP_SKIP_SAVE | PROP_HIDDEN);
2756 }
2757
2758 #undef IMA_DEF_NAME
2759
2760 /** \} */
2761
2762 /* -------------------------------------------------------------------- */
2763 /** \name Invert Operators
2764  * \{ */
2765
2766 static int image_invert_exec(bContext *C, wmOperator *op)
2767 {
2768   Image *ima = image_from_context(C);
2769   ImBuf *ibuf = BKE_image_acquire_ibuf(ima, NULL, NULL);
2770   SpaceImage *sima = CTX_wm_space_image(C);
2771   const bool is_paint = ((sima != NULL) && (sima->mode == SI_MODE_PAINT));
2772
2773   /* flags indicate if this channel should be inverted */
2774   const bool r = RNA_boolean_get(op->ptr, "invert_r");
2775   const bool g = RNA_boolean_get(op->ptr, "invert_g");
2776   const bool b = RNA_boolean_get(op->ptr, "invert_b");
2777   const bool a = RNA_boolean_get(op->ptr, "invert_a");
2778
2779   size_t i;
2780
2781   if (ibuf == NULL) {
2782     /* TODO: this should actually never happen, but does for render-results -> cleanup */
2783     return OPERATOR_CANCELLED;
2784   }
2785
2786   ED_image_undo_push_begin_with_image(op->type->name, ima, ibuf);
2787
2788   if (is_paint) {
2789     ED_imapaint_clear_partial_redraw();
2790   }
2791
2792   /* TODO: make this into an IMB_invert_channels(ibuf,r,g,b,a) method!? */
2793   if (ibuf->rect_float) {
2794
2795     float *fp = (float *)ibuf->rect_float;
2796     for (i = ((size_t)ibuf->x) * ibuf->y; i > 0; i--, fp += 4) {
2797       if (r) {
2798         fp[0] = 1.0f - fp[0];
2799       }
2800       if (g) {
2801         fp[1] = 1.0f - fp[1];
2802       }
2803       if (b) {
2804         fp[2] = 1.0f - fp[2];
2805       }
2806       if (a) {
2807         fp[3] = 1.0f - fp[3];
2808       }
2809     }
2810
2811     if (ibuf->rect) {
2812       IMB_rect_from_float(ibuf);
2813     }
2814   }
2815   else if (ibuf->rect) {
2816
2817     char *cp = (char *)ibuf->rect;
2818     for (i = ((size_t)ibuf->x) * ibuf->y; i > 0; i--, cp += 4) {
2819       if (r) {
2820         cp[0] = 255 - cp[0];
2821       }
2822       if (g) {
2823         cp[1] = 255 - cp[1];
2824       }
2825       if (b) {
2826         cp[2] = 255 - cp[2];
2827       }
2828       if (a) {
2829         cp[3] = 255 - cp[3];
2830       }
2831     }
2832   }
2833   else {
2834     BKE_image_release_ibuf(ima, ibuf, NULL);
2835     return OPERATOR_CANCELLED;
2836   }
2837
2838   ibuf->userflags |= IB_DISPLAY_BUFFER_INVALID;
2839   BKE_image_mark_dirty(ima, ibuf);
2840
2841   if (ibuf->mipmap[0]) {
2842     ibuf->userflags |= IB_MIPMAP_INVALID;
2843   }
2844
2845   ED_image_undo_push_end();
2846
2847   /* force GPU reupload, all image is invalid */
2848   GPU_free_image(ima);
2849
2850   WM_event_add_notifier(C, NC_IMAGE | NA_EDITED, ima);
2851
2852   BKE_image_release_ibuf(ima, ibuf, NULL);
2853
2854   return OPERATOR_FINISHED;
2855 }
2856
2857 void IMAGE_OT_invert(wmOperatorType *ot)
2858 {
2859   PropertyRNA *prop;
2860
2861   /* identifiers */
2862   ot->name = "Invert Channels";
2863   ot->idname = "IMAGE_OT_invert";
2864   ot->description = "Invert image's channels";
2865
2866   /* api callbacks */
2867   ot->exec = image_invert_exec;
2868   ot->poll = image_from_contect_has_data_poll_no_image_user;
2869
2870   /* properties */
2871   prop = RNA_def_boolean(ot->srna, "invert_r", 0, "Red", "Invert Red Channel");
2872   RNA_def_property_flag(prop, PROP_SKIP_SAVE);
2873   prop = RNA_def_boolean(ot->srna, "invert_g", 0, "Green", "Invert Green Channel");
2874   RNA_def_property_flag(prop, PROP_SKIP_SAVE);
2875   prop = RNA_def_boolean(ot->srna, "invert_b", 0, "Blue", "Invert Blue Channel");
2876   RNA_def_property_flag(prop, PROP_SKIP_SAVE);
2877   prop = RNA_def_boolean(ot->srna, "invert_a", 0, "Alpha", "Invert Alpha Channel");
2878   RNA_def_property_flag(prop, PROP_SKIP_SAVE);
2879
2880   /* flags */
2881   ot->flag = OPTYPE_REGISTER;
2882 }
2883
2884 /** \} */
2885
2886 /* -------------------------------------------------------------------- */
2887 /** \name Scale Operator
2888  * \{ */
2889
2890 static int image_scale_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
2891 {
2892   Image *ima = image_from_context(C);
2893   PropertyRNA *prop = RNA_struct_find_property(op->ptr, "size");
2894   if (!RNA_property_is_set(op->ptr, prop)) {
2895     ImBuf *ibuf = BKE_image_acquire_ibuf(ima, NULL, NULL);
2896     const int size[2] = {ibuf->x, ibuf->y};
2897     RNA_property_int_set_array(op->ptr, prop, size);
2898     BKE_image_release_ibuf(ima, ibuf, NULL);
2899   }
2900   return WM_operator_props_dialog_popup(C, op, 200, 200);
2901 }
2902
2903 static int image_scale_exec(bContext *C, wmOperator *op)
2904 {
2905   Image *ima = image_from_context(C);
2906   ImBuf *ibuf = BKE_image_acquire_ibuf(ima, NULL, NULL);
2907   SpaceImage *sima = CTX_wm_space_image(C);
2908   const bool is_paint = ((sima != NULL) && (sima->mode == SI_MODE_PAINT));
2909
2910   if (ibuf == NULL) {
2911     /* TODO: this should actually never happen, but does for render-results -> cleanup */
2912     return OPERATOR_CANCELLED;
2913   }
2914
2915   if (is_paint) {
2916     ED_imapaint_clear_partial_redraw();
2917   }
2918
2919   PropertyRNA *prop = RNA_struct_find_property(op->ptr, "size");
2920   int size[2];
2921   if (RNA_property_is_set(op->ptr, prop)) {
2922     RNA_property_int_get_array(op->ptr, prop, size);
2923   }
2924   else {
2925     size[0] = ibuf->x;
2926     size[1] = ibuf->y;
2927     RNA_property_int_set_array(op->ptr, prop, size);
2928   }
2929
2930   ED_image_undo_push_begin_with_image(op->type->name, ima, ibuf);
2931
2932   ibuf->userflags |= IB_DISPLAY_BUFFER_INVALID;
2933   IMB_scaleImBuf(ibuf, size[0], size[1]);
2934   BKE_image_release_ibuf(ima, ibuf, NULL);
2935
2936   ED_image_undo_push_end();
2937
2938   /* force GPU reupload, all image is invalid */
2939   GPU_free_image(ima);
2940
2941   DEG_id_tag_update(&ima->id, 0);
2942   WM_event_add_notifier(C, NC_IMAGE | NA_EDITED, ima);
2943
2944   return OPERATOR_FINISHED;
2945 }
2946
2947 void IMAGE_OT_resize(wmOperatorType *ot)
2948 {
2949   /* identifiers */
2950   ot->name = "Resize Image";
2951   ot->idname = "IMAGE_OT_resize";
2952   ot->description = "Resize the image";
2953
2954   /* api callbacks */
2955   ot->invoke = image_scale_invoke;
2956   ot->exec = image_scale_exec;
2957   ot->poll = image_from_contect_has_data_poll_no_image_user;
2958
2959   /* properties */
2960   RNA_def_int_vector(ot->srna, "size", 2, NULL, 1, INT_MAX, "Size", "", 1, SHRT_MAX);
2961
2962   /* flags */
2963   ot->flag = OPTYPE_REGISTER;
2964 }
2965
2966 /** \} */
2967
2968 /* -------------------------------------------------------------------- */
2969 /** \name Pack Operator
2970  * \{ */
2971
2972 static bool image_pack_test(bContext *C, wmOperator *op)
2973 {
2974   Image *ima = image_from_context(C);
2975
2976   if (!ima) {
2977     return 0;
2978   }
2979
2980   if (ima->source == IMA_SRC_SEQUENCE || ima->source == IMA_SRC_MOVIE) {
2981     BKE_report(op->reports, RPT_ERROR, "Packing movies or image sequences not supported");
2982     return 0;
2983   }
2984
2985   return 1;
2986 }
2987
2988 static int image_pack_exec(bContext *C, wmOperator *op)
2989 {
2990   struct Main *bmain = CTX_data_main(C);
2991   Image *ima = image_from_context(C);
2992
2993   if (!image_pack_test(C, op)) {
2994     return OPERATOR_CANCELLED;
2995   }
2996
2997   if (BKE_image_is_dirty(ima)) {
2998     BKE_image_memorypack(ima);
2999   }
3000   else {
3001     BKE_image_packfiles(op->reports, ima, ID_BLEND_PATH(bmain, &ima->id));
3002   }
3003
3004   WM_event_add_notifier(C, NC_IMAGE | NA_EDITED, ima);
3005
3006   return OPERATOR_FINISHED;
3007 }
3008
3009 void IMAGE_OT_pack(wmOperatorType *ot)
3010 {
3011   /* identifiers */
3012   ot->name = "Pack Image";
3013   ot->description = "Pack an image as embedded data into the .blend file";
3014   ot->idname = "IMAGE_OT_pack";
3015
3016   /* api callbacks */
3017   ot->exec = image_pack_exec;
3018
3019   /* flags */
3020   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
3021 }
3022
3023 /** \} */
3024
3025 /* -------------------------------------------------------------------- */
3026 /** \name Unpack Operator
3027  * \{ */
3028
3029 static int image_unpack_exec(bContext *C, wmOperator *op)
3030 {
3031   Image *ima = image_from_context(C);
3032   int method = RNA_enum_get(op->ptr, "method");
3033
3034   /* find the suppplied image by name */
3035   if (RNA_struct_property_is_set(op->ptr, "id")) {
3036     char imaname[MAX_ID_NAME - 2];
3037     RNA_string_get(op->ptr, "id", imaname);
3038     ima = BLI_findstring(&CTX_data_main(C)->images, imaname, offsetof(ID, name) + 2);
3039     if (!ima) {
3040       ima = image_from_context(C);
3041     }
3042   }
3043
3044   if (!ima || !BKE_image_has_packedfile(ima)) {
3045     return OPERATOR_CANCELLED;
3046   }
3047
3048   if (ima->source == IMA_SRC_SEQUENCE || ima->source == IMA_SRC_MOVIE) {
3049     BKE_report(op->reports, RPT_ERROR, "Unpacking movies or image sequences not supported");
3050     return OPERATOR_CANCELLED;
3051   }
3052
3053   if (G.fileflags & G_FILE_AUTOPACK) {
3054     BKE_report(op->reports,
3055                RPT_WARNING,
3056                "AutoPack is enabled, so image will be packed again on file save");
3057   }
3058
3059   /* XXX BKE_packedfile_unpack_image frees image buffers */
3060   ED_preview_kill_jobs(CTX_wm_manager(C), CTX_data_main(C));
3061
3062   BKE_packedfile_unpack_image(CTX_data_main(C), op->reports, ima, method);
3063
3064   WM_event_add_notifier(C, NC_IMAGE | NA_EDITED, ima);
3065
3066   return OPERATOR_FINISHED;
3067 }
3068
3069 static int image_unpack_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
3070 {
3071   Image *ima = image_from_context(C);
3072
3073   if (RNA_struct_property_is_set(op->ptr, "id")) {
3074     return image_unpack_exec(C, op);
3075   }
3076
3077   if (!ima || !BKE_image_has_packedfile(ima)) {
3078     return OPERATOR_CANCELLED;
3079   }
3080
3081   if (ima->source == IMA_SRC_SEQUENCE || ima->source == IMA_SRC_MOVIE) {
3082     BKE_report(op->reports, RPT_ERROR, "Unpacking movies or image sequences not supported");
3083     return OPERATOR_CANCELLED;
3084   }
3085
3086   if (G.fileflags & G_FILE_AUTOPACK) {
3087     BKE_report(op->reports,
3088                RPT_WARNING,
3089                "AutoPack is enabled, so image will be packed again on file save");
3090   }
3091
3092   unpack_menu(C,
3093               "IMAGE_OT_unpack",
3094               ima->id.name + 2,
3095               ima->name,
3096               "textures",
3097               BKE_image_has_packedfile(ima) ?
3098                   ((ImagePackedFile *)ima->packedfiles.first)->packedfile :
3099                   NULL);
3100
3101   return OPERATOR_FINISHED;
3102 }
3103
3104 void IMAGE_OT_unpack(wmOperatorType *ot)
3105 {
3106   /* identifiers */
3107   ot->name = "Unpack Image";
3108   ot->description = "Save an image packed in the .blend file to disk";
3109   ot->idname = "IMAGE_OT_unpack";
3110
3111   /* api callbacks */
3112   ot->exec = image_unpack_exec;
3113   ot->invoke = image_unpack_invoke;
3114
3115   /* flags */
3116   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
3117
3118   /* properties */
3119   RNA_def_enum(
3120       ot->srna, "method", rna_enum_unpack_method_items, PF_USE_LOCAL, "Method", "How to unpack");
3121   /* XXX, weak!, will fail with library, name collisions */
3122   RNA_def_string(
3123       ot->srna, "id", NULL, MAX_ID_NAME - 2, "Image Name", "Image data-block name to unpack");
3124 }
3125
3126 /** \} */
3127
3128 /* -------------------------------------------------------------------- */
3129 /** \name Sample Image Operator
3130  * \{ */
3131
3132 typedef struct ImageSampleInfo {
3133   ARegionType *art;
3134   void *draw_handle;
3135   int x, y;
3136   int channels;
3137
3138   int width, height;
3139   int sample_size;
3140
3141   unsigned char col[4];
3142   float colf[4];
3143   float linearcol[4];
3144   int z;
3145   float zf;
3146
3147   unsigned char *colp;
3148   const float *colfp;
3149   int *zp;
3150   float *zfp;
3151
3152   bool draw;
3153   bool color_manage;
3154   int use_default_view;
3155 } ImageSampleInfo;
3156
3157 static void image_sample_draw(const bContext *C, ARegion *ar, void *arg_info)
3158 {
3159   ImageSampleInfo *info = arg_info;
3160   if (!info->draw) {
3161     return;
3162   }
3163
3164   Scene *scene = CTX_data_scene(C);
3165   ED_image_draw_info(scene,
3166                      ar,
3167                      info->color_manage,
3168                      info->use_default_view,
3169                      info->channels,
3170                      info->x,
3171                      info->y,
3172                      info->colp,
3173                      info->colfp,
3174                      info->linearcol,
3175                      info->zp,
3176                      info->zfp);
3177
3178   if (info->sample_size > 1) {
3179     const wmWindow *win = CTX_wm_window(C);
3180     const wmEvent *event = win->eventstate;
3181
3182     SpaceImage *sima = CTX_wm_space_image(C);
3183     GPUVertFormat *format = immVertexFormat();
3184     uint pos = GPU_vertformat_attr_add(format, "pos", GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
3185
3186     const float color[3] = {1, 1, 1};
3187     immBindBuiltinProgram(GPU_SHADER_2D_UNIFORM_COLOR);
3188     immUniformColor3fv(color);
3189
3190     /* TODO(campbell): lock to pixels. */
3191     rctf sample_rect_fl;
3192     BLI_rctf_init_pt_radius(&sample_rect_fl,
3193                             (float[2]){event->x - ar->winrct.xmin, event->y - ar->winrct.ymin},
3194                             (float)(info->sample_size / 2.0f) * sima->zoom);
3195
3196     glEnable(GL_COLOR_LOGIC_OP);
3197     glLogicOp(GL_XOR);
3198     GPU_line_width(1.0f);
3199     imm_draw_box_wire_2d(pos,
3200                          (float)sample_rect_fl.xmin,
3201                          (float)sample_rect_fl.ymin,
3202                          (float)sample_rect_fl.xmax,
3203                          (float)sample_rect_fl.ymax);
3204     glDisable(GL_COLOR_LOGIC_OP);
3205
3206     immUnbindProgram();
3207   }
3208 }
3209
3210 /* Returns color in linear space, matching ED_space_node_color_sample(). */
3211 bool ED_space_image_color_sample(SpaceImage *sima, ARegion *ar, int mval[2], float r_col[3])
3212 {
3213   void *lock;
3214   ImBuf *ibuf = ED_space_image_acquire_buffer(sima, &lock);
3215   float fx, fy;
3216   bool ret = false;
3217
3218   if (ibuf == NULL) {
3219     ED_space_image_release_buffer(sima, ibuf, lock);
3220     return false;
3221   }
3222
3223   UI_view2d_region_to_view(&ar->v2d, mval[0], mval[1], &fx, &fy);
3224
3225   if (fx >= 0.0f && fy >= 0.0f && fx < 1.0f && fy < 1.0f) {
3226     const float *fp;
3227     unsigned char *cp;
3228     int x = (int)(fx * ibuf->x), y = (int)(fy * ibuf->y);
3229
3230     CLAMP(x, 0, ibuf->x - 1);
3231     CLAMP(y, 0, ibuf->y - 1);
3232
3233     if (ibuf->rect_float) {
3234       fp = (ibuf->rect_float + (ibuf->channels) * (y * ibuf->x + x));
3235       copy_v3_v3(r_col, fp);
3236       ret = true;
3237     }
3238     else if (ibuf->rect) {
3239       cp = (unsigned char *)(ibuf->rect + y * ibuf->x + x);
3240       rgb_uchar_to_float(r_col, cp);
3241       IMB_colormanagement_colorspace_to_scene_linear_v3(r_col, ibuf->rect_colorspace);
3242       ret = true;
3243     }
3244   }
3245
3246   ED_space_image_release_buffer(sima, ibuf, lock);
3247   return ret;
3248 }
3249
3250 /* -------------------------------------------------------------------- */
3251 /** \name Image Pixel Sample
3252  * \{ */
3253
3254 static void image_sample_pixel_color_ubyte(const ImBuf *ibuf,
3255                                            const int coord[2],
3256                                            uchar r_col[4],
3257                                            float r_col_linear[4])
3258 {
3259   const uchar *cp = (unsigned char *)(ibuf->rect + coord[1] * ibuf->x + coord[0]);
3260   copy_v4_v4_uchar(r_col, cp);
3261   rgba_uchar_to_float(r_col_linear, r_col);
3262   IMB_colormanagement_colorspace_to_scene_linear_v4(r_col_linear, false, ibuf->rect_colorspace);
3263 }
3264
3265 static void image_sample_pixel_color_float(ImBuf *ibuf, const int coord[2], float r_col[4])
3266 {
3267   const float *cp = ibuf->rect_float + (ibuf->channels) * (coord[1] * ibuf->x + coord[0]);
3268   copy_v4_v4(r_col, cp);
3269 }
3270
3271 /** \} */
3272
3273 /* -------------------------------------------------------------------- */
3274 /** \name Image Pixel Region Sample
3275  * \{ */
3276
3277 static void image_sample_rect_color_ubyte(const ImBuf *ibuf,
3278                                           const rcti *rect,
3279                                           uchar r_col[4],
3280                                           float r_col_linear[4])
3281 {
3282   uint col_accum_ub[4] = {0, 0, 0, 0};
3283   zero_v4(r_col_linear);
3284   int col_tot = 0;
3285   int coord[2];
3286   for (coord[0] = rect->xmin; coord[0] <= rect->xmax; coord[0]++) {
3287     for (coord[1] = rect->ymin; coord[1] <= rect->ymax; coord[1]++) {
3288       float col_temp_fl[4];
3289       uchar col_temp_ub[4];
3290       image_sample_pixel_color_ubyte(ibuf, coord, col_temp_ub, col_temp_fl);
3291       add_v4_v4(r_col_linear, col_temp_fl);
3292       col_accum_ub[0] += (uint)col_temp_ub[0];
3293       col_accum_ub[1] += (uint)col_temp_ub[1];
3294       col_accum_ub[2] += (uint)col_temp_ub[2];
3295       col_accum_ub[3] += (uint)col_temp_ub[3];
3296       col_tot += 1;
3297     }
3298   }
3299   mul_v4_fl(r_col_linear, 1.0 / (float)col_tot);
3300
3301   r_col[0] = MIN2(col_accum_ub[0] / col_tot, 255);
3302   r_col[1] = MIN2(col_accum_ub[1] / col_tot, 255);
3303   r_col[2] = MIN2(col_accum_ub[2] / col_tot, 255);
3304   r_col[3] = MIN2(col_accum_ub[3] / col_tot, 255);
3305 }
3306
3307 static void image_sample_rect_color_float(ImBuf *ibuf, const rcti *rect, float r_col[4])
3308 {
3309   zero_v4(r_col);
3310   int col_tot = 0;
3311   int coord[2];
3312   for (coord[0] = rect->xmin; coord[0] <= rect->xmax; coord[0]++) {
3313     for (coord[1] = rect->ymin; coord[1] <= rect->ymax; coord[1]++) {
3314       float col_temp_fl[4];
3315       image_sample_pixel_color_float(ibuf, coord, col_temp_fl);
3316       add_v4_v4(r_col, col_temp_fl);
3317       col_tot += 1;
3318     }
3319   }
3320   mul_v4_fl(r_col, 1.0 / (float)col_tot);
3321 }
3322
3323 /** \} */
3324
3325 static void image_sample_apply(bContext *C, wmOperator *op, const wmEvent *event)
3326 {
3327   SpaceImage *sima = CTX_wm_space_image(C);
3328   ARegion *ar = CTX_wm_region(C);
3329   void *lock;
3330   ImBuf *ibuf = ED_space_image_acquire_buffer(sima, &lock);
3331   ImageSampleInfo *info = op->customdata;
3332   float fx, fy;
3333   Scene *scene = CTX_data_scene(C);
3334   CurveMapping *curve_mapping = scene->view_settings.curve_mapping;
3335
3336   if (ibuf == NULL) {
3337     ED_space_image_release_buffer(sima, ibuf, lock);
3338     info->draw = false;
3339     return;
3340   }
3341
3342   UI_view2d_region_to_view(&ar->v2d, event->mval[0], event->mval[1], &fx, &fy);
3343
3344   if (fx >= 0.0f && fy >= 0.0f && fx < 1.0f && fy < 1.0f) {
3345     int x = (int)(fx * ibuf->x), y = (int)(fy * ibuf->y);
3346     Image *image = ED_space_image(sima);
3347
3348     CLAMP(x, 0, ibuf->x - 1);
3349     CLAMP(y, 0, ibuf->y - 1);
3350
3351     info->width = ibuf->x;
3352     info->height = ibuf->y;
3353     info->x = x;
3354     info->y = y;
3355
3356     info->draw = true;
3357     info->channels = ibuf->channels;
3358
3359     info->colp = NULL;
3360     info->colfp = NULL;
3361     info->zp = NULL;
3362     info->zfp = NULL;
3363
3364     info->use_default_view = (image->flag & IMA_VIEW_AS_RENDER) ? false : true;
3365
3366     rcti sample_rect;
3367     sample_rect.xmin = max_ii(0, x - info->sample_size / 2);
3368     sample_rect.ymin = max_ii(0, y - info->sample_size / 2);
3369     sample_rect.xmax = min_ii(ibuf->x, sample_rect.xmin + info->sample_size) - 1;
3370     sample_rect.ymax = min_ii(ibuf->y, sample_rect.ymin + info->sample_size) - 1;
3371
3372     if (ibuf->rect) {
3373       image_sample_rect_color_ubyte(ibuf, &sample_rect, info->col, info->linearcol);
3374       rgba_uchar_to_float(info->colf, info->col);
3375
3376       info->colp = info->col;
3377       info->colfp = info->colf;
3378       info->color_manage = true;
3379     }
3380     if (ibuf->rect_float) {
3381       image_sample_rect_color_float(ibuf, &sample_rect, info->colf);
3382
3383       if (ibuf->channels == 4) {
3384         /* pass */
3385       }
3386       else if (ibuf->channels == 3) {
3387         info->colf[3] = 1.0f;
3388       }
3389       else {
3390         info->colf[1] = info->colf[0];
3391         info->colf[2] = info->colf[0];
3392         info->colf[3] = 1.0f;
3393       }
3394       info->colfp = info->colf;
3395
3396       copy_v4_v4(info->linearcol, info->colf);
3397
3398       info->color_manage = true;
3399     }
3400
3401     if (ibuf->zbuf) {
3402       /* TODO, blend depth (not urgent). */
3403       info->z = ibuf->zbuf[y * ibuf->x + x];
3404       info->zp = &info->z;
3405       if (ibuf->zbuf == (int *)ibuf->rect) {
3406         info->colp = NULL;
3407       }
3408     }
3409     if (ibuf->zbuf_float) {
3410       /* TODO, blend depth (not urgent). */
3411       info->zf = ibuf->zbuf_float[y * ibuf->x + x];
3412       info->zfp = &info->zf;
3413       if (ibuf->zbuf_float == ibuf->rect_float) {
3414         info->colfp = NULL;
3415       }
3416     }
3417
3418     if (curve_mapping && ibuf->channels == 4) {
3419       /* we reuse this callback for set curves point operators */
3420       if (RNA_struct_find_property(op->ptr, "point")) {
3421         int point = RNA_enum_get(op->ptr, "point");
3422
3423         if (point == 1) {
3424           BKE_curvemapping_set_black_white(curve_mapping, NULL, info->linearcol);
3425         }
3426         else if (point == 0) {
3427           BKE_curvemapping_set_black_white(curve_mapping, info->linearcol, NULL);
3428         }
3429         WM_event_add_notifier(C, NC_WINDOW, NULL);
3430       }
3431     }
3432
3433     // XXX node curve integration ..
3434 #if 0
3435     {
3436       ScrArea *sa, *cur = curarea;
3437
3438       node_curvemap_sample(fp); /* sends global to node editor */
3439       for (sa = G.curscreen->areabase.first; sa; sa = sa->next) {
3440         if (sa->spacetype == SPACE_NODE) {
3441           areawinset(sa->win);
3442           scrarea_do_windraw(sa);
3443         }
3444       }
3445       node_curvemap_sample(NULL); /* clears global in node editor */
3446       curarea = cur;
3447     }
3448 #endif
3449   }
3450   else {
3451     info->draw = 0;
3452   }
3453
3454   ED_space_image_release_buffer(sima, ibuf, lock);
3455   ED_area_tag_redraw(CTX_wm_area(C));
3456 }
3457
3458 static void image_sample_exit(bContext *C, wmOperator *op)
3459 {
3460   ImageSampleInfo *info = op->customdata;
3461
3462   ED_region_draw_cb_exit(info->art, info->draw_handle);
3463   ED_area_tag_redraw(CTX_wm_area(C));
3464   MEM_freeN(info);
3465 }
3466
3467 static int image_sample_invoke(bContext *C, wmOperator *op, const wmEvent *event)
3468 {
3469   SpaceImage *sima = CTX_wm_space_image(C);
3470   ARegion *ar = CTX_wm_region(C);
3471   ImageSampleInfo *info;
3472
3473   if (ar->regiontype == RGN_TYPE_WINDOW) {
3474     if (event->mval[1] <= 16 && ED_space_image_show_cache(sima)) {
3475       return OPERATOR_PASS_THROUGH;
3476     }
3477   }
3478
3479   if (!ED_space_image_has_buffer(sima)) {
3480     return OPERATOR_CANCELLED;
3481   }
3482
3483   info = MEM_callocN(sizeof(ImageSampleInfo), "ImageSampleInfo");
3484
3485   info->art = ar->type;
3486   info->draw_handle = ED_region_draw_cb_activate(
3487       ar->type, image_sample_draw, info, REGION_DRAW_POST_PIXEL);
3488   info->sample_size = RNA_int_get(op->ptr, "size");
3489   op->customdata = info;
3490
3491   image_sample_apply(C, op, event);
3492
3493   WM_event_add_modal_handler(C, op);
3494
3495   return OPERATOR_RUNNING_MODAL;
3496 }
3497
3498 static int image_sample_modal(bContext *C, wmOperator *op, const wmEvent *event)
3499 {
3500   switch (event->type) {
3501     case LEFTMOUSE:
3502     case RIGHTMOUSE:  // XXX hardcoded
3503       if (event->val == KM_RELEASE) {
3504         image_sample_exit(C, op);
3505         return OPERATOR_CANCELLED;
3506       }
3507       break;
3508     case MOUSEMOVE:
3509       image_sample_apply(C, op, event);
3510       break;
3511   }
3512
3513   return OPERATOR_RUNNING_MODAL;
3514 }
3515
3516 static void image_sample_cancel(bContext *C, wmOperator *op)
3517 {
3518   image_sample_exit(C, op);
3519 }
3520
3521 void IMAGE_OT_sample(wmOperatorType *ot)
3522 {
3523   /* identifiers */
3524   ot->name = "Sample Color";
3525   ot->idname = "IMAGE_OT_sample";
3526   ot->description = "Use mouse to sample a color in current image";
3527
3528   /* api callbacks */
3529   ot->invoke = image_sample_invoke;
3530   ot->modal = image_sample_modal;
3531   ot->cancel = image_sample_cancel;
3532   ot->poll = image_sample_poll;
3533
3534   /* flags */
3535   ot->flag = OPTYPE_BLOCKING;
3536
3537   PropertyRNA *prop;
3538   prop = RNA_def_int(ot->srna, "size", 1, 1, 128, "Sample Size", "", 1, 64);
3539   RNA_def_property_subtype(prop, PROP_PIXEL);
3540   RNA_def_property_flag(prop, PROP_SKIP_SAVE);
3541 }
3542
3543 /** \} */
3544
3545 /* -------------------------------------------------------------------- */
3546 /** \name Sample Line Operator
3547  * \{ */
3548
3549 static int image_sample_line_exec(bContext *C, wmOperator *op)
3550 {
3551   SpaceImage *sima = CTX_wm_space_image(C);
3552   ARegion *ar = CTX_wm_region(C);
3553   Scene *scene = CTX_data_scene(C);
3554
3555   int x_start = RNA_int_get(op->ptr, "xstart");
3556   int y_start = RNA_int_get(op->ptr, "ystart");
3557   int x_end = RNA_int_get(op->ptr, "xend");
3558   int y_end = RNA_int_get(op->ptr, "yend");
3559
3560   void *lock;
3561   ImBuf *ibuf = ED_space_image_acquire_buffer(sima, &lock);
3562   Histogram *hist = &sima->sample_line_hist;
3563
3564   float x1f, y1f, x2f, y2f;
3565
3566   if (ibuf == NULL) {
3567     ED_space_image_release_buffer(sima, ibuf, lock);
3568     return OPERATOR_CANCELLED;
3569   }
3570   /* hmmmm */
3571   if (ibuf->channels < 3) {
3572     ED_space_image_release_buffer(sima, ibuf, lock);
3573     return OPERATOR_CANCELLED;
3574   }
3575
3576   UI_view2d_region_to_view(&ar->v2d, x_start, y_start, &x1f, &y1f);
3577   UI_view2d_region_to_view(&ar->v2d, x_end, y_end, &x2f, &y2f);
3578
3579   hist->co[0][0] = x1f;
3580   hist->co[0][1] = y1f;
3581   hist->co[1][0] = x2f;
3582   hist->co[1][1] = y2f;
3583
3584   /* enable line drawing */
3585   hist->flag |= HISTO_FLAG_SAMPLELINE;
3586
3587   BKE_histogram_update_sample_line(hist, ibuf, &scene->view_settings, &scene->display_settings);
3588
3589   /* reset y zoom */
3590   hist->ymax = 1.0f;
3591
3592   ED_space_image_release_buffer(sima, ibuf, lock);
3593
3594   ED_area_tag_redraw(CTX_wm_area(C));
3595
3596   return OPERATOR_FINISHED;
3597 }
3598
3599 static int image_sample_line_invoke(bContext *C, wmOperator *op, const wmEvent *event)
3600 {
3601   SpaceImage *sima = CTX_wm_space_image(C);
3602
3603   Histogram *hist = &sima->sample_line_hist;
3604   hist->flag &= ~HISTO_FLAG_SAMPLELINE;
3605
3606   if (!ED_space_image_has_buffer(sima)) {
3607     return OPERATOR_CANCELLED;
3608   }
3609
3610   return WM_gesture_straightline_invoke(C, op, event);
3611 }
3612
3613 void IMAGE_OT_sample_line(wmOperatorType *ot)
3614 {
3615   /* identifiers */
3616   ot->name = "Sample Line";
3617   ot->idname = "IMAGE_OT_sample_line";
3618   ot->description = "Sample a line and show it in Scope panels";
3619
3620   /* api callbacks */
3621   ot->invoke = image_sample_line_invoke;
3622   ot->modal = WM_gesture_straightline_modal;
3623   ot->exec = image_sample_line_exec;
3624   ot->poll = space_image_main_region_poll;
3625   ot->cancel = WM_gesture_straightline_cancel;
3626
3627   /* flags */
3628   ot->flag = 0; /* no undo/register since this operates on the space */
3629
3630   WM_operator_properties_gesture_straightline(ot, WM_CURSOR_EDIT);
3631 }
3632
3633 /** \} */
3634
3635 /* -------------------------------------------------------------------- */
3636 /** \name Set Curve Point Operator
3637  * \{ */
3638
3639 void IMAGE_OT_curves_point_set(wmOperatorType *ot)
3640 {
3641   static const EnumPropertyItem point_items[] = {
3642       {0, "BLACK_POINT", 0, "Black Point", ""},
3643       {1, "WHITE_POINT", 0, "White Point", ""},
3644       {0, NULL, 0, NULL, NULL},
3645   };
3646
3647   /* identifiers */
3648   ot->name = "Set Curves Point";
3649   ot->idname = "IMAGE_OT_curves_point_set";
3650   ot->description = "Set black point or white point for curves";
3651
3652   /* flags */
3653   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
3654
3655   /* api callbacks */
3656   ot->invoke = image_sample_invoke;
3657   ot->modal = image_sample_modal;
3658   ot->cancel = image_sample_cancel;
3659   ot->poll = space_image_main_area_not_uv_brush_poll;
3660
3661   /* properties */
3662   RNA_def_enum(
3663       ot->srna, "point", point_items, 0, "Point", "Set black point or white point for curves");
3664
3665   PropertyRNA *prop;
3666   prop = RNA_def_int(ot->srna, "size", 1, 1, 128, "Sample Size", "", 1, 64);
3667   RNA_def_property_subtype(prop, PROP_PIXEL);
3668   RNA_def_property_flag(prop, PROP_SKIP_SAVE);
3669 }
3670
3671 /** \} */
3672
3673 /* -------------------------------------------------------------------- */
3674 /** \name Cycle Render Slot Operator
3675  * \{ */
3676
3677 static bool image_cycle_render_slot_poll(bContext *C)
3678 {
3679   Image *ima = image_from_context(C);
3680
3681   return (ima && ima->type == IMA_TYPE_R_RESULT);
3682 }
3683
3684 static int image_cycle_render_slot_exec(bContext *C, wmOperator *op)
3685 {
3686   Image *ima = image_from_context(C);
3687   const int direction = RNA_boolean_get(op->ptr, "reverse") ? -1 : 1;
3688
3689   if (!ED_image_slot_cycle(ima, direction)) {
3690     return OPERATOR_CANCELLED;
3691   }
3692
3693   WM_event_add_notifier(C, NC_IMAGE | ND_DRAW, NULL);
3694
3695   /* no undo push for browsing existing */
3696   RenderSlot *slot = BKE_image_get_renderslot(ima, ima->render_slot);
3697   if ((slot && slot->render) || ima->render_slot == ima->last_render_slot) {
3698     return OPERATOR_CANCELLED;
3699   }
3700
3701   return OPERATOR_FINISHED;
3702 }
3703
3704 void IMAGE_OT_cycle_render_slot(wmOperatorType *ot)
3705 {
3706   /* identifiers */
3707   ot->name = "Cycle Render Slot";
3708   ot->idname = "IMAGE_OT_cycle_render_slot";
3709   ot->description = "Cycle through all non-void render slots";
3710
3711   /* api callbacks */
3712   ot->exec = image_cycle_render_slot_exec;
3713   ot->poll = image_cycle_render_slot_poll;
3714
3715   /* flags */
3716   ot->flag = OPTYPE_REGISTER;
3717
3718   RNA_def_boolean(ot->srna, "reverse", 0, "Cycle in Reverse", "");
3719 }
3720
3721 /** \} */
3722
3723 /* -------------------------------------------------------------------- */
3724 /** \name Clear Render Slot Operator
3725  * \{ */
3726
3727 static int image_clear_render_slot_exec(bContext *C, wmOperator *UNUSED(op))
3728 {
3729   SpaceImage *sima = CTX_wm_space_image(C);
3730   Image *ima = image_from_context(C);
3731
3732   if (!BKE_image_clear_renderslot(ima, &sima->iuser, ima->render_slot)) {
3733     return OPERATOR_CANCELLED;
3734   }
3735
3736   WM_event_add_notifier(C, NC_IMAGE | ND_DRAW, NULL);
3737
3738   return OPERATOR_FINISHED;
3739 }
3740
3741 void IMAGE_OT_clear_render_slot(wmOperatorType *ot)
3742 {
3743   /* identifiers */
3744   ot->name = "Clear Render Slot";
3745   ot->idname = "IMAGE_OT_clear_render_slot";
3746   ot->description = "Clear the currently selected render slot";
3747
3748   /* api callbacks */
3749   ot->exec = image_clear_render_slot_exec;
3750   ot->poll = image_cycle_render_slot_poll;
3751
3752   /* flags */
3753   ot->flag = OPTYPE_REGISTER;
3754 }
3755
3756 /** \} */
3757
3758 /* -------------------------------------------------------------------- */
3759 /** \name Add Render Slot Operator
3760  * \{ */
3761
3762 static int image_add_render_slot_exec(bContext *C, wmOperator *UNUSED(op))
3763 {
3764   Image *ima = image_from_context(C);
3765
3766   RenderSlot *slot = BKE_image_add_renderslot(ima, NULL);
3767   ima->render_slot = BLI_findindex(&ima->renderslots, slot);
3768
3769   WM_event_add_notifier(C, NC_IMAGE | ND_DRAW, NULL);
3770
3771   return OPERATOR_FINISHED;
3772 }
3773
3774 void IMAGE_OT_add_render_slot(wmOperatorType *ot)
3775 {
3776   /* identifiers */
3777   ot->name = "Add Render Slot";
3778   ot->idname = "IMAGE