text: 
  
  #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
  