typedef struct Image {
	/*...*/
	ListBase imlayers;
} Image;

/*...*/
 
typedef struct ImageLayer {
	struct ImageLayer *next, *prev;
	char name[IMA_LAYER_MAX_LEN];
	float opacity;
	int flag;
	ListBase ibufs; /* Stores only one ImBuf */
} ImageLayer;
 
/*...*/

/*...*/
 
static PointerRNA rna_Image_active_image_layer_get(PointerRNA *ptr)
{
	Image *ima= (Image*)ptr->data;
	ImageLayer *layer= imalayer_get_current(ima);
 
	return rna_pointer_inherit_refine(ptr, &RNA_ImageLayer, layer);
}
 
static int rna_Image_active_image_layer_index_get(PointerRNA *ptr)
{
	Image *ima= (Image*)ptr->data;
	return imalayer_get_current_num(ima);
}
 
static void rna_Image_active_image_layer_index_set(PointerRNA *ptr, int value)
{
	Image *ima= (Image*)ptr->data;
	imalayer_set_current_num(ima, value);
}
 
static void rna_Image_active_image_layer_index_range(PointerRNA *ptr, int *min, int *max)
{
	Image *im= (Image*)ptr->data;
 
	*min= 0;
	*max= BLI_countlist(&im->imlayers)-1;
	*max= MAX2(0, *max);
}
 
/*...*/
 
 
static void rna_def_image_layer(BlenderRNA *brna)
{
		StructRNA *srna;
		PropertyRNA *prop;
		FunctionRNA *func;
 
		srna= RNA_def_struct(brna, "ImageLayer", NULL);
		RNA_def_struct_ui_text(srna, "Image Layer", "Image layer");
 
		prop= RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
		RNA_def_property_string_sdna(prop, NULL, "name");
		RNA_def_property_string_default(prop, "ImageLayer");
		RNA_def_property_string_maxlength(prop, IMA_LAYER_MAX_LEN);
		RNA_def_property_update(prop, NC_OBJECT|ND_MODIFIER|NA_RENAME, NULL);
		RNA_def_property_ui_text(prop, "Name", "The name of the image layer.");
		RNA_def_struct_name_property(srna, prop);
 
		prop= RNA_def_property(srna, "opacity", PROP_FLOAT, PROP_NONE);
		RNA_def_property_float_sdna(prop, NULL, "opacity");
		RNA_def_property_float_default(prop, 1.0f);
		RNA_def_property_range(prop, 0.0, 1.0);
		RNA_def_property_ui_text(prop, "Opacity", "The opacity of the image layer when blended.");
		RNA_def_property_update(prop, NC_IMAGE|ND_DISPLAY, NULL);
 
		prop= RNA_def_property(srna, "invisible", PROP_BOOLEAN, PROP_NONE);
		RNA_def_property_boolean_sdna(prop, NULL, "flag", IMA_LAYER_INVISIBLE);
		RNA_def_property_ui_text(prop, "Invisible", "Hides the layer in the UV/Image Editor");
		RNA_def_property_update(prop, NC_IMAGE|ND_DISPLAY, NULL);
}
 
/* ... */
 
static void rna_def_image(BlenderRNA *brna)
{
	/*...*/
	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);
 
	/* Image Layers */
 
	/* Image Layers */
 
	prop= RNA_def_property(srna, "image_layers", PROP_COLLECTION, PROP_NONE);
	RNA_def_property_collection_sdna(prop, NULL, "imlayers", NULL);
	//RNA_def_property_collection_funcs(prop, "rna_Image_layers_begin", "rna_iterator_listbase_next", "rna_iterator_listbase_end", "rna_iterator_listbase_get", 0, 0, 0);
	RNA_def_property_struct_type(prop, "ImageLayer");
	RNA_def_property_ui_text(prop, "Image Layers", "");
 
	prop= RNA_def_property(srna, "active_image_layer", PROP_POINTER, PROP_NONE);
	RNA_def_property_struct_type(prop, "ImageLayer");
	RNA_def_property_pointer_funcs(prop, "rna_Image_active_image_layer_get", NULL, NULL, NULL);
	RNA_def_property_ui_text(prop, "Active Image Layer", "Active image layer");
	RNA_def_property_update(prop, NC_IMAGE|ND_DISPLAY, NULL);
 
	prop= RNA_def_property(srna, "active_image_layer_index", PROP_INT, PROP_UNSIGNED);
	RNA_def_property_int_funcs(prop, "rna_Image_active_image_layer_index_get", "rna_Image_active_image_layer_index_set", "rna_Image_active_image_layer_index_range");
	RNA_def_property_ui_text(prop, "Active Image Layer Index", "Index of active image layer slot");
	RNA_def_property_update(prop, NC_IMAGE|ND_DISPLAY, NULL);
 
	/*...*/
}
 
void RNA_def_image(BlenderRNA *brna)
{
	rna_def_image_layer(brna);
	rna_def_image(brna);
	rna_def_imageuser(brna);
}
 
/*...*/

/********************** image layer operators *********************/
 
int image_layer_poll(bContext *C)
{
	return NULL != CTX_data_edit_image(C);
}
 
static int image_layer_add_exec(bContext *C, wmOperator *op)
{
	Image *im= CTX_data_edit_image(C);
 
	if(!im)
		return OPERATOR_CANCELLED;
 
	image_add_image_layer(im);
	WM_event_add_notifier(C, NC_IMAGE|ND_DRAW, NULL);
 
	return OPERATOR_FINISHED;
}
 
void IMAGE_OT_image_layer_add(wmOperatorType *ot)
{
	/* identifiers */
	ot->name= "Add Image Layer";
	ot->idname= "IMAGE_OT_image_layer_add";
	ot->description="Add a new image layer";
 
	/* api callbacks */
	ot->exec= image_layer_add_exec;
	ot->poll = image_layer_poll;
 
	/* flags */
	ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
}
 
static int image_layer_remove_exec(bContext *C, wmOperator *op)
{
	Image *ima= CTX_data_edit_image(C);
 
	if(!ima)
		return OPERATOR_CANCELLED;
 
	image_remove_current_image_layer(ima);
	WM_event_add_notifier(C, NC_IMAGE|ND_DRAW, NULL);
 
	return OPERATOR_FINISHED;
}
 
void IMAGE_OT_image_layer_remove(wmOperatorType *ot)
{
	/* identifiers */
	ot->name= "Remove Image Layer";
	ot->idname= "IMAGE_OT_image_layer_remove";
	ot->description="Remove the selected image layer";
 
	/* api callbacks */
	ot->exec= image_layer_remove_exec;
	ot->poll = image_layer_poll;
 
	/* flags */
	ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
}
 
static int image_layer_fill_color_exec(bContext *C, wmOperator *op)
{
	float color[4];
 
	Image *ima= CTX_data_edit_image(C);
 
	if(!ima)
		return OPERATOR_CANCELLED;
 
	RNA_float_get_array(op->ptr, "color", color);
 
	imalayer_fill_color(ima, color);
 
	WM_event_add_notifier(C, NC_IMAGE|ND_DRAW, NULL);
 
	return OPERATOR_FINISHED;
}
 
void IMAGE_OT_image_layer_fill_color(wmOperatorType *ot)
{
	const float defcol[4] = {0.0f, 0.0f, 0.0f, 0.0f};
 
	/* identifiers */
	ot->name= "Fill Image Layer with Color";
	ot->idname= "IMAGE_OT_image_layer_fill_color";
	ot->description="Fill the image layer with a constant color";
 
	/* api callbacks */
	ot->exec= image_layer_fill_color_exec;
	ot->poll = image_layer_poll;
	ot->invoke= WM_operator_props_popup;
 
	/* flags */
	ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
 
	/* properties */
	RNA_def_float_color(ot->srna, "color", 4, defcol, 0.0f, 1.0f, "Fill Color", "Color used to fill the layer", 0.0f, 1.0f);
}
 
static int image_layer_move_exec(bContext *C, wmOperator *op)
{
	Image *ima= CTX_data_edit_image(C);
	ImageLayer *layer, *tmp;
	int type, layerID;
 
	if(!ima)
		return OPERATOR_CANCELLED;
 
	layer= imalayer_get_current(ima);
 
	if (!layer)
		return OPERATOR_CANCELLED;
 
	type= RNA_enum_get(op->ptr, "type");
	layerID= imalayer_get_current_num(ima);
 
	if (type == -1) { /* Move direction: Up */
		tmp= layer->prev;
		BLI_remlink(&ima->imlayers, layer);
		layer->next = layer->prev = NULL;
		if (tmp) {
			BLI_insertlinkbefore(&ima->imlayers, tmp, layer);
		}
		else {
			BLI_addhead(&ima->imlayers, layer);
		}
	}
	else { /* Move direction: Down */
		tmp= layer->next;
		BLI_remlink(&ima->imlayers, layer);
		layer->next = layer->prev = NULL;
		if (tmp) {
			BLI_insertlinkafter(&ima->imlayers, tmp, layer);
		}
		else {
			BLI_addtail(&ima->imlayers, layer);
		}
	}
 
	WM_event_add_notifier(C, NC_IMAGE|ND_DRAW, NULL);
 
	return OPERATOR_FINISHED;
}
 
void IMAGE_OT_image_layer_move(wmOperatorType *ot)
{
	static EnumPropertyItem slot_move[] = {
		{-1, "UP", 0, "Up", ""},
		{1, "DOWN", 0, "Down", ""},
		{0, NULL, 0, NULL, NULL}
	};
 
	/* identifiers */
	ot->name= "Move Imahe Layer";
	ot->idname= "IMAGE_OT_image_layer_move";
	ot->description="Move image layers up and down";
 
	/* api callbacks */
	ot->exec= image_layer_move_exec;
 
	/* flags */
	ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
 
	/* properties */
	RNA_def_enum(ot->srna, "type", slot_move, 0, "Type", "");
}

/* Removes all image layers from the image "ima" */
void image_free_image_layers(struct Image *ima);
 
/* Frees an image layer and associated memory */
void free_image_layer(struct ImageLayer *layer);
 
/* Removes the currently selected image layer */
int image_remove_current_image_layer(struct Image *ima);
 
/* Adds another image layer and selects it */
int image_add_image_layer(struct Image *ima);
 
/* Adds the base layer of images that points Image->ibufs.first */
int image_add_image_layer_base(struct Image *ima);
 
/* Returns the index of the currently selected image layer */
short imalayer_get_current_num(struct Image *ima);
 
/* Selects the image layer with the number specified in "value" */
void imalayer_set_current_num(struct Image *ima, short value);
 
/* Returns the image layer that is currently selected */
struct ImageLayer *imalayer_get_current(struct Image *ima);
 
/* Fills the current selected image layer with the color given */
void imalayer_fill_color(struct Image *ima, float color[4]);
 
/* image layers */
 
void image_free_image_layers(struct Image *ima)
{
	ImageLayer *layer, *next;
	ImBuf *ibuf;
	void *lock;
 
	if(ima==0)
		return;
 
	ibuf= BKE_image_acquire_ibuf(ima, NULL, &lock);
 
	layer=(ImageLayer*)(ima->imlayers.first);
	while(layer) {
		next= layer->next;
		BLI_remlink(&ima->imlayers, layer);
		free_image_layer(layer);
		layer= next;
	}
 
	BLI_freelistN(&ima->imlayers);
 
	BKE_image_release_ibuf(ima, lock);
}
 
void free_image_layer(ImageLayer *layer)
{
	ImBuf *ibuf, *next;
 
	if (!layer)
		return;
 
	ibuf= (layer->ibufs).first;
	while(ibuf) {
		next= ibuf->next;
		BLI_remlink(&layer->ibufs, ibuf);
 
		if((layer->flag & IMA_LAYER_BASE)==0) {
			if (ibuf->userdata) {
				MEM_freeN(ibuf->userdata);
				ibuf->userdata = NULL;
			}
 
			IMB_freeImBuf(ibuf);
		}
		ibuf= next;
	}
	/*BLI_freelistN(&layer->ibufs);*/
 
	MEM_freeN(layer);
}
 
ImageLayer *imalayer_get_current(Image *ima)
{
	ImageLayer *layer;
	if(ima==0)
		return 0;
 
	for(layer=ima->imlayers.first; layer; layer=layer->next){
		if(layer->flag & IMA_LAYER_CURRENT)
			return layer;
	}
 
	return 0;
}
 
short imalayer_get_current_num(Image *ima)
{
	ImageLayer *layer;
	short i;
 
	if(ima==0)
		return 0;
 
	for(layer=ima->imlayers.first, i=0; layer; layer=layer->next, i++)
		if(layer->flag & IMA_LAYER_CURRENT)
			return i;
 
	return i;
}
 
void imalayer_set_current_num(Image *ima, short index)
{
	ImageLayer *layer;
	short i;
 
	if(ima==0)
		return;
 
	for(layer=ima->imlayers.first, i=0; layer; layer=layer->next, i++) {
		if(i == index)
			layer->flag |= IMA_LAYER_CURRENT;
		else
			layer->flag &= ~IMA_LAYER_CURRENT;
	}
}
 
void imalayer_fill_color(struct Image *ima, float color[4])
{
	ImageLayer *layer= NULL;
	ImBuf *ibuf= NULL;
	unsigned char *rect= NULL;
	float *rect_float= NULL;
	void *lock;
 
	if (ima==NULL)
		return FALSE;
 
	ibuf= BKE_image_acquire_ibuf(ima, NULL, &lock);
 
 
	layer= imalayer_get_current(ima);
 
	if ((ibuf = ima->imlayers.first)) {
		if (ibuf->flags & IB_rectfloat) {
			rect_float= (float*)ibuf->rect_float;
		}
		else {
			rect= (unsigned char*)ibuf->rect;
		}
 
		//BKE_image_buf_fill_color(rect, rect_float, ibuf->x, ibuf->y, color);
	}
 
	BKE_image_release_ibuf(ima, lock);
}
 
int image_remove_current_image_layer(Image *ima)
{
	ImageLayer *layer= NULL;
 
	if(ima==NULL)
		return FALSE;
 
	layer= imalayer_get_current(ima);
 
	free_image_layer(layer);
 
	/* Ensure the first element in list gets selected (if any) */
	if(ima->imlayers.first)
		((ImageLayer *) ima->imlayers.first)->flag |= IMA_LAYER_CURRENT;
 
	return TRUE;
}
 
/* Works in most of the cases but since no unique name is nessecary, this is acceptable as a start. */
static void imalayer_unique_name(const ListBase *imlayers, ImageLayer *newlayer)
{
	char *new_name = 0;
	int new_len = 0;
	int suffix;
	ImageLayer *i;
	char *name = newlayer->name;
 
	/* When list is empty, there's no need to check name */
	if (!imlayers->first)
		return;
 
	/* Iterate over every list element and check */
	for(i=imlayers->first; i; i=i->next) {
 
		/* If names differ, go to next element */
		if(strcmp(name, i->name))
			continue;
 
		if(!new_name) {
			int len = strlen(name);
 
			if(len >= 4 && sscanf(name + len - 4, ".%03d", &suffix) == 1) {
				new_len = len;
			}
			else {
				suffix = 0;
				new_len = len + 4;
				if(new_len > 31)
					new_len = 31;
			}
 
			new_name = MEM_mallocN(new_len + 1, "new_name");
			strcpy(new_name, name);
			name = new_name;
		}
		sprintf(new_name + new_len - 4, ".%03d", ++suffix);
	}
 
	if(new_name) {
		strcpy(newlayer->name, new_name);
		MEM_freeN(new_name);
	}
}
 
int image_add_image_layer(Image *ima)
{
	ImageLayer *layer= NULL;
	ImBuf *ibuf, *imaibuf;
	float color[4] = {0.0f, 1.0f, 0.0f, 1.0f};
	void *lock;
 
	if(ima==NULL)
		return FALSE;
 
	ibuf= BKE_image_acquire_ibuf(ima, NULL, &lock);
 
	/* Deselect other layers */
	layer = ima->imlayers.first;
	for(; layer; layer=layer->next)
		layer->flag &= ~IMA_LAYER_CURRENT;
 
	layer= (ImageLayer*) MEM_callocN(sizeof(ImageLayer), "image_layer");
	layer->next = layer->prev = NULL;
 
	/*if(BLI_countlist(&ima->imlayers)>0)
		sprintf(layer->name, "ImageLayer %i", BLI_countlist(&ima->imlayers));
	else
		strcpy(layer->name, "ImageLayer");*/
 
	strcpy(layer->name, "ImageLayer");
	imalayer_unique_name(&ima->imlayers, layer);
 
	layer->opacity = 1.0f;
	layer->flag = IMA_LAYER_CURRENT;
 
	/* Get ImBuf from ima */
	imaibuf = (ImBuf*)ima->ibufs.first;
	ibuf = add_ibuf_size(imaibuf->x, imaibuf->y, layer->name, imaibuf->depth, imaibuf->flags, 0, color);
	BLI_addtail(&layer->ibufs, ibuf);
	BLI_addtail(&ima->imlayers, layer);
 
	BKE_image_release_ibuf(ima, lock);
 
	return TRUE;
}
 
/* TODO: (kwk) Base image layer needs proper locking... */
int image_add_image_layer_base(Image *ima)
{
	ImageLayer *layer= NULL;
	ImBuf *ibuf;
	void *lock;
 
	if(ima==NULL)
		return FALSE;
 
	ibuf= BKE_image_acquire_ibuf(ima, NULL, &lock);
 
	/* Deselect other layers */
	layer = ima->imlayers.first;
	for(; layer; layer=layer->next)
		layer->flag &= ~IMA_LAYER_CURRENT;
 
	layer= (ImageLayer*) MEM_callocN(sizeof(ImageLayer), "image_layer");
	layer->next = layer->prev = NULL;
 
	strcpy(layer->name, "BaseLayer");
	imalayer_unique_name(&ima->imlayers, layer);
 
	layer->opacity = 1.0f;
	layer->flag = IMA_LAYER_CURRENT | IMA_LAYER_BASE; /* BASE causes no free on deletion of layer */
 
	/* Get ImBuf from ima */
	ibuf = (ImBuf*)ima->ibufs.first;
	BLI_addtail(&layer->ibufs, ibuf);
	BLI_addtail(&ima->imlayers, layer);
 
	BKE_image_release_ibuf(ima, lock);
 
	return TRUE;
}