#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>

#include "toonz.h"
#include "tmsg.h"
#include "file.h"
#include "tiff.h"
#include "tiffio.h"
#include "version.h"
#include "history.h"
#include "colorsdb.h"
#include "ImageP/img_security.h"

#define LATEST_PLT_TYPE 4

static int Next_img_read_plt_without_buffer = FALSE;
static int Read_without_buffer = FALSE;
#define SET_READ_WITHOUT_BUFFER                                 \
	{                                                           \
		Read_without_buffer = Next_img_read_plt_without_buffer; \
		Next_img_read_plt_without_buffer = FALSE;               \
	}

#ifdef VECCHIA_MANIERA
static char *build_string_names(IMAGE *image);
static void set_color_names(IMAGE *image, char *names);
static char *plt_find_color_name(IMAGE *img, int color);
static char *plt_find_pencil_name(IMAGE *img, int color);
static void plt_set_color_name(IMAGE *img, int color, char *name);
static void plt_set_pencil_name(IMAGE *img, int pencil, char *name);
#endif

/*---------------------------------------------------------------------------*/

int img_write_plt(char *filename, IMAGE *image)
{
	TIFF *tfp;
	UCHAR *buffer;
	int i, j, scanline, width, rows_per_strip;
	LPIXEL *cmap, *color, *pencil;
	USHORT palette[TOONZPALETTE_COUNT];
	char *names, *history;
	int plt_type, cmap_size;

	CHECK_IMAGEDLL_LICENSE_AND_GET_IMG_LICENSE_ATTR

	names = NIL;

	if (image->type != CMAP)
		return FALSE;

	tfp = TIFFOpen(filename, "w");
	if (!tfp)
		return FALSE;

	plt_type = (image->cmap.offset > 0) ? 4 : 3;

	if (!image->cmap.info.n_colors) {
		assert(plt_type == 4);
		image->cmap.info = Tcm_old_default_info;
		image->cmap.info.n_colors = image->cmap.color_n;
		image->cmap.info.n_pencils = image->cmap.pencil_n;
		cmap_size = TCM_MIN_CMAP_BUFFER_SIZE(image->cmap.info);
	} else {
		cmap_size = TCM_CMAP_BUFFER_SIZE(image->cmap.info);
	}
	palette[0] = plt_type;
	palette[1] = image->cmap.offset;
	palette[2] = cmap_size <= 0xffff ? cmap_size : 0;
	palette[3] = 0 /* image->cmap.info.tone_offs */;
	palette[4] = image->cmap.info.tone_bits;
	palette[5] = image->cmap.info.color_offs;
	palette[6] = image->cmap.info.color_bits;
	palette[7] = image->cmap.info.pencil_offs;
	palette[8] = image->cmap.info.pencil_bits;
	palette[9] = image->cmap.info.offset_mask;
	palette[10] = image->cmap.info.n_colors;
	palette[11] = image->cmap.info.n_pencils;

	for (i = 12; i < TOONZPALETTE_COUNT - 1; i++)
		palette[i] = 0;

	palette[TOONZPALETTE_COUNT - 1] = (Img_license_attr & TA_TOONZ_EDU) != 0;

	TIFFSetField(tfp, TIFFTAG_TOONZPALETTE, palette);

	if (plt_type == 3) {
		assert(image->cmap.color && image->cmap.pencil);
		width = image->cmap.color_n + image->cmap.pencil_n;
	} else {
		if (image->cmap.color && image->cmap.pencil)
			width = cmap_size + image->cmap.color_n + image->cmap.pencil_n;
		else
			width = cmap_size;
	}
	TIFFSetField(tfp, TIFFTAG_BITSPERSAMPLE, 8);
	TIFFSetField(tfp, TIFFTAG_SAMPLESPERPIXEL, 4);
	TIFFSetField(tfp, TIFFTAG_IMAGEWIDTH, width);
	TIFFSetField(tfp, TIFFTAG_IMAGELENGTH, 1);
	TIFFSetField(tfp, TIFFTAG_COMPRESSION, COMPRESSION_NONE);
	TIFFSetField(tfp, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
	TIFFSetField(tfp, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_RGB);

#ifdef VECCHIA_MANIERA

	names_pointer = (TREE *)image->cmap.names;
	image->cmap.names = cdb_encode_names((TREE *)image->cmap.names,
										 &(image->cmap.names_max));
	str = build_string_names(image);
	names_string_pointer = (char *)image->cmap.names;
	image->cmap.names = (USHORT *)names_pointer;
	if (names_string_pointer)
		free(names_string_pointer);

#endif

	names = cdb_encode_all(image->cmap.names);

	TIFFSetField(tfp, TIFFTAG_TOONZCOLORNAMES, names);

	/* Aggiungo History */
	history = build_history();
	if (image->history) {
		switch (check_history(image->history, history)) {
			CASE APPEND : image->history = append_history(image->history, history);
			CASE REPLACE : image->history = replace_last_history(image->history, history);
		DEFAULT:
			printf("Internal error: bad history type; aborting...\n");
			abort();
		}
		free(history);
	} else
		image->history = history;

	TIFFSetField(tfp, TIFFTAG_TOONZHISTORY, image->history);

	scanline = TIFFScanlineSize(tfp);

	/*
 * massima lunghezza di bytes in una strip e' 8k 
 * vedi Graphics File Formats pag.48 
 */
	rows_per_strip = (8 * 1024) / scanline;

	TIFFSetField(tfp, TIFFTAG_ROWSPERSTRIP,
				 rows_per_strip == 0 ? 1L : rows_per_strip);

	TMALLOC(buffer, scanline);
	cmap = image->cmap.buffer;
	color = image->cmap.color;
	pencil = image->cmap.pencil;

	switch (plt_type) {
		CASE 1 : printf("img_rwite_plt error: type 1 .plt's are not written any more\n");
		abort();
		CASE 2 : __OR 4 : for (i = 0, j = 0; i < cmap_size; i++, j += 4)
		{
			buffer[j + 0] = cmap[i].r;
			buffer[j + 1] = cmap[i].g;
			buffer[j + 2] = cmap[i].b;
			buffer[j + 3] = cmap[i].m;
		}
		if (width > cmap_size) {
			for (i = 0; i < image->cmap.color_n; i++, j += 4) {
				buffer[j + 0] = color[i].r;
				buffer[j + 1] = color[i].g;
				buffer[j + 2] = color[i].b;
				buffer[j + 3] = color[i].m;
			}
			for (i = 0; i < image->cmap.pencil_n; i++, j += 4) {
				buffer[j + 0] = pencil[i].r;
				buffer[j + 1] = pencil[i].g;
				buffer[j + 2] = pencil[i].b;
				buffer[j + 3] = pencil[i].m;
			}
		}
		CASE 3 : for (i = 0, j = 0; i < image->cmap.color_n; i++, j += 4)
		{
			buffer[j + 0] = color[i].m; /* different from type 2 */
			buffer[j + 1] = color[i].b;
			buffer[j + 2] = color[i].g;
			buffer[j + 3] = color[i].r;
		}
		for (i = 0; i < image->cmap.pencil_n; i++, j += 4) {
			buffer[j + 0] = pencil[i].m;
			buffer[j + 1] = pencil[i].b;
			buffer[j + 2] = pencil[i].g;
			buffer[j + 3] = pencil[i].r;
		}
	DEFAULT:
		assert(!"bad palette type");
	}

	if (TIFFWriteScanline(tfp, buffer, 0, 0) < 0)
		goto bad;
	TFREE(buffer);
	TIFFClose(tfp);
	TFREE(names);
	return TRUE;

bad:
	TFREE(buffer);
	TIFFClose(tfp);
	TFREE(names);
	return FALSE;
}

/*===========================================================================*/

void next_img_read_plt_without_buffer(void)
{
	Next_img_read_plt_without_buffer = TRUE;
}

/*---------------------------------------------------------------------------*/

IMAGE *img_read_plt(char *filename)
{
	int with_cmap_buffer;
	IMAGE *image = NIL;
	TIFF *tfp;
	UCHAR *buffer = NIL;
	int i, j, scanline;
	LPIXEL *cmap;
	USHORT *palette; /*  [TOONZPALETTE_COUNT] */
	USHORT spp, bps, comp, plan_con, photom;
	int width, height;
	char *names;
	int plt_type, m, cmap_file_size, cmap_alloc_size;
	int colpen_cmap, colbuf_alloc_size, penbuf_alloc_size;
	int max_n_colors, max_n_pencils;
	int act_n_colors, act_n_pencils, index;
	LPIXEL grey, black;
	TBOOL edu_file;

	CHECK_IMAGEDLL_LICENSE_AND_GET_IMG_LICENSE_ATTR

	SET_READ_WITHOUT_BUFFER

	tfp = TIFFOpen(filename, "r");
	if (!tfp)
		return NIL;

	TIFFGetField(tfp, TIFFTAG_TOONZPALETTE, &palette);
	TIFFGetField(tfp, TIFFTAG_TOONZCOLORNAMES, &names);

	TIFFGetField(tfp, TIFFTAG_BITSPERSAMPLE, &bps);
	TIFFGetField(tfp, TIFFTAG_SAMPLESPERPIXEL, &spp);
	TIFFGetField(tfp, TIFFTAG_IMAGEWIDTH, &width);
	TIFFGetField(tfp, TIFFTAG_IMAGELENGTH, &height);
	TIFFGetField(tfp, TIFFTAG_COMPRESSION, &comp);
	TIFFGetField(tfp, TIFFTAG_PLANARCONFIG, &plan_con);
	TIFFGetField(tfp, TIFFTAG_PHOTOMETRIC, &photom);

	if (photom != PHOTOMETRIC_RGB || plan_con != PLANARCONFIG_CONTIG)
		goto bad;

	edu_file = palette[TOONZPALETTE_COUNT - 1] & 1;
	if (edu_file && !(Img_license_attr & TA_TOONZ_EDU)) {
		char str[1024];
		BUILD_EDU_ERROR_STRING(str)
		tmsg_error(str);
		goto bad;
	}

	scanline = TIFFScanlineSize(tfp);

	image = new_img();
	if (!image)
		goto bad;
	image->type = CMAP;

	/* Leggo history */
	if (!TIFFGetField(tfp, TIFFTAG_TOONZHISTORY, &image->history))
		image->history = "";
	image->history = strsave(image->history);

	plt_type = palette[0];
	image->cmap.offset = palette[1];
	image->cmap.color_n = palette[10];
	image->cmap.pencil_n = palette[11];

	image->cmap.info = Tcm_old_default_info;
	if (palette[6]) {
		/*image->cmap.info.tone_offs   = palette[3]; */
		image->cmap.info.tone_bits = palette[4];
		image->cmap.info.color_offs = palette[5];
		image->cmap.info.color_bits = palette[6];
		image->cmap.info.pencil_offs = palette[7];
		image->cmap.info.pencil_bits = palette[8];
		image->cmap.info.offset_mask = palette[9];
		image->cmap.info.n_tones = 1 << palette[4];
		image->cmap.info.n_colors = palette[10];
		image->cmap.info.n_pencils = palette[11];
	}
	image->cmap.info.default_val = (image->cmap.info.n_tones - 1) |
								   image->cmap.info.offset_mask;

	cmap_alloc_size = TCM_CMAP_BUFFER_SIZE(image->cmap.info);
	cmap_file_size = palette[2] ? palette[2] : cmap_alloc_size;
	colpen_cmap = image->cmap.info.n_tones > 16;
	colbuf_alloc_size = TCM_CMAP_COLBUFFER_SIZE(image->cmap.info);
	penbuf_alloc_size = TCM_CMAP_PENBUFFER_SIZE(image->cmap.info);

	TMALLOC(buffer, scanline);
	if (!buffer)
		goto bad;

	with_cmap_buffer = !Read_without_buffer || (plt_type <= 2) ||
					   (plt_type == 4);
	if (with_cmap_buffer) {
		if (colpen_cmap) {
			TMALLOC(image->cmap.colbuffer, colbuf_alloc_size);
			TMALLOC(image->cmap.penbuffer, penbuf_alloc_size);
			if (!image->cmap.colbuffer || !image->cmap.penbuffer)
				goto bad;
		} else {
			TMALLOC(image->cmap.buffer, cmap_alloc_size);
			if (!image->cmap.buffer)
				goto bad;
		}
	}
	TCALLOC(image->cmap.color, 1 << image->cmap.info.color_bits);
	if (!image->cmap.color)
		goto bad;
	TCALLOC(image->cmap.pencil, 1 << image->cmap.info.pencil_bits);
	if (!image->cmap.pencil)
		goto bad;

	if (TIFFReadScanline(tfp, buffer, 0, 0) < 0)
		goto bad;

	switch (plt_type) {
		CASE 1 : if (!with_cmap_buffer)
		{
			TCALLOC(image->cmap.buffer, cmap_alloc_size)
			if (!image->cmap.buffer)
				goto bad;
		}
		for (i = 0, j = 0; i < cmap_file_size; i++, j += 4) {
			image->cmap.buffer[i].r = buffer[j + 0];
			image->cmap.buffer[i].g = buffer[j + 1];
			image->cmap.buffer[i].b = buffer[j + 2];
		}
		to_new_cmap(&image->cmap);
		set_colors_and_pencils(&image->cmap);
		if (!with_cmap_buffer)
			TFREE(image->cmap.buffer)

		CASE 2 : __OR 4 : if (with_cmap_buffer) for (i = 0, j = 0; i < cmap_file_size; i++, j += 4)
		{
			image->cmap.buffer[i].r = buffer[j + 0];
			image->cmap.buffer[i].g = buffer[j + 1];
			image->cmap.buffer[i].b = buffer[j + 2];
			image->cmap.buffer[i].m = buffer[j + 3];
		}
		else j = 4 * cmap_file_size;

		if (width > cmap_file_size) {
			for (i = 0; i < image->cmap.color_n; i++, j += 4) {
				image->cmap.color[i].r = buffer[j + 0];
				image->cmap.color[i].g = buffer[j + 1];
				image->cmap.color[i].b = buffer[j + 2];
				image->cmap.color[i].m = buffer[j + 3];
			}
			for (i = 0; i < image->cmap.pencil_n; i++, j += 4) {
				image->cmap.pencil[i].r = buffer[j + 0];
				image->cmap.pencil[i].g = buffer[j + 1];
				image->cmap.pencil[i].b = buffer[j + 2];
				image->cmap.pencil[i].m = buffer[j + 3];
			}
		} else
			set_colors_and_pencils(&image->cmap);

		CASE 3 : for (i = 0, j = 0; i < image->cmap.color_n; i++, j += 4)
		{
			image->cmap.color[i].m = buffer[j + 0]; /* different from type 2 */
			image->cmap.color[i].b = buffer[j + 1];
			image->cmap.color[i].g = buffer[j + 2];
			image->cmap.color[i].r = buffer[j + 3];
		}
		for (i = 0; i < image->cmap.pencil_n; i++, j += 4) {
			image->cmap.pencil[i].m = buffer[j + 0];
			image->cmap.pencil[i].b = buffer[j + 1];
			image->cmap.pencil[i].g = buffer[j + 2];
			image->cmap.pencil[i].r = buffer[j + 3];
		}
		if (with_cmap_buffer)
			if (colpen_cmap) {
				memset(image->cmap.colbuffer, 0, colbuf_alloc_size * sizeof(LPIXEL));
				memset(image->cmap.penbuffer, 0, penbuf_alloc_size * sizeof(LPIXEL));
				fill_cmap_colbuffer(image->cmap.colbuffer, image->cmap.info,
									image->cmap.color, FALSE);
				fill_cmap_penbuffer(image->cmap.penbuffer, image->cmap.info,
									image->cmap.pencil, FALSE);
			} else {
				memset(image->cmap.buffer, 0, cmap_alloc_size * sizeof(LPIXEL));
				fill_cmap_buffer(image->cmap.buffer, image->cmap.info,
								 image->cmap.color, image->cmap.pencil, FALSE);
			}
	DEFAULT:
		goto bad;
	}

#ifdef VECCHIA_MANIERA

	set_color_names(image, names);
	names_pointer = image->cmap.names;
	image->cmap.names = (USHORT *)cdb_decode_names(image->cmap.names,
												   image->cmap.names_max);
	TFREE(names_pointer);

#endif

	image->cmap.names = cdb_decode_all(names, image->cmap.info);

	/* estendo la palette */

	max_n_colors = 1 << image->cmap.info.color_bits;
	max_n_pencils = 1 << image->cmap.info.pencil_bits;
	if (max_n_colors > image->cmap.info.n_colors ||
		max_n_pencils > image->cmap.info.n_pencils) {
		act_n_colors = image->cmap.info.n_colors;
		act_n_pencils = image->cmap.info.n_pencils;
		image->cmap.info.n_colors = max_n_colors;
		image->cmap.info.n_pencils = max_n_pencils;
		image->cmap.color_n = image->cmap.info.n_colors;
		image->cmap.pencil_n = image->cmap.info.n_pencils;
		grey.r = grey.g = grey.b = 127;
		grey.m = 255;
		black.r = black.g = black.b = 0;
		black.m = 255;
		for (i = act_n_colors; i < max_n_colors; i++) {
			image->cmap.color[i] = grey;
			index = TCM_COLOR_INDEX(image->cmap.info, i);
			cdb_set_group(image, index, UNUSED_COLOR_PAGE_NAME);
			if (with_cmap_buffer && colpen_cmap)
				fill_cmap_colramp(image->cmap.colbuffer, image->cmap.info,
								  image->cmap.color[i], i, FALSE);
		}
		for (i = act_n_pencils; i < max_n_pencils; i++) {
			image->cmap.pencil[i] = black;
			index = TCM_PENCIL_INDEX(image->cmap.info, i);
			cdb_set_group(image, index, UNUSED_COLOR_PAGE_NAME);
			if (with_cmap_buffer && colpen_cmap)
				fill_cmap_penramp(image->cmap.penbuffer, image->cmap.info,
								  image->cmap.pencil[i], i, FALSE);
		}
		if (with_cmap_buffer && !colpen_cmap)
			fill_cmap_buffer(image->cmap.buffer, image->cmap.info,
							 image->cmap.color, image->cmap.pencil, FALSE);
	}

	if (buffer)
		TFREE(buffer);
	TIFFClose(tfp);
	return image;

bad:
	if (image)
		free_img(image);
	TFREE(buffer);
	TIFFClose(tfp);
	return NIL;
}

/*---------------------------------------------------------------------------*/

IMAGE *img_read_plt_info(char *filename)
{
	IMAGE *image = NIL;
	TIFF *tfp;
	USHORT *palette; /*  [TOONZPALETTE_COUNT] */
	USHORT plan_con, photom;
	char *names;
	int max_n_colors, max_n_pencils;
	TBOOL edu_file;

	CHECK_IMAGEDLL_LICENSE_AND_GET_IMG_LICENSE_ATTR

	tfp = TIFFOpen(filename, "r");
	if (!tfp)
		return NIL;

	TIFFGetField(tfp, TIFFTAG_TOONZPALETTE, &palette);
	TIFFGetField(tfp, TIFFTAG_TOONZCOLORNAMES, &names);
	TIFFGetField(tfp, TIFFTAG_PLANARCONFIG, &plan_con);
	TIFFGetField(tfp, TIFFTAG_PHOTOMETRIC, &photom);

	if (photom != PHOTOMETRIC_RGB || plan_con != PLANARCONFIG_CONTIG)
		goto bad;

	edu_file = palette[TOONZPALETTE_COUNT - 1] & 1;
	if (edu_file && !(Img_license_attr & TA_TOONZ_EDU)) {
		char str[1024];
		BUILD_EDU_ERROR_STRING(str)
		tmsg_warning(str);
	}

	image = new_img();
	if (!image)
		goto bad;
	image->type = CMAP;

	if (palette[0] < 1 || palette[0] > LATEST_PLT_TYPE)
		goto bad;

	image->cmap.offset = palette[1];
	image->cmap.color_n = palette[10];
	image->cmap.pencil_n = palette[11];

	image->cmap.info = Tcm_old_default_info;
	if (palette[6]) {
		/*image->cmap.info.tone_offs   = palette[3]; */
		image->cmap.info.tone_bits = palette[4];
		image->cmap.info.color_offs = palette[5];
		image->cmap.info.color_bits = palette[6];
		image->cmap.info.pencil_offs = palette[7];
		image->cmap.info.pencil_bits = palette[8];
		image->cmap.info.offset_mask = palette[9];
		image->cmap.info.n_tones = 1 << palette[4];
		image->cmap.info.n_colors = palette[10];
		image->cmap.info.n_pencils = palette[11];
	}
	image->cmap.info.default_val = (image->cmap.info.n_tones - 1) |
								   image->cmap.info.offset_mask;

	/* Leggo history */
	if (!TIFFGetField(tfp, TIFFTAG_TOONZHISTORY, &image->history))
		image->history = "";
	image->history = strsave(image->history);

	/* estendo la palette */

	max_n_colors = 1 << image->cmap.info.color_bits;
	max_n_pencils = 1 << image->cmap.info.pencil_bits;
	if (max_n_colors > image->cmap.info.n_colors ||
		max_n_pencils > image->cmap.info.n_pencils) {
		image->cmap.info.n_colors = max_n_colors;
		image->cmap.info.n_pencils = max_n_pencils;
		image->cmap.color_n = image->cmap.info.n_colors;
		image->cmap.pencil_n = image->cmap.info.n_pencils;
	}

	image->cmap.names = cdb_decode_all(names, image->cmap.info);

	TIFFClose(tfp);
	return image;

bad:
	if (image)
		free_img(image);
	TIFFClose(tfp);
	return NIL;
}

/*---------------------------------------------------------------------------*/
/* Attenzione: se si modifica questa funzione, occore riportare le
 *             variazioni nella libreria line x line (simg_plt.c)
 */

#ifdef VECCHIA_MANIERA

static char *plt_find_color_name(IMAGE *img, int color)
{
	char *name;
	int index;

	index = TCM_COLOR_INDEX(img->cmap.info, color);
	name = find_color_name(img, index);

	return name;
}

#endif

/*---------------------------------------------------------------------------*/
/* Attenzione: se si modifica questa funzione, occore riportare le
 *             variazioni nella libreria line x line (simg_plt.c)
 */

#ifdef VECCHIA_MANIERA

static char *plt_find_pencil_name(IMAGE *img, int pencil)
{
	char *name;
	int index;

	index = TCM_PENCIL_INDEX(img->cmap.info, pencil);
	name = find_color_name(img, index);

	return name;
}

#endif

/*---------------------------------------------------------------------------*/
/* Attenzione: se si modifica questa funzione, occore riportare le
 *             variazioni nella libreria line x line (simg_plt.c)
 */

#ifdef VECCHIA_MANIERA

static void plt_set_color_name(IMAGE *img, int color, char *name)
{
	int index;

	index = TCM_COLOR_INDEX(img->cmap.info, color);
	set_color_name(img, index, name);
}

#endif

/*---------------------------------------------------------------------------*/
/* Attenzione: se si modifica questa funzione, occore riportare le
 *             variazioni nella libreria line x line (simg_plt.c)
 */

#ifdef VECCHIA_MANIERA

static void plt_set_pencil_name(IMAGE *img, int pencil, char *name)
{
	int index;

	index = TCM_PENCIL_INDEX(img->cmap.info, pencil);
	set_color_name(img, index, name);
}

#endif

/*---------------------------------------------------------------------------*/
/* Attenzione: se si modifica questa funzione, occore riportare le
 *             variazioni nella libreria line x line (simg_plt.c)
 */

#ifdef VECCHIA_MANIERA

static char *build_string_names(IMAGE *image)
{
	char *str, *name;
	int i, maxsize = 1000, ptr, len;

	str = (char *)malloc(maxsize);
	ptr = 0;

	for (i = 0; i < image->cmap.color_n; i++) {
		name = plt_find_color_name(image, i);
		if (name && *name) {
			len = strlen(name);
			if ((len + ptr) >= maxsize) {
				maxsize += 200;
				str = (char *)realloc(str, maxsize);
			}
			memmove(str + ptr, name, len);
			ptr += len;
		}
		if (ptr + 1 >= maxsize) {
			maxsize += 200;
			str = (char *)realloc(str, maxsize);
		}
		memmove(str + ptr, "|", 1);
		ptr++;
	}

	for (i = 0; i < image->cmap.pencil_n; i++) {
		name = plt_find_pencil_name(image, i);
		if (name && *name) {
			len = strlen(name);
			if ((len + ptr) >= maxsize) {
				maxsize += 200;
				str = (char *)realloc(str, maxsize);
			}
			memmove(str + ptr, name, len);
			ptr += len;
		}
		if (ptr + 1 >= maxsize) {
			maxsize += 200;
			str = (char *)realloc(str, maxsize);
		}
		memmove(str + ptr, "|", 1);
		ptr++;
	}

	str[ptr] = 0;
	return str;
}

#endif

/*---------------------------------------------------------------------------*/
/* Attenzione: se si modifica questa funzione, occore riportare le
 *             variazioni nella libreria line x line (simg_plt.c)
 */

#ifdef VECCHIA_MANIERA

static void set_color_names(IMAGE *image, char *names)
{
	int i;
	char *s, *name;

	s = names;
	i = 0;
	while (*s) {
		name = NULL;
		if (*s != '|') {
			name = s;
			while (*s && *s != '|')
				s++;
			*s = 0;
		}

		if (name) {
			if (i < image->cmap.info.n_colors)
				plt_set_color_name(image, i, name);
			else
				plt_set_pencil_name(image, i - image->cmap.info.n_colors, name);
		}
		i++;
		s++;
	}
}

#endif