Cleanup: use `rna_enum_` prefix for RNA enums
[blender.git] / source / blender / makesrna / intern / rna_image.c
index d039ff84917b3e91705d2fd818a549c61f9ab92b..63fa59828ac931408427fe53b6775c4f6dea4f07 100644 (file)
  *  \ingroup RNA
  */
 
-
 #include <stdlib.h>
 
-#include "RNA_define.h"
-#include "RNA_enum_types.h"
-
-#include "rna_internal.h"
-
 #include "DNA_image_types.h"
 #include "DNA_scene_types.h"
 
+#include "BLI_utildefines.h"
+
 #include "BKE_context.h"
 #include "BKE_depsgraph.h"
 #include "BKE_image.h"
 
+#include "RNA_access.h"
+#include "RNA_define.h"
+#include "RNA_enum_types.h"
+
+#include "rna_internal.h"
+
 #include "WM_types.h"
 #include "WM_api.h"
 
-EnumPropertyItem image_generated_type_items[] = {
+EnumPropertyItem rna_enum_image_generated_type_items[] = {
        {IMA_GENTYPE_BLANK, "BLANK", 0, "Blank", "Generate a blank image"},
        {IMA_GENTYPE_GRID, "UV_GRID", 0, "UV Grid", "Generated grid to test UV mappings"},
        {IMA_GENTYPE_GRID_COLOR, "COLOR_GRID", 0, "Color Grid", "Generated improved UV grid to test UV mappings"},
@@ -76,23 +78,30 @@ static void rna_Image_animated_update(Main *UNUSED(bmain), Scene *UNUSED(scene),
        }
 }
 
-static int rna_Image_dirty_get(PointerRNA *ptr)
+static int rna_Image_is_stereo_3d_get(PointerRNA *ptr)
 {
-       Image *ima = (Image *)ptr->data;
-       ImBuf *ibuf;
+       return BKE_image_is_stereo((Image *)ptr->data);
+}
 
-       for (ibuf = ima->ibufs.first; ibuf; ibuf = ibuf->next)
-               if (ibuf->userflags & IB_BITMAPDIRTY)
-                       return 1;
-       
-       return 0;
+static int rna_Image_is_multiview_get(PointerRNA *ptr)
+{
+       return BKE_image_is_multiview((Image *)ptr->data);
 }
 
-static void rna_Image_source_update(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
+static int rna_Image_dirty_get(PointerRNA *ptr)
+{
+       return BKE_image_is_dirty((Image *)ptr->data);
+}
+
+static void rna_Image_source_set(PointerRNA *ptr, int value)
 {
        Image *ima = ptr->id.data;
-       BKE_image_signal(ima, NULL, IMA_SIGNAL_SRC_CHANGE);
-       DAG_id_tag_update(&ima->id, 0);
+
+       if (value != ima->source) {
+               ima->source = value;
+               BKE_image_signal(ima, NULL, IMA_SIGNAL_SRC_CHANGE);
+               DAG_id_tag_update(&ima->id, 0);
+       }
 }
 
 static void rna_Image_fields_update(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
@@ -113,30 +122,47 @@ static void rna_Image_fields_update(Main *UNUSED(bmain), Scene *UNUSED(scene), P
                        BKE_image_signal(ima, NULL, IMA_SIGNAL_FREE);
        }
 
-       BKE_image_release_ibuf(ima, lock);
+       BKE_image_release_ibuf(ima, ibuf, lock);
 }
 
-static void rna_Image_free_update(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
+static void rna_Image_reload_update(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
 {
        Image *ima = ptr->id.data;
-       BKE_image_signal(ima, NULL, IMA_SIGNAL_FREE);
+       BKE_image_signal(ima, NULL, IMA_SIGNAL_RELOAD);
        WM_main_add_notifier(NC_IMAGE | NA_EDITED, &ima->id);
        DAG_id_tag_update(&ima->id, 0);
 }
 
+static void rna_Image_generated_update(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
+{
+       Image *ima = ptr->id.data;
+       BKE_image_signal(ima, NULL, IMA_SIGNAL_FREE);
+}
 
-static void rna_Image_reload_update(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
+static void rna_Image_colormanage_update(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
 {
        Image *ima = ptr->id.data;
-       BKE_image_signal(ima, NULL, IMA_SIGNAL_RELOAD);
-       WM_main_add_notifier(NC_IMAGE | NA_EDITED, &ima->id);
+       BKE_image_signal(ima, NULL, IMA_SIGNAL_COLORMANAGE);
        DAG_id_tag_update(&ima->id, 0);
+       WM_main_add_notifier(NC_IMAGE | ND_DISPLAY, &ima->id);
+       WM_main_add_notifier(NC_IMAGE | NA_EDITED, &ima->id);
 }
 
-static void rna_Image_generated_update(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
+static void rna_Image_views_format_update(Main *UNUSED(bmain), Scene *scene, PointerRNA *ptr)
 {
        Image *ima = ptr->id.data;
-       BKE_image_signal(ima, NULL, IMA_SIGNAL_FREE);
+       ImBuf *ibuf;
+       void *lock;
+
+       ibuf = BKE_image_acquire_ibuf(ima, NULL, &lock);
+
+       if (ibuf) {
+               ImageUser iuser = {NULL};
+               iuser.scene = scene;
+               BKE_image_signal(ima, &iuser, IMA_SIGNAL_FREE);
+       }
+
+       BKE_image_release_ibuf(ima, ibuf, lock);
 }
 
 static void rna_ImageUser_update(Main *UNUSED(bmain), Scene *scene, PointerRNA *ptr)
@@ -153,8 +179,15 @@ static char *rna_ImageUser_path(PointerRNA *ptr)
                /* ImageUser *iuser = ptr->data; */
                
                switch (GS(((ID *)ptr->id.data)->name)) {
+                       case ID_OB:
                        case ID_TE:
+                       {
                                return BLI_strdup("image_user");
+                       }
+                       case ID_NT:
+                       {
+                               return rna_Node_ImageUser_path(ptr);
+                       }
                }
        }
        
@@ -162,7 +195,7 @@ static char *rna_ImageUser_path(PointerRNA *ptr)
 }
 
 static EnumPropertyItem *rna_Image_source_itemf(bContext *UNUSED(C), PointerRNA *ptr,
-                                                PropertyRNA *UNUSED(prop), int *free)
+                                                PropertyRNA *UNUSED(prop), bool *r_free)
 {
        Image *ima = (Image *)ptr->data;
        EnumPropertyItem *item = NULL;
@@ -179,7 +212,7 @@ static EnumPropertyItem *rna_Image_source_itemf(bContext *UNUSED(C), PointerRNA
        }
 
        RNA_enum_item_end(&item, &totitem);
-       *free = 1;
+       *r_free = true;
 
        return item;
 }
@@ -187,38 +220,29 @@ static EnumPropertyItem *rna_Image_source_itemf(bContext *UNUSED(C), PointerRNA
 static int rna_Image_file_format_get(PointerRNA *ptr)
 {
        Image *image = (Image *)ptr->data;
-       ImBuf *ibuf = BKE_image_get_ibuf(image, NULL);
-       return BKE_ftype_to_imtype(ibuf ? ibuf->ftype : 0);
+       ImBuf *ibuf = BKE_image_acquire_ibuf(image, NULL, NULL);
+       int imtype = BKE_image_ftype_to_imtype(ibuf ? ibuf->ftype : 0, ibuf ? &ibuf->foptions : NULL);
+
+       BKE_image_release_ibuf(image, ibuf, NULL);
+
+       return imtype;
 }
 
 static void rna_Image_file_format_set(PointerRNA *ptr, int value)
 {
        Image *image = (Image *)ptr->data;
        if (BKE_imtype_is_movie(value) == 0) { /* should be able to throw an error here */
-               ImBuf *ibuf;
-               int ftype = BKE_imtype_to_ftype(value);
-
-#if 0
-               ibuf = BKE_image_get_ibuf(image, NULL);
-               if (ibuf)
-                       ibuf->ftype = ftype;
-#endif
-
-               /* to be safe change all buffer file types */
-               for (ibuf = image->ibufs.first; ibuf; ibuf = ibuf->next) {
-                       ibuf->ftype = ftype;
-               }
+               ImbFormatOptions options;
+               int ftype = BKE_image_imtype_to_ftype(value, &options);
+               BKE_image_file_format_set(image, ftype, &options);
        }
 }
 
 static int rna_Image_has_data_get(PointerRNA *ptr)
 {
-       Image *im = (Image *)ptr->data;
-
-       if (im->ibufs.first)
-               return 1;
+       Image *image = (Image *)ptr->data;
 
-       return 0;
+       return BKE_image_has_loaded_ibuf(image);
 }
 
 static void rna_Image_size_get(PointerRNA *ptr, int *values)
@@ -237,7 +261,7 @@ static void rna_Image_size_get(PointerRNA *ptr, int *values)
                values[1] = 0;
        }
 
-       BKE_image_release_ibuf(im, lock);
+       BKE_image_release_ibuf(im, ibuf, lock);
 }
 
 static void rna_Image_resolution_get(PointerRNA *ptr, float *values)
@@ -256,7 +280,7 @@ static void rna_Image_resolution_get(PointerRNA *ptr, float *values)
                values[1] = 0;
        }
 
-       BKE_image_release_ibuf(im, lock);
+       BKE_image_release_ibuf(im, ibuf, lock);
 }
 
 static void rna_Image_resolution_set(PointerRNA *ptr, const float *values)
@@ -271,7 +295,7 @@ static void rna_Image_resolution_set(PointerRNA *ptr, const float *values)
                ibuf->ppm[1] = values[1];
        }
 
-       BKE_image_release_ibuf(im, lock);
+       BKE_image_release_ibuf(im, ibuf, lock);
 }
 
 static int rna_Image_depth_get(PointerRNA *ptr)
@@ -290,18 +314,27 @@ static int rna_Image_depth_get(PointerRNA *ptr)
        else
                planes = ibuf->planes;
 
-       BKE_image_release_ibuf(im, lock);
+       BKE_image_release_ibuf(im, ibuf, lock);
 
        return planes;
 }
 
 static int rna_Image_frame_duration_get(PointerRNA *ptr)
 {
-       Image *im = (Image *)ptr->data;
+       Image *ima = ptr->id.data;
+       int duration = 1;
+
+       if (BKE_image_has_anim(ima)) {
+               duration = IMB_anim_get_duration(((ImageAnim *)ima->anims.first)->anim, IMB_TC_RECORD_RUN);
+       }
+       else {
+               /* acquire ensures ima->anim is set, if possible! */
+               void *lock;
+               ImBuf *ibuf = BKE_image_acquire_ibuf(ima, NULL, &lock);
+               BKE_image_release_ibuf(ima, ibuf, lock);
+       }
 
-       if (im->anim)
-               return IMB_anim_get_duration(im->anim, IMB_TC_RECORD_RUN);
-       return 1;
+       return duration;
 }
 
 static int rna_Image_pixels_get_length(PointerRNA *ptr, int length[RNA_MAX_ARRAY_DIMENSION])
@@ -317,7 +350,7 @@ static int rna_Image_pixels_get_length(PointerRNA *ptr, int length[RNA_MAX_ARRAY
        else
                length[0] = 0;
 
-       BKE_image_release_ibuf(ima, lock);
+       BKE_image_release_ibuf(ima, ibuf, lock);
 
        return length[0];
 }
@@ -343,7 +376,7 @@ static void rna_Image_pixels_get(PointerRNA *ptr, float *values)
                }
        }
 
-       BKE_image_release_ibuf(ima, lock);
+       BKE_image_release_ibuf(ima, ibuf, lock);
 }
 
 static void rna_Image_pixels_set(PointerRNA *ptr, const float *values)
@@ -369,7 +402,89 @@ static void rna_Image_pixels_set(PointerRNA *ptr, const float *values)
                ibuf->userflags |= IB_BITMAPDIRTY | IB_DISPLAY_BUFFER_INVALID;
        }
 
-       BKE_image_release_ibuf(ima, lock);
+       BKE_image_release_ibuf(ima, ibuf, lock);
+}
+
+static int rna_Image_channels_get(PointerRNA *ptr)
+{
+       Image *im = (Image *)ptr->data;
+       ImBuf *ibuf;
+       void *lock;
+       int channels = 0;
+
+       ibuf = BKE_image_acquire_ibuf(im, NULL, &lock);
+       if (ibuf)
+               channels = ibuf->channels;
+
+       BKE_image_release_ibuf(im, ibuf, lock);
+
+       return channels;
+}
+
+static int rna_Image_is_float_get(PointerRNA *ptr)
+{
+       Image *im = (Image *)ptr->data;
+       ImBuf *ibuf;
+       void *lock;
+       bool is_float = false;
+
+       ibuf = BKE_image_acquire_ibuf(im, NULL, &lock);
+       if (ibuf)
+               is_float = ibuf->rect_float != NULL;
+
+       BKE_image_release_ibuf(im, ibuf, lock);
+
+       return is_float;
+}
+
+static PointerRNA rna_Image_packed_file_get(PointerRNA *ptr)
+{
+       Image *ima = (Image *)ptr->id.data;
+
+       if (BKE_image_has_packedfile(ima)) {
+               ImagePackedFile *imapf = ima->packedfiles.first;
+               return rna_pointer_inherit_refine(ptr, &RNA_PackedFile, imapf->packedfile);
+       }
+       else {
+               return PointerRNA_NULL;
+       }
+}
+
+static void rna_Image_render_slots_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
+{
+       Image *image = (Image *)ptr->id.data;
+       rna_iterator_array_begin(iter, (void *)image->render_slots, sizeof(RenderSlot), IMA_MAX_RENDER_SLOT, 0, NULL);
+}
+
+static PointerRNA rna_render_slots_active_get(PointerRNA *ptr)
+{
+       Image *image = (Image *)ptr->id.data;
+       RenderSlot *render_slot = &image->render_slots[image->render_slot];
+
+       return rna_pointer_inherit_refine(ptr, &RNA_RenderSlot, render_slot);
+}
+
+static void rna_render_slots_active_set(PointerRNA *ptr, PointerRNA value)
+{
+       Image *image = (Image *)ptr->id.data;
+       if (value.id.data == image) {
+               RenderSlot *render_slot = (RenderSlot *)value.data;
+               int index = render_slot - image->render_slots;
+               image->render_slot = CLAMPIS(index, 0, IMA_MAX_RENDER_SLOT - 1);
+       }
+}
+
+static int rna_render_slots_active_index_get(PointerRNA *ptr)
+{
+       Image *image = (Image *)ptr->id.data;
+       return image->render_slot;
+}
+
+static void rna_render_slots_active_index_set(PointerRNA *ptr, int value)
+{
+       Image *image = (Image *)ptr->id.data;
+       image->render_slot = value;
+       CLAMP(image->render_slot, 0, IMA_MAX_RENDER_SLOT - 1);
 }
 
 #else
@@ -381,25 +496,33 @@ static void rna_def_imageuser(BlenderRNA *brna)
 
        srna = RNA_def_struct(brna, "ImageUser", NULL);
        RNA_def_struct_ui_text(srna, "Image User",
-                              "Parameters defining how an Image datablock is used by another datablock");
+                              "Parameters defining how an Image data-block is used by another data-block");
        RNA_def_struct_path_func(srna, "rna_ImageUser_path");
 
        prop = RNA_def_property(srna, "use_auto_refresh", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flag", IMA_ANIM_ALWAYS);
        RNA_def_property_ui_text(prop, "Auto Refresh", "Always refresh image on frame changes");
        RNA_def_property_update(prop, 0, "rna_ImageUser_update");
+       RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
+
+       prop = RNA_def_property(srna, "frame_current", PROP_INT, PROP_TIME);
+       RNA_def_property_int_sdna(prop, NULL, "framenr");
+       RNA_def_property_range(prop, MINAFRAME, MAXFRAME);
+       RNA_def_property_ui_text(prop, "Current Frame", "Current frame number in image sequence or movie");
 
        /* animation */
        prop = RNA_def_property(srna, "use_cyclic", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "cycl", 0);
        RNA_def_property_ui_text(prop, "Cyclic", "Cycle the images in the movie");
        RNA_def_property_update(prop, 0, "rna_ImageUser_update");
+       RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
 
        prop = RNA_def_property(srna, "frame_duration", PROP_INT, PROP_NONE);
        RNA_def_property_int_sdna(prop, NULL, "frames");
        RNA_def_property_range(prop, 0, MAXFRAMEF);
        RNA_def_property_ui_text(prop, "Frames", "Number of images of a movie to use");
        RNA_def_property_update(prop, 0, "rna_ImageUser_update");
+       RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
 
        prop = RNA_def_property(srna, "frame_offset", PROP_INT, PROP_NONE);
        RNA_def_property_int_sdna(prop, NULL, "offset");
@@ -412,12 +535,14 @@ static void rna_def_imageuser(BlenderRNA *brna)
        RNA_def_property_ui_text(prop, "Start Frame",
                                 "Global starting frame of the movie/sequence, assuming first picture has a #1");
        RNA_def_property_update(prop, 0, "rna_ImageUser_update");
+       RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
 
        prop = RNA_def_property(srna, "fields_per_frame", PROP_INT, PROP_NONE);
        RNA_def_property_int_sdna(prop, NULL, "fie_ima");
        RNA_def_property_range(prop, 1, 200);
        RNA_def_property_ui_text(prop, "Fields per Frame", "Number of fields per rendered frame (2 fields is 1 image)");
        RNA_def_property_update(prop, 0, "rna_ImageUser_update");
+       RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
 
        prop = RNA_def_property(srna, "multilayer_layer", PROP_INT, PROP_UNSIGNED);
        RNA_def_property_int_sdna(prop, NULL, "layer");
@@ -428,6 +553,71 @@ static void rna_def_imageuser(BlenderRNA *brna)
        RNA_def_property_int_sdna(prop, NULL, "pass");
        RNA_def_property_clear_flag(prop, PROP_EDITABLE); /* image_multi_cb */
        RNA_def_property_ui_text(prop, "Pass", "Pass in multilayer image");
+
+       prop = RNA_def_property(srna, "multilayer_view", PROP_INT, PROP_UNSIGNED);
+       RNA_def_property_int_sdna(prop, NULL, "view");
+       RNA_def_property_clear_flag(prop, PROP_EDITABLE); /* image_multi_cb */
+       RNA_def_property_ui_text(prop, "View", "View in multilayer image");
+}
+
+/* image.packed_files */
+static void rna_def_image_packed_files(BlenderRNA *brna)
+{
+       StructRNA *srna;
+       PropertyRNA *prop;
+
+       srna = RNA_def_struct(brna, "ImagePackedFile", NULL);
+       RNA_def_struct_sdna(srna, "ImagePackedFile");
+
+       prop = RNA_def_property(srna, "packed_file", PROP_POINTER, PROP_NONE);
+       RNA_def_property_pointer_sdna(prop, NULL, "packedfile");
+       RNA_def_property_ui_text(prop, "Packed File", "");
+       RNA_def_property_clear_flag(prop, PROP_EDITABLE);
+
+       prop = RNA_def_property(srna, "filepath", PROP_STRING, PROP_FILEPATH);
+       RNA_def_property_string_sdna(prop, NULL, "filepath");
+       RNA_def_struct_name_property(srna, prop);
+
+       RNA_api_image_packed_file(srna);
+}
+
+static void rna_def_render_slot(BlenderRNA *brna)
+{
+       StructRNA *srna;
+       PropertyRNA *prop;
+       srna = RNA_def_struct(brna, "RenderSlot", NULL);
+       RNA_def_struct_ui_text(srna, "Render Slot", "Parameters defining the render slot");
+
+       prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
+       RNA_def_property_string_sdna(prop, NULL, "name");
+       RNA_def_property_ui_text(prop, "Name", "Render slot name");
+       RNA_def_property_update(prop, NC_IMAGE | ND_DISPLAY, NULL);
+}
+
+static void rna_def_render_slots(BlenderRNA *brna)
+{
+       StructRNA *srna;
+       PropertyRNA *prop;
+
+       srna = RNA_def_struct(brna, "RenderSlots", NULL);
+       RNA_def_struct_sdna(srna, "RenderSlot");
+       RNA_def_struct_ui_text(srna, "Render Slots", "Collection of the render slots");
+
+       prop = RNA_def_property(srna, "active", PROP_POINTER, PROP_NONE);
+       RNA_def_property_struct_type(prop, "RenderSlot");
+       RNA_def_property_pointer_funcs(prop, "rna_render_slots_active_get", "rna_render_slots_active_set", NULL, NULL);
+       RNA_def_property_flag(prop, PROP_EDITABLE | PROP_NEVER_UNLINK);
+       RNA_def_property_ui_text(prop, "Active", "Active render slot of the image");
+       RNA_def_property_update(prop, NC_IMAGE | ND_DISPLAY, NULL);
+
+       prop = RNA_def_property(srna, "active_index", PROP_INT, PROP_NONE);
+       RNA_def_property_int_funcs(prop, "rna_render_slots_active_index_get",
+                                  "rna_render_slots_active_index_set",
+                                  NULL);
+       RNA_def_property_range(prop, 0, IMA_MAX_RENDER_SLOT);
+       RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
+       RNA_def_property_ui_text(prop, "Active Index", "Index of an active render slot of the image");
+       RNA_def_property_update(prop, NC_IMAGE | ND_DISPLAY, NULL);
 }
 
 static void rna_def_image(BlenderRNA *brna)
@@ -452,9 +642,14 @@ static void rna_def_image(BlenderRNA *brna)
                {IMA_STD_FIELD, "ODD", 0, "Lower First", "Lower field first"},
                {0, NULL, 0, NULL, NULL}
        };
+       static const EnumPropertyItem alpha_mode_items[] = {
+               {IMA_ALPHA_STRAIGHT, "STRAIGHT", 0, "Straight", "Transparent RGB and alpha pixels are unmodified"},
+               {IMA_ALPHA_PREMUL, "PREMUL", 0, "Premultiplied", "Transparent RGB pixels are multiplied by the alpha channel"},
+               {0, NULL, 0, NULL, NULL}
+       };
 
        srna = RNA_def_struct(brna, "Image", "ID");
-       RNA_def_struct_ui_text(srna, "Image", "Image datablock referencing an external or packed image");
+       RNA_def_struct_ui_text(srna, "Image", "Image data-block referencing an external or packed image");
        RNA_def_struct_ui_icon(srna, ICON_IMAGE_DATA);
 
        prop = RNA_def_property(srna, "filepath", PROP_STRING, PROP_FILEPATH);
@@ -468,15 +663,15 @@ static void rna_def_image(BlenderRNA *brna)
        RNA_def_property_ui_text(prop, "File Name", "Image/Movie file name (without data refreshing)");
 
        prop = RNA_def_property(srna, "file_format", PROP_ENUM, PROP_NONE);
-       RNA_def_property_enum_items(prop, image_type_items);
+       RNA_def_property_enum_items(prop, rna_enum_image_type_items);
        RNA_def_property_enum_funcs(prop, "rna_Image_file_format_get", "rna_Image_file_format_set", NULL);
        RNA_def_property_ui_text(prop, "File Format", "Format used for re-saving this file");
 
        prop = RNA_def_property(srna, "source", PROP_ENUM, PROP_NONE);
        RNA_def_property_enum_items(prop, image_source_items);
-       RNA_def_property_enum_funcs(prop, NULL, NULL, "rna_Image_source_itemf");
+       RNA_def_property_enum_funcs(prop, NULL, "rna_Image_source_set", "rna_Image_source_itemf");
        RNA_def_property_ui_text(prop, "Source", "Where the image comes from");
-       RNA_def_property_update(prop, NC_IMAGE | ND_DISPLAY, "rna_Image_source_update");
+       RNA_def_property_update(prop, NC_IMAGE | ND_DISPLAY, NULL);
 
        prop = RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
        RNA_def_property_enum_items(prop, prop_type_items);
@@ -485,38 +680,61 @@ static void rna_def_image(BlenderRNA *brna)
        RNA_def_property_update(prop, NC_IMAGE | ND_DISPLAY, NULL);
 
        prop = RNA_def_property(srna, "packed_file", PROP_POINTER, PROP_NONE);
+       RNA_def_property_struct_type(prop, "PackedFile");
        RNA_def_property_pointer_sdna(prop, NULL, "packedfile");
-       RNA_def_property_ui_text(prop, "Packed File", "");
-       
+       RNA_def_property_pointer_funcs(prop, "rna_Image_packed_file_get", NULL, NULL, NULL);
+       RNA_def_property_ui_text(prop, "Packed File", "First packed file of the image");
+
+       prop = RNA_def_property(srna, "packed_files", PROP_COLLECTION, PROP_NONE);
+       RNA_def_property_collection_sdna(prop, NULL, "packedfiles", NULL);
+       RNA_def_property_struct_type(prop, "ImagePackedFile");
+       RNA_def_property_clear_flag(prop, PROP_EDITABLE);
+       RNA_def_property_ui_text(prop, "Packed Files", "Collection of packed images");
+
        prop = RNA_def_property(srna, "field_order", PROP_ENUM, PROP_NONE);
        RNA_def_property_enum_bitflag_sdna(prop, NULL, "flag");
        RNA_def_property_enum_items(prop, prop_field_order_items);
        RNA_def_property_ui_text(prop, "Field Order", "Order of video fields (select which lines are displayed first)");
        RNA_def_property_update(prop, NC_IMAGE | ND_DISPLAY, NULL);
-       
+
        /* booleans */
        prop = RNA_def_property(srna, "use_fields", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flag", IMA_FIELDS);
        RNA_def_property_ui_text(prop, "Fields", "Use fields of the image");
        RNA_def_property_update(prop, NC_IMAGE | ND_DISPLAY, "rna_Image_fields_update");
-
-       prop = RNA_def_property(srna, "use_premultiply", PROP_BOOLEAN, PROP_NONE);
-       RNA_def_property_boolean_sdna(prop, NULL, "flag", IMA_DO_PREMUL);
-       RNA_def_property_ui_text(prop, "Premultiply", "Convert RGB from key alpha to premultiplied alpha");
-       RNA_def_property_update(prop, NC_IMAGE | ND_DISPLAY, "rna_Image_free_update");
+       RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
        
-       prop = RNA_def_property(srna, "use_color_unpremultiply", PROP_BOOLEAN, PROP_NONE);
-       RNA_def_property_boolean_sdna(prop, NULL, "flag", IMA_CM_PREDIVIDE);
-       RNA_def_property_ui_text(prop, "Color Unpremultiply",
-                                "For premultiplied alpha images, do color space conversion on colors without alpha, "
-                                "to avoid fringing for images with light backgrounds");
-       RNA_def_property_update(prop, NC_IMAGE | ND_DISPLAY, "rna_Image_free_update");
-
-       prop = RNA_def_property(srna, "view_as_render", PROP_BOOLEAN, PROP_NONE);
+
+       prop = RNA_def_property(srna, "use_view_as_render", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flag", IMA_VIEW_AS_RENDER);
        RNA_def_property_ui_text(prop, "View as Render", "Apply render part of display transformation when displaying this image on the screen");
        RNA_def_property_update(prop, NC_IMAGE | ND_DISPLAY, NULL);
 
+       prop = RNA_def_property(srna, "use_alpha", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", IMA_IGNORE_ALPHA);
+       RNA_def_property_ui_text(prop, "Use Alpha", "Use the alpha channel information from the image or make image fully opaque");
+       RNA_def_property_update(prop, NC_IMAGE | ND_DISPLAY, "rna_Image_colormanage_update");
+
+       prop = RNA_def_property(srna, "use_deinterlace", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_boolean_sdna(prop, NULL, "flag", IMA_DEINTERLACE);
+       RNA_def_property_ui_text(prop, "Deinterlace", "Deinterlace movie file on load");
+       RNA_def_property_update(prop, NC_IMAGE | ND_DISPLAY, "rna_Image_reload_update");
+
+       prop = RNA_def_property(srna, "use_multiview", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_boolean_sdna(prop, NULL, "flag", IMA_USE_VIEWS);
+       RNA_def_property_ui_text(prop, "Use Multi-View", "Use Multiple Views (when available)");
+       RNA_def_property_update(prop, NC_IMAGE | ND_DISPLAY, "rna_Image_views_format_update");
+
+       prop = RNA_def_property(srna, "is_stereo_3d", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_boolean_funcs(prop, "rna_Image_is_stereo_3d_get", NULL);
+       RNA_def_property_ui_text(prop, "Stereo 3D", "Image has left and right views");
+       RNA_def_property_clear_flag(prop, PROP_EDITABLE);
+
+       prop = RNA_def_property(srna, "is_multiview", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_boolean_funcs(prop, "rna_Image_is_multiview_get", NULL);
+       RNA_def_property_ui_text(prop, "Multiple Views", "Image has more than one view");
+       RNA_def_property_clear_flag(prop, PROP_EDITABLE);
+
        prop = RNA_def_property(srna, "is_dirty", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_funcs(prop, "rna_Image_dirty_get", NULL);
        RNA_def_property_clear_flag(prop, PROP_EDITABLE);
@@ -525,26 +743,39 @@ static void rna_def_image(BlenderRNA *brna)
        /* generated image (image_generated_change_cb) */
        prop = RNA_def_property(srna, "generated_type", PROP_ENUM, PROP_NONE);
        RNA_def_property_enum_sdna(prop, NULL, "gen_type");
-       RNA_def_property_enum_items(prop, image_generated_type_items);
+       RNA_def_property_enum_items(prop, rna_enum_image_generated_type_items);
        RNA_def_property_ui_text(prop, "Generated Type", "Generated image type");
        RNA_def_property_update(prop, NC_IMAGE | ND_DISPLAY, "rna_Image_generated_update");
-
+       RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
+       
        prop = RNA_def_property(srna, "generated_width", PROP_INT, PROP_NONE);
        RNA_def_property_int_sdna(prop, NULL, "gen_x");
-       RNA_def_property_range(prop, 1, 16384);
+       RNA_def_property_flag(prop, PROP_PROPORTIONAL);
+       RNA_def_property_range(prop, 1, 65536);
        RNA_def_property_ui_text(prop, "Generated Width", "Generated image width");
        RNA_def_property_update(prop, NC_IMAGE | ND_DISPLAY, "rna_Image_generated_update");
-
+       RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
+       
        prop = RNA_def_property(srna, "generated_height", PROP_INT, PROP_NONE);
        RNA_def_property_int_sdna(prop, NULL, "gen_y");
-       RNA_def_property_range(prop, 1, 16384);
+       RNA_def_property_flag(prop, PROP_PROPORTIONAL);
+       RNA_def_property_range(prop, 1, 65536);
        RNA_def_property_ui_text(prop, "Generated Height", "Generated image height");
        RNA_def_property_update(prop, NC_IMAGE | ND_DISPLAY, "rna_Image_generated_update");
-
+       RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
+       
        prop = RNA_def_property(srna, "use_generated_float", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "gen_flag", IMA_GEN_FLOAT);
        RNA_def_property_ui_text(prop, "Float Buffer", "Generate floating point buffer");
        RNA_def_property_update(prop, NC_IMAGE | ND_DISPLAY, "rna_Image_generated_update");
+       RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
+
+       prop = RNA_def_property(srna, "generated_color", PROP_FLOAT, PROP_COLOR_GAMMA);
+       RNA_def_property_float_sdna(prop, NULL, "gen_color");
+       RNA_def_property_array(prop, 4);
+       RNA_def_property_ui_text(prop, "Color", "Fill color for the generated image");
+       RNA_def_property_update(prop, NC_IMAGE | ND_DISPLAY, "rna_Image_generated_update");
+       RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
 
        /* realtime properties */
        prop = RNA_def_property(srna, "mapping", PROP_ENUM, PROP_NONE);
@@ -556,7 +787,8 @@ static void rna_def_image(BlenderRNA *brna)
        prop = RNA_def_property(srna, "display_aspect", PROP_FLOAT, PROP_XYZ);
        RNA_def_property_float_sdna(prop, NULL, "aspx");
        RNA_def_property_array(prop, 2);
-       RNA_def_property_range(prop, 0.1f, 5000.0f);
+       RNA_def_property_range(prop, 0.1f, FLT_MAX);
+       RNA_def_property_ui_range(prop, 0.1f, 5000.f, 1, 2);
        RNA_def_property_ui_text(prop, "Display Aspect", "Display Aspect for this image, does not affect rendering");
        RNA_def_property_update(prop, NC_IMAGE | ND_DISPLAY, NULL);
 
@@ -567,13 +799,13 @@ static void rna_def_image(BlenderRNA *brna)
 
        prop = RNA_def_property(srna, "frame_start", PROP_INT, PROP_NONE);
        RNA_def_property_int_sdna(prop, NULL, "twsta");
-       RNA_def_property_range(prop, 0, 128);
+       RNA_def_property_range(prop, 0, 255);
        RNA_def_property_ui_text(prop, "Animation Start", "Start frame of an animated texture");
        RNA_def_property_update(prop, NC_IMAGE | ND_DISPLAY, "rna_Image_animated_update");
 
        prop = RNA_def_property(srna, "frame_end", PROP_INT, PROP_NONE);
        RNA_def_property_int_sdna(prop, NULL, "twend");
-       RNA_def_property_range(prop, 0, 128);
+       RNA_def_property_range(prop, 0, 255);
        RNA_def_property_ui_text(prop, "Animation End", "End frame of an animated texture");
        RNA_def_property_update(prop, NC_IMAGE | ND_DISPLAY, "rna_Image_animated_update");
 
@@ -617,10 +849,12 @@ static void rna_def_image(BlenderRNA *brna)
        RNA_def_property_ui_text(prop, "Bindcode", "OpenGL bindcode");
        RNA_def_property_update(prop, NC_IMAGE | ND_DISPLAY, NULL);
 
-       prop = RNA_def_property(srna, "render_slot", PROP_INT, PROP_UNSIGNED);
-       RNA_def_property_range(prop, 0, IMA_MAX_RENDER_SLOT - 1);
-       RNA_def_property_ui_text(prop, "Render Slot", "The current render slot displayed, only for viewer type images");
-       RNA_def_property_update(prop, NC_IMAGE | ND_DISPLAY, NULL);
+       prop = RNA_def_property(srna, "render_slots", PROP_COLLECTION, PROP_NONE);
+       RNA_def_property_struct_type(prop, "RenderSlot");
+       RNA_def_property_ui_text(prop, "Render Slots", "Render slots of the image");
+       RNA_def_property_collection_funcs(prop, "rna_Image_render_slots_begin", "rna_iterator_array_next",
+                                         "rna_iterator_array_end", "rna_iterator_array_get", NULL, NULL, NULL, NULL);
+       RNA_def_property_srna(prop, "RenderSlots");
 
        /*
         * Image.has_data and Image.depth are temporary,
@@ -638,6 +872,7 @@ static void rna_def_image(BlenderRNA *brna)
 
        prop = RNA_def_int_vector(srna, "size", 2, NULL, 0, 0, "Size",
                                  "Width and height in pixels, zero when image data cant be loaded", 0, 0);
+       RNA_def_property_subtype(prop, PROP_PIXEL);
        RNA_def_property_int_funcs(prop, "rna_Image_size_get", NULL, NULL);
        RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 
@@ -649,6 +884,10 @@ static void rna_def_image(BlenderRNA *brna)
        RNA_def_property_ui_text(prop, "Duration", "Duration (in frames) of the image (1 when not a video/sequence)");
        RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 
+       /* NOTE about pixels/channels/is_floa:
+        * this properties describes how image is stored internally (inside of ImBuf),
+        * not how it was saved to disk or how it'll be saved on disk
+        */
        prop = RNA_def_property(srna, "pixels", PROP_FLOAT, PROP_NONE);
        RNA_def_property_flag(prop, PROP_DYNAMIC);
        RNA_def_property_multi_array(prop, 1, NULL);
@@ -656,18 +895,49 @@ static void rna_def_image(BlenderRNA *brna)
        RNA_def_property_dynamic_array_funcs(prop, "rna_Image_pixels_get_length");
        RNA_def_property_float_funcs(prop, "rna_Image_pixels_get", "rna_Image_pixels_set", NULL);
 
+       prop = RNA_def_property(srna, "channels", PROP_INT, PROP_UNSIGNED);
+       RNA_def_property_int_funcs(prop, "rna_Image_channels_get", NULL, NULL);
+       RNA_def_property_ui_text(prop, "Channels", "Number of channels in pixels buffer");
+       RNA_def_property_clear_flag(prop, PROP_EDITABLE);
+
+       prop = RNA_def_property(srna, "is_float", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_boolean_funcs(prop, "rna_Image_is_float_get", NULL);
+       RNA_def_property_clear_flag(prop, PROP_EDITABLE);
+       RNA_def_property_ui_text(prop, "Is Float", "True if this image is stored in float buffer");
+
        prop = RNA_def_property(srna, "colorspace_settings", PROP_POINTER, PROP_NONE);
        RNA_def_property_pointer_sdna(prop, NULL, "colorspace_settings");
-       RNA_def_property_struct_type(prop, "ColorManagedColorspaceSettings");
+       RNA_def_property_struct_type(prop, "ColorManagedInputColorspaceSettings");
        RNA_def_property_ui_text(prop, "Color Space Settings", "Input color space settings");
 
+       prop = RNA_def_property(srna, "alpha_mode", PROP_ENUM, PROP_NONE);
+       RNA_def_property_enum_items(prop, alpha_mode_items);
+       RNA_def_property_ui_text(prop, "Alpha Mode", "Representation of alpha information in the RGBA pixels");
+       RNA_def_property_update(prop, NC_IMAGE | ND_DISPLAY, "rna_Image_colormanage_update");
+
+       /* multiview */
+       prop = RNA_def_property(srna, "views_format", PROP_ENUM, PROP_NONE);
+       RNA_def_property_enum_sdna(prop, NULL, "views_format");
+       RNA_def_property_enum_items(prop, rna_enum_views_format_items);
+       RNA_def_property_ui_text(prop, "Views Format", "Mode to load image views");
+       RNA_def_property_update(prop, NC_IMAGE | ND_DISPLAY, "rna_Image_views_format_update");
+
+       prop = RNA_def_property(srna, "stereo_3d_format", PROP_POINTER, PROP_NONE);
+       RNA_def_property_pointer_sdna(prop, NULL, "stereo3d_format");
+       RNA_def_property_flag(prop, PROP_NEVER_NULL);
+       RNA_def_property_struct_type(prop, "Stereo3dFormat");
+       RNA_def_property_ui_text(prop, "Stereo 3D Format", "Settings for stereo 3d");
+
        RNA_api_image(srna);
 }
 
 void RNA_def_image(BlenderRNA *brna)
 {
+       rna_def_render_slot(brna);
+       rna_def_render_slots(brna);
        rna_def_image(brna);
        rna_def_imageuser(brna);
+       rna_def_image_packed_files(brna);
 }
 
 #endif