#include <stdio.h></stdio.h>

#include <stdlib.h></stdlib.h>

#include <string.h></string.h>

#include <assert.h></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