source/blender/editors/space_image/image_ops.c

   1 /**
   2  * $Id$
   3  *
   4  * ***** BEGIN GPL LICENSE BLOCK *****
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License
   8  * as published by the Free Software Foundation; either version 2
   9  * of the License, or (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software Foundation,
  18  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  19  *
  20  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
  21  * All rights reserved.
  22  *
  23  * Contributor(s): Blender Foundation, 2002-2009
  24  *
  25  * ***** END GPL LICENSE BLOCK *****
  26  */
  27
  28 #include <string.h>
  29 #include <stdlib.h>
  30
  31 #include "MEM_guardedalloc.h"
  32
  33 #include "DNA_image_types.h"
  34 #include "DNA_node_types.h"
  35 #include "DNA_object_types.h"
  36 #include "DNA_packedFile_types.h"
  37 #include "DNA_space_types.h"
  38 #include "DNA_scene_types.h"
  39 #include "DNA_screen_types.h"
  40 #include "DNA_userdef_types.h"
  41 #include "DNA_windowmanager_types.h"
  42
  43 #include "BKE_colortools.h"
  44 #include "BKE_context.h"
  45 #include "BKE_image.h"
  46 #include "BKE_global.h"
  47 #include "BKE_library.h"
  48 #include "BKE_node.h"
  49 #include "BKE_packedFile.h"
  50 #include "BKE_report.h"
  51 #include "BKE_screen.h"
  52
  53 #include "BLI_arithb.h"
  54 #include "BLI_blenlib.h"
  55
  56 #include "IMB_imbuf.h"
  57 #include "IMB_imbuf_types.h"
  58
  59 #include "RE_pipeline.h"
  60
  61 #include "RNA_access.h"
  62 #include "RNA_define.h"
  63 #include "RNA_types.h"
  64
  65 #include "ED_image.h"
  66 #include "ED_screen.h"
  67 #include "ED_space_api.h"
  68 #include "ED_uvedit.h"
  69
  70 #include "UI_interface.h"
  71 #include "UI_resources.h"
  72 #include "UI_view2d.h"
  73
  74 #include "WM_api.h"
  75 #include "WM_types.h"
  76
  77 #include "image_intern.h"
  78
  79 /******************** view navigation utilities *********************/
  80
  81 static void sima_zoom_set(SpaceImage *sima, ARegion *ar, float zoom)
  82 {
  83         float oldzoom= sima->zoom;
  84         int width, height;
  85
  86         sima->zoom= zoom;
  87
  88         if (sima->zoom > 0.1f && sima->zoom < 4.0f)
  89                 return;
  90
  91         /* check zoom limits */
  92         ED_space_image_size(sima, &width, &height);
  93
  94         width *= sima->zoom;
  95         height *= sima->zoom;
  96
  97         if((width < 4) && (height < 4))
  98                 sima->zoom= oldzoom;
  99         else if((ar->winrct.xmax - ar->winrct.xmin) <= sima->zoom)
 100                 sima->zoom= oldzoom;
 101         else if((ar->winrct.ymax - ar->winrct.ymin) <= sima->zoom)
 102                 sima->zoom= oldzoom;
 103 }
 104
 105 static void sima_zoom_set_factor(SpaceImage *sima, ARegion *ar, float zoomfac)
 106 {
 107         sima_zoom_set(sima, ar, sima->zoom*zoomfac);
 108 }
 109
 110 static int space_image_poll(bContext *C)
 111 {
 112         SpaceImage *sima= (SpaceImage*)CTX_wm_space_data(C);
 113         if(sima && sima->spacetype==SPACE_IMAGE)
 114                 if(ED_space_image_buffer(sima))
 115                         return 1;
 116         return 0;
 117 }
 118
 119 static int space_image_file_exists_poll(bContext *C)
 120 {
 121         if(space_image_poll(C)) {
 122                 SpaceImage *sima= (SpaceImage*)CTX_wm_space_data(C);
 123                 ImBuf *ibuf= ED_space_image_buffer(sima);
 124
 125                 if(ibuf && BLI_exists(ibuf->name) && BLI_is_writable(ibuf->name))
 126                         return 1;
 127         }
 128         return 0;
 129 }
 130
 131
 132 int space_image_main_area_poll(bContext *C)
 133 {
 134         SpaceLink *slink= CTX_wm_space_data(C);
 135         // XXX ARegion *ar= CTX_wm_region(C);
 136
 137         if(slink && (slink->spacetype == SPACE_IMAGE))
 138                 return 1; // XXX (ar && ar->type->regionid == RGN_TYPE_WINDOW);
 139
 140         return 0;
 141 }
 142
 143 /********************** view pan operator *********************/
 144
 145 typedef struct ViewPanData {
 146         float x, y;
 147         float xof, yof;
 148 } ViewPanData;
 149
 150 static void view_pan_init(bContext *C, wmOperator *op, wmEvent *event)
 151 {
 152         SpaceImage *sima= (SpaceImage*)CTX_wm_space_data(C);
 153         ViewPanData *vpd;
 154
 155         op->customdata= vpd= MEM_callocN(sizeof(ViewPanData), "ImageViewPanData");
 156         WM_cursor_modal(CTX_wm_window(C), BC_NSEW_SCROLLCURSOR);
 157
 158         vpd->x= event->x;
 159         vpd->y= event->y;
 160         vpd->xof= sima->xof;
 161         vpd->yof= sima->yof;
 162
 163         WM_event_add_modal_handler(C, &CTX_wm_window(C)->handlers, op);
 164 }
 165
 166 static void view_pan_exit(bContext *C, wmOperator *op, int cancel)
 167 {
 168         SpaceImage *sima= (SpaceImage*)CTX_wm_space_data(C);
 169         ViewPanData *vpd= op->customdata;
 170
 171         if(cancel) {
 172                 sima->xof= vpd->xof;
 173                 sima->yof= vpd->yof;
 174                 ED_area_tag_redraw(CTX_wm_area(C));
 175         }
 176
 177         WM_cursor_restore(CTX_wm_window(C));
 178         MEM_freeN(op->customdata);
 179 }
 180
 181 static int view_pan_exec(bContext *C, wmOperator *op)
 182 {
 183         SpaceImage *sima= (SpaceImage*)CTX_wm_space_data(C);
 184         float offset[2];
 185
 186         RNA_float_get_array(op->ptr, "offset", offset);
 187         sima->xof += offset[0];
 188         sima->yof += offset[1];
 189
 190         ED_area_tag_redraw(CTX_wm_area(C));
 191
 192         /* XXX notifier? */
 193 #if 0
 194         if(image_preview_active(curarea, NULL, NULL)) {
 195                 /* recalculates new preview rect */
 196                 scrarea_do_windraw(curarea);
 197                 image_preview_event(2);
 198         }
 199 #endif
 200
 201         return OPERATOR_FINISHED;
 202 }
 203
 204 static int view_pan_invoke(bContext *C, wmOperator *op, wmEvent *event)
 205 {
 206         view_pan_init(C, op, event);
 207         return OPERATOR_RUNNING_MODAL;
 208 }
 209
 210 static int view_pan_modal(bContext *C, wmOperator *op, wmEvent *event)
 211 {
 212         SpaceImage *sima= (SpaceImage*)CTX_wm_space_data(C);
 213         ViewPanData *vpd= op->customdata;
 214         float offset[2];
 215
 216         switch(event->type) {
 217                 case MOUSEMOVE:
 218                         sima->xof= vpd->xof;
 219                         sima->yof= vpd->yof;
 220                         offset[0]= (vpd->x - event->x)/sima->zoom;
 221                         offset[1]= (vpd->y - event->y)/sima->zoom;
 222                         RNA_float_set_array(op->ptr, "offset", offset);
 223                         view_pan_exec(C, op);
 224                         break;
 225                 case MIDDLEMOUSE:
 226                         if(event->val==0) {
 227                                 view_pan_exit(C, op, 0);
 228                                 return OPERATOR_FINISHED;
 229                         }
 230                         break;
 231         }
 232
 233         return OPERATOR_RUNNING_MODAL;
 234 }
 235
 236 static int view_pan_cancel(bContext *C, wmOperator *op)
 237 {
 238         view_pan_exit(C, op, 1);
 239         return OPERATOR_CANCELLED;
 240 }
 241
 242 void IMAGE_OT_view_pan(wmOperatorType *ot)
 243 {
 244         /* identifiers */
 245         ot->name= "View Pan";
 246         ot->idname= "IMAGE_OT_view_pan";
 247
 248         /* api callbacks */
 249         ot->exec= view_pan_exec;
 250         ot->invoke= view_pan_invoke;
 251         ot->modal= view_pan_modal;
 252         ot->cancel= view_pan_cancel;
 253         ot->poll= space_image_main_area_poll;
 254
 255         /* properties */
 256         RNA_def_float_vector(ot->srna, "offset", 2, NULL, -FLT_MAX, FLT_MAX,
 257                 "Offset", "Offset in floating point units, 1.0 is the width and height of the image.", -FLT_MAX, FLT_MAX);
 258 }
 259
 260 /********************** view zoom operator *********************/
 261
 262 typedef struct ViewZoomData {
 263         float x, y;
 264         float zoom;
 265 } ViewZoomData;
 266
 267 static void view_zoom_init(bContext *C, wmOperator *op, wmEvent *event)
 268 {
 269         SpaceImage *sima= (SpaceImage*)CTX_wm_space_data(C);
 270         ViewZoomData *vpd;
 271
 272         op->customdata= vpd= MEM_callocN(sizeof(ViewZoomData), "ImageViewZoomData");
 273         WM_cursor_modal(CTX_wm_window(C), BC_NSEW_SCROLLCURSOR);
 274
 275         vpd->x= event->x;
 276         vpd->y= event->y;
 277         vpd->zoom= sima->zoom;
 278
 279         WM_event_add_modal_handler(C, &CTX_wm_window(C)->handlers, op);
 280 }
 281
 282 static void view_zoom_exit(bContext *C, wmOperator *op, int cancel)
 283 {
 284         SpaceImage *sima= (SpaceImage*)CTX_wm_space_data(C);
 285         ViewZoomData *vpd= op->customdata;
 286
 287         if(cancel) {
 288                 sima->zoom= vpd->zoom;
 289                 ED_area_tag_redraw(CTX_wm_area(C));
 290         }
 291
 292         WM_cursor_restore(CTX_wm_window(C));
 293         MEM_freeN(op->customdata);
 294 }
 295
 296 static int view_zoom_exec(bContext *C, wmOperator *op)
 297 {
 298         SpaceImage *sima= (SpaceImage*)CTX_wm_space_data(C);
 299         ARegion *ar= CTX_wm_region(C);
 300
 301         sima_zoom_set_factor(sima, ar, RNA_float_get(op->ptr, "factor"));
 302
 303         ED_area_tag_redraw(CTX_wm_area(C));
 304
 305         /* XXX notifier? */
 306 #if 0
 307         if(image_preview_active(curarea, NULL, NULL)) {
 308                 /* recalculates new preview rect */
 309                 scrarea_do_windraw(curarea);
 310                 image_preview_event(2);
 311         }
 312 #endif
 313
 314         return OPERATOR_FINISHED;
 315 }
 316
 317 static int view_zoom_invoke(bContext *C, wmOperator *op, wmEvent *event)
 318 {
 319         view_zoom_init(C, op, event);
 320         return OPERATOR_RUNNING_MODAL;
 321 }
 322
 323 static int view_zoom_modal(bContext *C, wmOperator *op, wmEvent *event)
 324 {
 325         SpaceImage *sima= (SpaceImage*)CTX_wm_space_data(C);
 326         ARegion *ar= CTX_wm_region(C);
 327         ViewZoomData *vpd= op->customdata;
 328         float factor;
 329
 330         switch(event->type) {
 331                 case MOUSEMOVE:
 332                         factor= 1.0 + (vpd->x-event->x+vpd->y-event->y)/300.0f;
 333                         RNA_float_set(op->ptr, "factor", factor);
 334                         sima_zoom_set(sima, ar, vpd->zoom*factor);
 335                         ED_area_tag_redraw(CTX_wm_area(C));
 336                         break;
 337                 case MIDDLEMOUSE:
 338                         if(event->val==0) {
 339                                 view_zoom_exit(C, op, 0);
 340                                 return OPERATOR_FINISHED;
 341                         }
 342                         break;
 343         }
 344
 345         return OPERATOR_RUNNING_MODAL;
 346 }
 347
 348 static int view_zoom_cancel(bContext *C, wmOperator *op)
 349 {
 350         view_zoom_exit(C, op, 1);
 351         return OPERATOR_CANCELLED;
 352 }
 353
 354 void IMAGE_OT_view_zoom(wmOperatorType *ot)
 355 {
 356         /* identifiers */
 357         ot->name= "View Zoom";
 358         ot->idname= "IMAGE_OT_view_zoom";
 359
 360         /* api callbacks */
 361         ot->exec= view_zoom_exec;
 362         ot->invoke= view_zoom_invoke;
 363         ot->modal= view_zoom_modal;
 364         ot->cancel= view_zoom_cancel;
 365         ot->poll= space_image_main_area_poll;
 366
 367         /* properties */
 368         RNA_def_float(ot->srna, "factor", 0.0f, 0.0f, FLT_MAX,
 369                 "Factor", "Zoom factor, values higher than 1.0 zoom in, lower values zoom out.", -FLT_MAX, FLT_MAX);
 370 }
 371
 372 /********************** view all operator *********************/
 373
 374 /* Updates the fields of the View2D member of the SpaceImage struct.
 375  * Default behavior is to reset the position of the image and set the zoom to 1
 376  * If the image will not fit within the window rectangle, the zoom is adjusted */
 377
 378 static int view_all_exec(bContext *C, wmOperator *op)
 379 {
 380         SpaceImage *sima;
 381         ARegion *ar;
 382         Scene *scene;
 383         Object *obedit;
 384         Image *ima;
 385         ImBuf *ibuf;
 386         float aspx, aspy, zoomx, zoomy, w, h;
 387         int width, height;
 388
 389         /* retrieve state */
 390         sima= (SpaceImage*)CTX_wm_space_data(C);
 391         ar= CTX_wm_region(C);
 392         scene= (Scene*)CTX_data_scene(C);
 393         obedit= CTX_data_edit_object(C);
 394
 395         ima= ED_space_image(sima);
 396         ibuf= ED_space_image_buffer(sima);
 397         ED_space_image_size(sima, &width, &height);
 398         ED_space_image_aspect(sima, &aspx, &aspy);
 399
 400         w= width*aspx;
 401         h= height*aspy;
 402
 403         /* check if the image will fit in the image with zoom==1 */
 404         width = ar->winrct.xmax - ar->winrct.xmin + 1;
 405         height = ar->winrct.ymax - ar->winrct.ymin + 1;
 406
 407         if((w >= width || h >= height) && (width > 0 && height > 0)) {
 408                 /* find the zoom value that will fit the image in the image space */
 409                 zoomx= width/w;
 410                 zoomy= height/h;
 411                 sima_zoom_set(sima, ar, 1.0f/power_of_2(1/MIN2(zoomx, zoomy)));
 412         }
 413         else
 414                 sima_zoom_set(sima, ar, 1.0f);
 415
 416         sima->xof= sima->yof= 0.0f;
 417
 418         ED_area_tag_redraw(CTX_wm_area(C));
 419
 420         return OPERATOR_FINISHED;
 421 }
 422
 423 void IMAGE_OT_view_all(wmOperatorType *ot)
 424 {
 425         /* identifiers */
 426         ot->name= "View All";
 427         ot->idname= "IMAGE_OT_view_all";
 428
 429         /* api callbacks */
 430         ot->exec= view_all_exec;
 431         ot->poll= space_image_main_area_poll;
 432 }
 433
 434 /********************** view selected operator *********************/
 435
 436 static int view_selected_exec(bContext *C, wmOperator *op)
 437 {
 438         SpaceImage *sima;
 439         ARegion *ar;
 440         Scene *scene;
 441         Object *obedit;
 442         Image *ima;
 443         ImBuf *ibuf;
 444         float size, min[2], max[2], d[2];
 445         int width, height;
 446
 447         /* retrieve state */
 448         sima= (SpaceImage*)CTX_wm_space_data(C);
 449         ar= CTX_wm_region(C);
 450         scene= (Scene*)CTX_data_scene(C);
 451         obedit= CTX_data_edit_object(C);
 452
 453         ima= ED_space_image(sima);
 454         ibuf= ED_space_image_buffer(sima);
 455         ED_space_image_size(sima, &width, &height);
 456
 457         /* get bounds */
 458         if(!ED_uvedit_minmax(scene, ima, obedit, min, max))
 459                 return OPERATOR_CANCELLED;
 460
 461         /* adjust offset and zoom */
 462         sima->xof= (int)(((min[0] + max[0])*0.5f - 0.5f)*width);
 463         sima->yof= (int)(((min[1] + max[1])*0.5f - 0.5f)*height);
 464
 465         d[0]= max[0] - min[0];
 466         d[1]= max[1] - min[1];
 467         size= 0.5*MAX2(d[0], d[1])*MAX2(width, height)/256.0f;
 468
 469         if(size<=0.01) size= 0.01;
 470         sima_zoom_set(sima, ar, 0.7/size);
 471
 472         ED_area_tag_redraw(CTX_wm_area(C));
 473
 474         return OPERATOR_FINISHED;
 475 }
 476
 477 void IMAGE_OT_view_selected(wmOperatorType *ot)
 478 {
 479         /* identifiers */
 480         ot->name= "View Center";
 481         ot->idname= "IMAGE_OT_view_selected";
 482
 483         /* api callbacks */
 484         ot->exec= view_selected_exec;
 485         ot->poll= ED_operator_uvedit;
 486 }
 487
 488 /********************** view zoom in/out operator *********************/
 489
 490 static int view_zoom_in_exec(bContext *C, wmOperator *op)
 491 {
 492         SpaceImage *sima= (SpaceImage*)CTX_wm_space_data(C);
 493         ARegion *ar= CTX_wm_region(C);
 494
 495         sima_zoom_set_factor(sima, ar, 1.25f);
 496
 497         ED_area_tag_redraw(CTX_wm_area(C));
 498
 499         return OPERATOR_FINISHED;
 500 }
 501
 502 void IMAGE_OT_view_zoom_in(wmOperatorType *ot)
 503 {
 504         /* identifiers */
 505         ot->name= "View Zoom In";
 506         ot->idname= "IMAGE_OT_view_zoom_in";
 507
 508         /* api callbacks */
 509         ot->exec= view_zoom_in_exec;
 510         ot->poll= space_image_main_area_poll;
 511 }
 512
 513 static int view_zoom_out_exec(bContext *C, wmOperator *op)
 514 {
 515         SpaceImage *sima= (SpaceImage*)CTX_wm_space_data(C);
 516         ARegion *ar= CTX_wm_region(C);
 517
 518         sima_zoom_set_factor(sima, ar, 0.8f);
 519
 520         ED_area_tag_redraw(CTX_wm_area(C));
 521
 522         return OPERATOR_FINISHED;
 523 }
 524
 525 void IMAGE_OT_view_zoom_out(wmOperatorType *ot)
 526 {
 527         /* identifiers */
 528         ot->name= "View Zoom Out";
 529         ot->idname= "IMAGE_OT_view_zoom_out";
 530
 531         /* api callbacks */
 532         ot->exec= view_zoom_out_exec;
 533         ot->poll= space_image_main_area_poll;
 534 }
 535
 536 /********************** view zoom ratio operator *********************/
 537
 538 static int view_zoom_ratio_exec(bContext *C, wmOperator *op)
 539 {
 540         SpaceImage *sima= (SpaceImage*)CTX_wm_space_data(C);
 541         ARegion *ar= CTX_wm_region(C);
 542
 543         sima_zoom_set(sima, ar, RNA_float_get(op->ptr, "ratio"));
 544
 545         /* ensure pixel exact locations for draw */
 546         sima->xof= (int)sima->xof;
 547         sima->yof= (int)sima->yof;
 548
 549         /* XXX notifier? */
 550 #if 0
 551         if(image_preview_active(curarea, NULL, NULL)) {
 552                 /* recalculates new preview rect */
 553                 scrarea_do_windraw(curarea);
 554                 image_preview_event(2);
 555         }
 556 #endif
 557
 558         ED_area_tag_redraw(CTX_wm_area(C));
 559
 560         return OPERATOR_FINISHED;
 561 }
 562
 563 void IMAGE_OT_view_zoom_ratio(wmOperatorType *ot)
 564 {
 565         /* identifiers */
 566         ot->name= "View Zoom Ratio";
 567         ot->idname= "IMAGE_OT_view_zoom_ratio";
 568
 569         /* api callbacks */
 570         ot->exec= view_zoom_ratio_exec;
 571         ot->poll= space_image_main_area_poll;
 572
 573         /* properties */
 574         RNA_def_float(ot->srna, "ratio", 0.0f, 0.0f, FLT_MAX,
 575                 "Ratio", "Zoom ratio, 1.0 is 1:1, higher is zoomed in, lower is zoomed out.", -FLT_MAX, FLT_MAX);
 576 }
 577
 578 /**************** load/replace/save callbacks ******************/
 579
 580 /* XXX make dynamic */
 581 static const EnumPropertyItem image_file_type_items[] = {
 582                 {R_TARGA, "TARGA", 0, "Targa", ""},
 583                 {R_RAWTGA, "TARGA RAW", 0, "Targa Raw", ""},
 584                 {R_PNG, "PNG", 0, "PNG", ""},
 585                 {R_BMP, "BMP", 0, "BMP", ""},
 586                 {R_JPEG90, "JPEG", 0, "Jpeg", ""},
 587 #ifdef WITH_OPENJPEG
 588                 {R_JP2, "JPEG_2000", 0, "Jpeg 2000", ""},
 589 #endif
 590                 {R_IRIS, "IRIS", 0, "Iris", ""},
 591         //if(G.have_libtiff)
 592                 {R_TIFF, "TIFF", 0, "Tiff", ""},
 593                 {R_RADHDR, "RADIANCE_HDR", 0, "Radiance HDR", ""},
 594                 {R_CINEON, "CINEON", 0, "Cineon", ""},
 595                 {R_DPX, "DPX", 0, "DPX", ""},
 596 #ifdef WITH_OPENEXR
 597                 {R_OPENEXR, "OPENEXR", 0, "OpenEXR", ""},
 598         /* saving sequences of multilayer won't work, they copy buffers  */
 599         /*if(ima->source==IMA_SRC_SEQUENCE && ima->type==IMA_TYPE_MULTILAYER);
 600         else*/
 601                 {R_MULTILAYER, "MULTILAYER", 0, "MultiLayer", ""},
 602 #endif
 603                 {0, NULL, 0, NULL, NULL}};
 604
 605 static void image_filesel(bContext *C, wmOperator *op, const char *path)
 606 {
 607         RNA_string_set(op->ptr, "filename", path);
 608         WM_event_add_fileselect(C, op);
 609 }
 610
 611 /******************** open image operator ********************/
 612
 613 static int open_exec(bContext *C, wmOperator *op)
 614 {
 615         SpaceImage *sima= (SpaceImage*)CTX_wm_space_data(C);
 616         Scene *scene= CTX_data_scene(C);
 617         Object *obedit= CTX_data_edit_object(C);
 618         Image *ima= NULL;
 619         char str[FILE_MAX];
 620
 621         RNA_string_get(op->ptr, "filename", str);
 622         ima= BKE_add_image_file(str, scene->r.cfra);
 623
 624         if(!ima)
 625                 return OPERATOR_CANCELLED;
 626
 627         BKE_image_signal(ima, &sima->iuser, IMA_SIGNAL_RELOAD);
 628         ED_space_image_set(C, sima, scene, obedit, ima);
 629
 630         return OPERATOR_FINISHED;
 631 }
 632
 633 static int open_invoke(bContext *C, wmOperator *op, wmEvent *event)
 634 {
 635         SpaceImage *sima= (SpaceImage*)CTX_wm_space_data(C);
 636         char *path= (sima->image)? sima->image->name: U.textudir;
 637
 638         if(RNA_property_is_set(op->ptr, "filename"))
 639                 return open_exec(C, op);
 640
 641         image_filesel(C, op, path);
 642
 643         return OPERATOR_RUNNING_MODAL;
 644 }
 645
 646 void IMAGE_OT_open(wmOperatorType *ot)
 647 {
 648         /* identifiers */
 649         ot->name= "Open";
 650         ot->idname= "IMAGE_OT_open";
 651
 652         /* api callbacks */
 653         ot->exec= open_exec;
 654         ot->invoke= open_invoke;
 655         ot->poll= ED_operator_image_active;
 656
 657         /* flags */
 658         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
 659
 660         /* properties */
 661         RNA_def_string_file_path(ot->srna, "filename", "", FILE_MAX, "Filename", "File path of image to open.");
 662 }
 663
 664 /******************** replace image operator ********************/
 665
 666 static int replace_exec(bContext *C, wmOperator *op)
 667 {
 668         SpaceImage *sima= (SpaceImage*)CTX_wm_space_data(C);
 669         char str[FILE_MAX];
 670
 671         if(!sima->image)
 672                 return OPERATOR_CANCELLED;
 673
 674         RNA_string_get(op->ptr, "filename", str);
 675         BLI_strncpy(sima->image->name, str, sizeof(sima->image->name)-1); /* we cant do much if the str is longer then 240 :/ */
 676
 677         BKE_image_signal(sima->image, &sima->iuser, IMA_SIGNAL_RELOAD);
 678         WM_event_add_notifier(C, NC_IMAGE|NA_EDITED, sima->image);
 679
 680         return OPERATOR_FINISHED;
 681 }
 682
 683 static int replace_invoke(bContext *C, wmOperator *op, wmEvent *event)
 684 {
 685         SpaceImage *sima= (SpaceImage*)CTX_wm_space_data(C);
 686         char *path= (sima->image)? sima->image->name: U.textudir;
 687
 688         if(!sima->image)
 689                 return OPERATOR_CANCELLED;
 690
 691         if(RNA_property_is_set(op->ptr, "filename"))
 692                 return replace_exec(C, op);
 693
 694         image_filesel(C, op, path);
 695
 696         return OPERATOR_RUNNING_MODAL;
 697 }
 698
 699 void IMAGE_OT_replace(wmOperatorType *ot)
 700 {
 701         /* identifiers */
 702         ot->name= "Replace";
 703         ot->idname= "IMAGE_OT_replace";
 704
 705         /* api callbacks */
 706         ot->exec= replace_exec;
 707         ot->invoke= replace_invoke;
 708         ot->poll= space_image_poll;
 709
 710         /* flags */
 711         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
 712
 713         /* properties */
 714         RNA_def_string_file_path(ot->srna, "filename", "", FILE_MAX, "Filename", "File path of image to replace current image with.");
 715 }
 716
 717 /******************** save image as operator ********************/
 718
 719 /* assumes name is FILE_MAX */
 720 /* ima->name and ibuf->name should end up the same */
 721 static void save_image_doit(bContext *C, SpaceImage *sima, Scene *scene, wmOperator *op, char *name)
 722 {
 723         Image *ima= ED_space_image(sima);
 724         ImBuf *ibuf= ED_space_image_buffer(sima);
 725         int len;
 726
 727         if (ibuf) {
 728                 BLI_convertstringcode(name, G.sce);
 729                 BLI_convertstringframe(name, scene->r.cfra);
 730
 731                 if(scene->r.scemode & R_EXTENSION)  {
 732                         BKE_add_image_extension(scene, name, sima->imtypenr);
 733                         BKE_add_image_extension(scene, name, sima->imtypenr);
 734                 }
 735
 736                 /* enforce user setting for RGB or RGBA, but skip BW */
 737                 if(scene->r.planes==32)
 738                         ibuf->depth= 32;
 739                 else if(scene->r.planes==24)
 740                         ibuf->depth= 24;
 741
 742                 WM_cursor_wait(1);
 743
 744                 if(sima->imtypenr==R_MULTILAYER) {
 745                         RenderResult *rr= BKE_image_get_renderresult(scene, ima);
 746                         if(rr) {
 747                                 RE_WriteRenderResult(rr, name, scene->r.quality);
 748
 749                                 BLI_strncpy(ima->name, name, sizeof(ima->name));
 750                                 BLI_strncpy(ibuf->name, name, sizeof(ibuf->name));
 751
 752                                 /* should be function? nevertheless, saving only happens here */
 753                                 for(ibuf= ima->ibufs.first; ibuf; ibuf= ibuf->next)
 754                                         ibuf->userflags &= ~IB_BITMAPDIRTY;
 755
 756                         }
 757                         else
 758                                 BKE_report(op->reports, RPT_ERROR, "Did not write, no Multilayer Image");
 759                 }
 760                 else if (BKE_write_ibuf(scene, ibuf, name, sima->imtypenr, scene->r.subimtype, scene->r.quality)) {
 761                         BLI_strncpy(ima->name, name, sizeof(ima->name));
 762                         BLI_strncpy(ibuf->name, name, sizeof(ibuf->name));
 763
 764                         ibuf->userflags &= ~IB_BITMAPDIRTY;
 765
 766                         /* change type? */
 767                         if( ELEM(ima->source, IMA_SRC_GENERATED, IMA_SRC_VIEWER)) {
 768                                 ima->source= IMA_SRC_FILE;
 769                                 ima->type= IMA_TYPE_IMAGE;
 770                         }
 771                         if(ima->type==IMA_TYPE_R_RESULT)
 772                                 ima->type= IMA_TYPE_IMAGE;
 773
 774                         /* name image as how we saved it */
 775                         len= strlen(name);
 776                         while (len > 0 && name[len - 1] != '/' && name[len - 1] != '\\') len--;
 777                         rename_id(&ima->id, name+len);
 778                 }
 779                 else
 780                         BKE_reportf(op->reports, RPT_ERROR, "Couldn't write image: %s", name);
 781
 782                 WM_event_add_notifier(C, NC_IMAGE|NA_EDITED, sima->image);
 783
 784                 WM_cursor_wait(0);
 785         }
 786 }
 787
 788 static int save_as_exec(bContext *C, wmOperator *op)
 789 {
 790         SpaceImage *sima= (SpaceImage*)CTX_wm_space_data(C);
 791         Scene *scene= CTX_data_scene(C);
 792         Image *ima = ED_space_image(sima);
 793         char str[FILE_MAX];
 794
 795         if(!ima)
 796                 return OPERATOR_CANCELLED;
 797
 798         sima->imtypenr= RNA_enum_get(op->ptr, "file_type");
 799         RNA_string_get(op->ptr, "filename", str);
 800
 801         save_image_doit(C, sima, scene, op, str);
 802
 803         return OPERATOR_FINISHED;
 804 }
 805
 806 static int save_as_invoke(bContext *C, wmOperator *op, wmEvent *event)
 807 {
 808         SpaceImage *sima= (SpaceImage*)CTX_wm_space_data(C);
 809         Image *ima = ED_space_image(sima);
 810         ImBuf *ibuf= ED_space_image_buffer(sima);
 811         Scene *scene= CTX_data_scene(C);
 812
 813         if(RNA_property_is_set(op->ptr, "filename"))
 814                 return save_as_exec(C, op);
 815
 816         if(!ima)
 817                 return OPERATOR_CANCELLED;
 818
 819         /* always opens fileselect */
 820         if(ibuf) {
 821                 /* cant save multilayer sequence, ima->rr isn't valid for a specific frame */
 822                 if(ima->rr && !(ima->source==IMA_SRC_SEQUENCE && ima->type==IMA_TYPE_MULTILAYER))
 823                         sima->imtypenr= R_MULTILAYER;
 824                 else if(ima->type==IMA_TYPE_R_RESULT)
 825                         sima->imtypenr= scene->r.imtype;
 826                 else
 827                         sima->imtypenr= BKE_ftype_to_imtype(ibuf->ftype);
 828
 829                 RNA_enum_set(op->ptr, "file_type", sima->imtypenr);
 830
 831                 if(ibuf->name[0]==0)
 832                         BLI_strncpy(ibuf->name, G.ima, FILE_MAX);
 833
 834                 // XXX note: we can give default menu enums to operator for this
 835                 image_filesel(C, op, ibuf->name);
 836
 837                 return OPERATOR_RUNNING_MODAL;
 838         }
 839
 840         return OPERATOR_CANCELLED;
 841 }
 842
 843 void IMAGE_OT_save_as(wmOperatorType *ot)
 844 {
 845         /* identifiers */
 846         ot->name= "Save As";
 847         ot->idname= "IMAGE_OT_save_as";
 848
 849         /* api callbacks */
 850         ot->exec= save_as_exec;
 851         ot->invoke= save_as_invoke;
 852         ot->poll= space_image_poll;
 853
 854         /* flags */
 855         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
 856
 857         /* properties */
 858         RNA_def_string_file_path(ot->srna, "filename", "", FILE_MAX, "Filename", "File path to save image to.");
 859         RNA_def_enum(ot->srna, "file_type", image_file_type_items, R_PNG, "File Type", "File type to save image as.");
 860 }
 861
 862 /******************** save image operator ********************/
 863
 864 static int save_exec(bContext *C, wmOperator *op)
 865 {
 866         SpaceImage *sima= (SpaceImage*)CTX_wm_space_data(C);
 867         Image *ima = ED_space_image(sima);
 868         ImBuf *ibuf= ED_space_image_buffer(sima);
 869         Scene *scene= CTX_data_scene(C);
 870         char name[FILE_MAX];
 871
 872         if(!ima || !ibuf)
 873                 return OPERATOR_CANCELLED;
 874
 875         /* if exists, saves over without fileselect */
 876
 877         BLI_strncpy(name, ibuf->name, FILE_MAX);
 878         if(name[0]==0)
 879                 BLI_strncpy(name, G.ima, FILE_MAX);
 880
 881         if(BLI_exists(name) && BLI_is_writable(name)) {
 882                 if(BKE_image_get_renderresult(scene, ima))
 883                         sima->imtypenr= R_MULTILAYER;
 884                 else
 885                         sima->imtypenr= BKE_ftype_to_imtype(ibuf->ftype);
 886
 887                 save_image_doit(C, sima, scene, op, name);
 888         }
 889         else {
 890                 BKE_report(op->reports, RPT_ERROR, "Can not save image.");
 891                 return OPERATOR_CANCELLED;
 892         }
 893
 894         return OPERATOR_FINISHED;
 895 }
 896
 897 void IMAGE_OT_save(wmOperatorType *ot)
 898 {
 899         /* identifiers */
 900         ot->name= "Save";
 901         ot->idname= "IMAGE_OT_save";
 902
 903         /* api callbacks */
 904         ot->exec= save_exec;
 905         ot->poll= space_image_file_exists_poll;
 906
 907         /* flags */
 908         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
 909 }
 910
 911 /******************* save sequence operator ********************/
 912
 913 static int save_sequence_exec(bContext *C, wmOperator *op)
 914 {
 915         SpaceImage *sima= (SpaceImage*)CTX_wm_space_data(C);
 916         ImBuf *ibuf;
 917         int tot= 0;
 918         char di[FILE_MAX], fi[FILE_MAX];
 919
 920         if(sima->image==NULL)
 921                 return OPERATOR_CANCELLED;
 922
 923         if(sima->image->source!=IMA_SRC_SEQUENCE) {
 924                 BKE_report(op->reports, RPT_ERROR, "Can only save sequence on image sequences.");
 925                 return OPERATOR_CANCELLED;
 926         }
 927
 928         if(sima->image->type==IMA_TYPE_MULTILAYER) {
 929                 BKE_report(op->reports, RPT_ERROR, "Can't save multilayer sequences.");
 930                 return OPERATOR_CANCELLED;
 931         }
 932
 933         /* get total */
 934         for(ibuf= sima->image->ibufs.first; ibuf; ibuf= ibuf->next)
 935                 if(ibuf->userflags & IB_BITMAPDIRTY)
 936                         tot++;
 937
 938         if(tot==0) {
 939                 BKE_report(op->reports, RPT_WARNING, "No images have been changed.");
 940                 return OPERATOR_CANCELLED;
 941         }
 942
 943         /* get a filename for menu */
 944         for(ibuf= sima->image->ibufs.first; ibuf; ibuf= ibuf->next)
 945                 if(ibuf->userflags & IB_BITMAPDIRTY)
 946                         break;
 947
 948         BLI_strncpy(di, ibuf->name, FILE_MAX);
 949         BLI_splitdirstring(di, fi);
 950
 951         BKE_reportf(op->reports, RPT_INFO, "%d Image(s) will be saved in %s", tot, di);
 952
 953         for(ibuf= sima->image->ibufs.first; ibuf; ibuf= ibuf->next) {
 954                 if(ibuf->userflags & IB_BITMAPDIRTY) {
 955                         char name[FILE_MAX];
 956                         BLI_strncpy(name, ibuf->name, sizeof(name));
 957
 958                         BLI_convertstringcode(name, G.sce);
 959
 960                         if(0 == IMB_saveiff(ibuf, name, IB_rect | IB_zbuf | IB_zbuffloat)) {
 961                                 BKE_reportf(op->reports, RPT_ERROR, "Could not write image %s.", name);
 962                                 break;
 963                         }
 964
 965                         printf("Saved: %s\n", ibuf->name);
 966                         ibuf->userflags &= ~IB_BITMAPDIRTY;
 967                 }
 968         }
 969
 970         return OPERATOR_FINISHED;
 971 }
 972
 973 void IMAGE_OT_save_sequence(wmOperatorType *ot)
 974 {
 975         /* identifiers */
 976         ot->name= "Save Sequence";
 977         ot->idname= "IMAGE_OT_save_sequence";
 978
 979         /* api callbacks */
 980         ot->exec= save_sequence_exec;
 981         ot->poll= space_image_poll;
 982
 983         /* flags */
 984         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
 985 }
 986
 987 /******************** reload image operator ********************/
 988
 989 static int reload_exec(bContext *C, wmOperator *op)
 990 {
 991         SpaceImage *sima;
 992
 993         /* retrieve state */
 994         sima= (SpaceImage*)CTX_wm_space_data(C);
 995
 996         if(!sima->image)
 997                 return OPERATOR_CANCELLED;
 998
 999         BKE_image_signal(sima->image, &sima->iuser, IMA_SIGNAL_RELOAD);
1000         /* ED_space_image_set(C, sima, scene, obedit, NULL); - do we really need this? */
1001
1002         // XXX BIF_preview_changed(ID_TE);
1003         WM_event_add_notifier(C, NC_IMAGE|NA_EDITED, sima->image);
1004         ED_area_tag_redraw(CTX_wm_area(C));
1005
1006         return OPERATOR_FINISHED;
1007 }
1008
1009 void IMAGE_OT_reload(wmOperatorType *ot)
1010 {
1011         /* identifiers */
1012         ot->name= "Reload";
1013         ot->idname= "IMAGE_OT_reload";
1014
1015         /* api callbacks */
1016         ot->exec= reload_exec;
1017         ot->poll= space_image_poll;
1018
1019         /* flags */
1020         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
1021 }
1022
1023 /********************** new image operator *********************/
1024
1025 static int new_exec(bContext *C, wmOperator *op)
1026 {
1027         SpaceImage *sima;
1028         Scene *scene;
1029         Object *obedit;
1030         Image *ima;
1031         char name[22];
1032         float color[4];
1033         int width, height, floatbuf, uvtestgrid;
1034
1035         /* retrieve state */
1036         sima= (SpaceImage*)CTX_wm_space_data(C);
1037         scene= (Scene*)CTX_data_scene(C);
1038         obedit= CTX_data_edit_object(C);
1039
1040         RNA_string_get(op->ptr, "name", name);
1041         width= RNA_int_get(op->ptr, "width");
1042         height= RNA_int_get(op->ptr, "height");
1043         floatbuf= RNA_boolean_get(op->ptr, "float");
1044         uvtestgrid= RNA_boolean_get(op->ptr, "uv_test_grid");
1045         RNA_float_get_array(op->ptr, "color", color);
1046         color[3]= RNA_float_get(op->ptr, "alpha");
1047
1048         ima = BKE_add_image_size(width, height, name, floatbuf, uvtestgrid, color);
1049         BKE_image_signal(sima->image, &sima->iuser, IMA_SIGNAL_USER_NEW_IMAGE);
1050         ED_space_image_set(C, sima, scene, obedit, ima);
1051
1052         return OPERATOR_FINISHED;
1053 }
1054
1055 void IMAGE_OT_new(wmOperatorType *ot)
1056 {
1057         /* identifiers */
1058         ot->name= "New";
1059         ot->idname= "IMAGE_OT_new";
1060
1061         /* api callbacks */
1062         ot->exec= new_exec;
1063         ot->invoke= WM_operator_redo;
1064         ot->poll= ED_operator_image_active;
1065
1066         /* flags */
1067         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
1068
1069         /* properties */
1070         RNA_def_string(ot->srna, "name", "Untitled", 21, "Name", "Image datablock name.");
1071         RNA_def_int(ot->srna, "width", 1024, 1, INT_MAX, "Width", "Image width.", 1, 16384);
1072         RNA_def_int(ot->srna, "height", 1024, 1, INT_MAX, "Height", "Image height.", 1, 16384);
1073         RNA_def_float_color(ot->srna, "color", 3, NULL, 0.0f, FLT_MAX, "Color", "Default fill color.", 0.0f, 1.0f);
1074         RNA_def_float(ot->srna, "alpha", 1.0f, 0.0f, 1.0f, "Alpha", "Default fill alpha.", 0.0f, 1.0f);
1075         RNA_def_boolean(ot->srna, "uv_test_grid", 0, "UV Test Grid", "Fill the image with a grid for UV map testing.");
1076         RNA_def_boolean(ot->srna, "float", 0, "32 bit Float", "Create image with 32 bit floating point bit depth.");
1077 }
1078
1079 /********************* pack operator *********************/
1080
1081 static int pack_test(bContext *C, wmOperator *op)
1082 {
1083         Image *ima= CTX_data_edit_image(C);
1084         int as_png= RNA_boolean_get(op->ptr, "as_png");
1085
1086         if(!ima)
1087                 return 0;
1088         if(!as_png && ima->packedfile)
1089                 return 0;
1090
1091         if(ima->source==IMA_SRC_SEQUENCE || ima->source==IMA_SRC_MOVIE) {
1092                 BKE_report(op->reports, RPT_ERROR, "Can't pack movie or image sequence.");
1093                 return 0;
1094         }
1095
1096         return 1;
1097 }
1098
1099 static int pack_exec(bContext *C, wmOperator *op)
1100 {
1101         SpaceImage *sima= (SpaceImage*)CTX_wm_space_data(C);
1102         Image *ima= ED_space_image(sima);
1103         ImBuf *ibuf= ED_space_image_buffer(sima);
1104         int as_png= RNA_boolean_get(op->ptr, "as_png");
1105
1106         if(!pack_test(C, op))
1107                 return OPERATOR_CANCELLED;
1108
1109         if(!as_png && (ibuf && (ibuf->userflags & IB_BITMAPDIRTY))) {
1110                 BKE_report(op->reports, RPT_ERROR, "Can't pack edited image from disk, only as internal PNG.");
1111                 return OPERATOR_CANCELLED;
1112         }
1113
1114         if(as_png)
1115                 BKE_image_memorypack(ima);
1116         else
1117                 ima->packedfile= newPackedFile(ima->name);
1118
1119         return OPERATOR_FINISHED;
1120 }
1121
1122 static int pack_invoke(bContext *C, wmOperator *op, wmEvent *event)
1123 {
1124         SpaceImage *sima= (SpaceImage*)CTX_wm_space_data(C);
1125         ImBuf *ibuf= ED_space_image_buffer(sima);
1126         uiPopupMenu *pup;
1127         uiLayout *layout;
1128         int as_png= RNA_boolean_get(op->ptr, "as_png");
1129
1130         if(!pack_test(C, op))
1131                 return OPERATOR_CANCELLED;
1132
1133         if(!as_png && (ibuf && (ibuf->userflags & IB_BITMAPDIRTY))) {
1134                 pup= uiPupMenuBegin(C, "OK", ICON_QUESTION);
1135                 layout= uiPupMenuLayout(pup);
1136                 uiItemBooleanO(layout, "Can't pack edited image from disk. Pack as internal PNG?", 0, op->idname, "as_png", 1);
1137                 uiPupMenuEnd(C, pup);
1138
1139                 return OPERATOR_CANCELLED;
1140         }
1141
1142         return pack_exec(C, op);
1143 }
1144
1145 void IMAGE_OT_pack(wmOperatorType *ot)
1146 {
1147         /* identifiers */
1148         ot->name= "Pack";
1149         ot->idname= "IMAGE_OT_pack";
1150
1151         /* api callbacks */
1152         ot->exec= pack_exec;
1153         ot->invoke= pack_invoke;
1154         ot->poll= space_image_poll;
1155
1156         /* flags */
1157         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
1158
1159         /* properties */
1160         RNA_def_boolean(ot->srna, "as_png", 0, "Pack As PNG", "Pack image as lossless PNG.");
1161 }
1162
1163 /********************* unpack operator *********************/
1164
1165 static int unpack_exec(bContext *C, wmOperator *op)
1166 {
1167         Image *ima= CTX_data_edit_image(C);
1168
1169         if(!ima)
1170                 return OPERATOR_CANCELLED;
1171         if(!ima->packedfile)
1172                 return OPERATOR_CANCELLED;
1173
1174         if(ima->source==IMA_SRC_SEQUENCE || ima->source==IMA_SRC_MOVIE) {
1175                 BKE_report(op->reports, RPT_ERROR, "Can't unpack movie or image sequence.");
1176                 return OPERATOR_CANCELLED;
1177         }
1178
1179         if(G.fileflags & G_AUTOPACK)
1180                 BKE_report(op->reports, RPT_WARNING, "AutoPack is enabled, so image will be packed again on file save.");
1181
1182         unpackImage(ima, PF_ASK);
1183
1184         return OPERATOR_FINISHED;
1185 }
1186
1187 void IMAGE_OT_unpack(wmOperatorType *ot)
1188 {
1189         /* identifiers */
1190         ot->name= "Unpack";
1191         ot->idname= "IMAGE_OT_unpack";
1192
1193         /* api callbacks */
1194         ot->exec= unpack_exec;
1195         ot->poll= space_image_poll;
1196
1197         /* flags */
1198         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
1199 }
1200
1201 /******************** sample image operator ********************/
1202
1203 typedef struct ImageSampleInfo {
1204         ARegionType *art;
1205         void *draw_handle;
1206         int x, y;
1207
1208         char col[4];
1209         float colf[4];
1210         int z;
1211         float zf;
1212
1213         char *colp;
1214         float *colfp;
1215         int *zp;
1216         float *zfp;
1217
1218         int draw;
1219 } ImageSampleInfo;
1220
1221 static void sample_draw(const bContext *C, ARegion *ar, void *arg_info)
1222 {
1223         SpaceImage *sima= (SpaceImage*)CTX_wm_space_data(C);
1224         ImBuf *ibuf= ED_space_image_buffer(sima);
1225         ImageSampleInfo *info= arg_info;
1226
1227         if(ibuf == NULL)
1228                 return;
1229
1230         draw_image_info(ar, ibuf->channels, info->x, info->y, info->colp,
1231                 info->colfp, info->zp, info->zfp);
1232 }
1233
1234 static void sample_apply(bContext *C, wmOperator *op, wmEvent *event)
1235 {
1236         SpaceImage *sima= (SpaceImage*)CTX_wm_space_data(C);
1237         ARegion *ar= CTX_wm_region(C);
1238         ImBuf *ibuf= ED_space_image_buffer(sima);
1239         ImageSampleInfo *info= op->customdata;
1240         float fx, fy;
1241         int x, y;
1242
1243         if(ibuf == NULL)
1244                 return;
1245
1246         x= event->x - ar->winrct.xmin;
1247         y= event->y - ar->winrct.ymin;
1248         UI_view2d_region_to_view(&ar->v2d, x, y, &fx, &fy);
1249
1250         if(fx>=0.0 && fy>=0.0 && fx<1.0 && fy<1.0) {
1251                 float *fp;
1252                 char *cp;
1253                 int x= (int)(fx*ibuf->x), y= (int)(fy*ibuf->y);
1254
1255                 CLAMP(x, 0, ibuf->x-1);
1256                 CLAMP(y, 0, ibuf->y-1);
1257
1258                 info->x= x;
1259                 info->y= y;
1260                 info->draw= 1;
1261
1262                 info->colp= NULL;
1263                 info->colfp= NULL;
1264                 info->zp= NULL;
1265                 info->zfp= NULL;
1266
1267                 if(ibuf->rect) {
1268                         cp= (char *)(ibuf->rect + y*ibuf->x + x);
1269
1270                         info->col[0]= cp[0];
1271                         info->col[1]= cp[1];
1272                         info->col[2]= cp[2];
1273                         info->col[3]= cp[3];
1274                         info->colp= info->col;
1275
1276                         info->colf[0]= (float)cp[0]/255.0f;
1277                         info->colf[1]= (float)cp[1]/255.0f;
1278                         info->colf[2]= (float)cp[2]/255.0f;
1279                         info->colf[3]= (float)cp[3]/255.0f;
1280                         info->colfp= info->colf;
1281                 }
1282                 if(ibuf->rect_float) {
1283                         fp= (ibuf->rect_float + (ibuf->channels)*(y*ibuf->x + x));
1284
1285                         info->colf[0]= fp[0];
1286                         info->colf[1]= fp[1];
1287                         info->colf[2]= fp[2];
1288                         info->colf[3]= fp[4];
1289                         info->colfp= info->colf;
1290                 }
1291
1292                 if(ibuf->zbuf) {
1293                         info->z= ibuf->zbuf[y*ibuf->x + x];
1294                         info->zp= &info->z;
1295                 }
1296                 if(ibuf->zbuf_float) {
1297                         info->zf= ibuf->zbuf_float[y*ibuf->x + x];
1298                         info->zfp= &info->zf;
1299                 }
1300
1301                 if(sima->cumap && ibuf->channels==4) {
1302                         /* we reuse this callback for set curves point operators */
1303                         if(RNA_struct_find_property(op->ptr, "point")) {
1304                                 int point= RNA_enum_get(op->ptr, "point");
1305
1306                                 if(point == 1) {
1307                                         curvemapping_set_black_white(sima->cumap, NULL, info->colfp);
1308                                         curvemapping_do_ibuf(sima->cumap, ibuf);
1309                                 }
1310                                 else if(point == 0) {
1311                                         curvemapping_set_black_white(sima->cumap, info->colfp, NULL);
1312                                         curvemapping_do_ibuf(sima->cumap, ibuf);
1313                                 }
1314                         }
1315                 }
1316
1317                 // XXX node curve integration ..
1318 #if 0
1319                 {
1320                         ScrArea *sa, *cur= curarea;
1321
1322                         node_curvemap_sample(fp);       /* sends global to node editor */
1323                         for(sa= G.curscreen->areabase.first; sa; sa= sa->next) {
1324                                 if(sa->spacetype==SPACE_NODE) {
1325                                         areawinset(sa->win);
1326                                         scrarea_do_windraw(sa);
1327                                 }
1328                         }
1329                         node_curvemap_sample(NULL);             /* clears global in node editor */
1330                         curarea= cur;
1331                 }
1332 #endif
1333         }
1334         else
1335                 info->draw= 0;
1336
1337         ED_area_tag_redraw(CTX_wm_area(C));
1338 }
1339
1340 static void sample_exit(bContext *C, wmOperator *op)
1341 {
1342         ImageSampleInfo *info= op->customdata;
1343
1344         ED_region_draw_cb_exit(info->art, info->draw_handle);
1345         ED_area_tag_redraw(CTX_wm_area(C));
1346         MEM_freeN(info);
1347 }
1348
1349 static int sample_invoke(bContext *C, wmOperator *op, wmEvent *event)
1350 {
1351         SpaceImage *sima= (SpaceImage*)CTX_wm_space_data(C);
1352         ARegion *ar= CTX_wm_region(C);
1353         ImBuf *ibuf= ED_space_image_buffer(sima);
1354         ImageSampleInfo *info;
1355
1356         if(ibuf == NULL)
1357                 return OPERATOR_CANCELLED;
1358
1359         info= MEM_callocN(sizeof(ImageSampleInfo), "ImageSampleInfo");
1360         info->art= ar->type;
1361         info->draw_handle = ED_region_draw_cb_activate(ar->type, sample_draw, info, REGION_DRAW_POST);
1362         op->customdata= info;
1363
1364         sample_apply(C, op, event);
1365
1366         WM_event_add_modal_handler(C, &CTX_wm_window(C)->handlers, op);
1367
1368         return OPERATOR_RUNNING_MODAL;
1369 }
1370
1371 static int sample_modal(bContext *C, wmOperator *op, wmEvent *event)
1372 {
1373         switch(event->type) {
1374                 case LEFTMOUSE:
1375                 case RIGHTMOUSE: // XXX hardcoded
1376                         sample_exit(C, op);
1377                         return OPERATOR_CANCELLED;
1378                 case MOUSEMOVE:
1379                         sample_apply(C, op, event);
1380                         break;
1381         }
1382
1383         return OPERATOR_RUNNING_MODAL;
1384 }
1385
1386 static int sample_cancel(bContext *C, wmOperator *op)
1387 {
1388         sample_exit(C, op);
1389         return OPERATOR_CANCELLED;
1390 }
1391
1392 void IMAGE_OT_sample(wmOperatorType *ot)
1393 {
1394         /* identifiers */
1395         ot->name= "Sample";
1396         ot->idname= "IMAGE_OT_sample";
1397
1398         /* api callbacks */
1399         ot->invoke= sample_invoke;
1400         ot->modal= sample_modal;
1401         ot->cancel= sample_cancel;
1402         ot->poll= space_image_main_area_poll;
1403 }
1404
1405 /******************** set curve point operator ********************/
1406
1407 void IMAGE_OT_curves_point_set(wmOperatorType *ot)
1408 {
1409         static EnumPropertyItem point_items[]= {
1410                 {0, "BLACK_POINT", 0, "Black Point", ""},
1411                 {1, "WHITE_POINT", 0, "White Point", ""},
1412                 {0, NULL, 0, NULL, NULL}};
1413
1414         /* identifiers */
1415         ot->name= "Set Curves Point";
1416         ot->idname= "IMAGE_OT_curves_point_set";
1417
1418         /* flags */
1419         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
1420
1421         /* api callbacks */
1422         ot->invoke= sample_invoke;
1423         ot->modal= sample_modal;
1424         ot->cancel= sample_cancel;
1425         ot->poll= space_image_main_area_poll;
1426
1427         /* properties */
1428         RNA_def_enum(ot->srna, "point", point_items, 0, "Point", "Set black point or white point for curves.");
1429 }
1430
1431 /******************** record composite operator *********************/
1432
1433 typedef struct RecordCompositeData {
1434         wmTimer *timer;
1435         int old_cfra;
1436         int sfra, efra;
1437 } RecordCompositeData;
1438
1439 int record_composite_apply(bContext *C, wmOperator *op)
1440 {
1441         SpaceImage *sima= (SpaceImage*)CTX_wm_space_data(C);
1442         RecordCompositeData *rcd= op->customdata;
1443         Scene *scene= CTX_data_scene(C);
1444         ImBuf *ibuf;
1445
1446         WM_timecursor(CTX_wm_window(C), scene->r.cfra);
1447
1448         // XXX scene->nodetree->test_break= blender_test_break;
1449         // XXX scene->nodetree->test_break= NULL;
1450
1451         BKE_image_all_free_anim_ibufs(scene->r.cfra);
1452         ntreeCompositTagAnimated(scene->nodetree);
1453         ntreeCompositExecTree(scene->nodetree, &scene->r, scene->r.cfra != rcd->old_cfra);      /* 1 is no previews */
1454
1455         ED_area_tag_redraw(CTX_wm_area(C));
1456
1457         ibuf= BKE_image_get_ibuf(sima->image, &sima->iuser);
1458         /* save memory in flipbooks */
1459         if(ibuf)
1460                 imb_freerectfloatImBuf(ibuf);
1461
1462         scene->r.cfra++;
1463
1464         return (scene->r.cfra <= rcd->efra);
1465 }
1466
1467 static int record_composite_init(bContext *C, wmOperator *op)
1468 {
1469         SpaceImage *sima= (SpaceImage*)CTX_wm_space_data(C);
1470         Scene *scene= CTX_data_scene(C);
1471         RecordCompositeData *rcd;
1472
1473         if(sima->iuser.frames < 2)
1474                 return 0;
1475         if(scene->nodetree == NULL)
1476                 return 0;
1477
1478         op->customdata= rcd= MEM_callocN(sizeof(RecordCompositeData), "ImageRecordCompositeData");
1479
1480         rcd->old_cfra= scene->r.cfra;
1481         rcd->sfra= sima->iuser.sfra;
1482         rcd->efra= sima->iuser.sfra + sima->iuser.frames-1;
1483         scene->r.cfra= rcd->sfra;
1484
1485         return 1;
1486 }
1487
1488 static void record_composite_exit(bContext *C, wmOperator *op)
1489 {
1490         Scene *scene= CTX_data_scene(C);
1491         SpaceImage *sima= (SpaceImage*)CTX_wm_space_data(C);
1492         RecordCompositeData *rcd= op->customdata;
1493
1494         scene->r.cfra= rcd->old_cfra;
1495
1496         WM_cursor_restore(CTX_wm_window(C));
1497
1498         if(rcd->timer)
1499                 WM_event_remove_window_timer(CTX_wm_window(C), rcd->timer);
1500
1501         WM_event_add_notifier(C, NC_IMAGE|NA_EDITED, sima->image);
1502
1503         // XXX play_anim(0);
1504         // XXX allqueue(REDRAWNODE, 1);
1505
1506         MEM_freeN(rcd);
1507 }
1508
1509 static int record_composite_exec(bContext *C, wmOperator *op)
1510 {
1511         if(!record_composite_init(C, op))
1512                 return OPERATOR_CANCELLED;
1513
1514         while(record_composite_apply(C, op))
1515                 ;
1516
1517         record_composite_exit(C, op);
1518
1519         return OPERATOR_FINISHED;
1520 }
1521
1522 static int record_composite_invoke(bContext *C, wmOperator *op, wmEvent *event)
1523 {
1524         RecordCompositeData *rcd= op->customdata;
1525
1526         if(!record_composite_init(C, op))
1527                 return OPERATOR_CANCELLED;
1528
1529         rcd= op->customdata;
1530         rcd->timer= WM_event_add_window_timer(CTX_wm_window(C), TIMER, 0.0f);
1531         WM_event_add_modal_handler(C, &CTX_wm_window(C)->handlers, op);
1532
1533         if(!record_composite_apply(C, op))
1534                 return OPERATOR_FINISHED;
1535
1536         return OPERATOR_RUNNING_MODAL;
1537 }
1538
1539 static int record_composite_modal(bContext *C, wmOperator *op, wmEvent *event)
1540 {
1541         RecordCompositeData *rcd= op->customdata;
1542
1543         switch(event->type) {
1544                 case TIMER:
1545                         if(rcd->timer == event->customdata) {
1546                                 if(!record_composite_apply(C, op)) {
1547                                         record_composite_exit(C, op);
1548                                         return OPERATOR_FINISHED;
1549                                 }
1550                         }
1551                         break;
1552                 case ESCKEY:
1553                         record_composite_exit(C, op);
1554                         return OPERATOR_FINISHED;
1555         }
1556
1557         return OPERATOR_RUNNING_MODAL;
1558 }
1559
1560 static int record_composite_cancel(bContext *C, wmOperator *op)
1561 {
1562         record_composite_exit(C, op);
1563         return OPERATOR_CANCELLED;
1564 }
1565
1566 void IMAGE_OT_record_composite(wmOperatorType *ot)
1567 {
1568         /* identifiers */
1569         ot->name= "Record Composite";
1570         ot->idname= "IMAGE_OT_record_composite";
1571
1572         /* api callbacks */
1573         ot->exec= record_composite_exec;
1574         ot->invoke= record_composite_invoke;
1575         ot->modal= record_composite_modal;
1576         ot->cancel= record_composite_cancel;
1577         ot->poll= space_image_poll;
1578 }
1579
1580 /******************** TODO ********************/
1581
1582 /* XXX notifier? */
1583 #if 0
1584 /* goes over all ImageUsers, and sets frame numbers if auto-refresh is set */
1585 void BIF_image_update_frame(void)
1586 {
1587         Tex *tex;
1588
1589         /* texture users */
1590         for(tex= G.main->tex.first; tex; tex= tex->id.next) {
1591                 if(tex->type==TEX_IMAGE && tex->ima)
1592                         if(ELEM(tex->ima->source, IMA_SRC_MOVIE, IMA_SRC_SEQUENCE))
1593                                 if(tex->iuser.flag & IMA_ANIM_ALWAYS)
1594                                         BKE_image_user_calc_imanr(&tex->iuser, scene->r.cfra, 0);
1595
1596         }
1597         /* image window, compo node users */
1598         if(G.curscreen) {
1599                 ScrArea *sa;
1600                 for(sa= G.curscreen->areabase.first; sa; sa= sa->next) {
1601                         if(sa->spacetype==SPACE_VIEW3D) {
1602                                 View3D *v3d= sa->spacedata.first;
1603                                 if(v3d->bgpic)
1604                                         if(v3d->bgpic->iuser.flag & IMA_ANIM_ALWAYS)
1605                                                 BKE_image_user_calc_imanr(&v3d->bgpic->iuser, scene->r.cfra, 0);
1606                         }
1607                         else if(sa->spacetype==SPACE_IMAGE) {
1608                                 SpaceImage *sima= sa->spacedata.first;
1609                                 if(sima->iuser.flag & IMA_ANIM_ALWAYS)
1610                                         BKE_image_user_calc_imanr(&sima->iuser, scene->r.cfra, 0);
1611                         }
1612                         else if(sa->spacetype==SPACE_NODE) {
1613                                 SpaceNode *snode= sa->spacedata.first;
1614                                 if((snode->treetype==NTREE_COMPOSIT) && (snode->nodetree)) {
1615                                         bNode *node;
1616                                         for(node= snode->nodetree->nodes.first; node; node= node->next) {
1617                                                 if(node->id && node->type==CMP_NODE_IMAGE) {
1618                                                         Image *ima= (Image *)node->id;
1619                                                         ImageUser *iuser= node->storage;
1620                                                         if(ELEM(ima->source, IMA_SRC_MOVIE, IMA_SRC_SEQUENCE))
1621                                                                 if(iuser->flag & IMA_ANIM_ALWAYS)
1622                                                                         BKE_image_user_calc_imanr(iuser, scene->r.cfra, 0);
1623                                                 }
1624                                         }
1625                                 }
1626                         }
1627                 }
1628         }
1629 }
1630 #endif
1631