gdyntext.c

GIMP Dynamic Text是GIMP的插件程序

/*
 * GIMP Dynamic Text -- This is a plug-in for The GIMP 1.0
 * Copyright (C) 1998,1999,2000 Marco Lamberto <[e-mail]>
 * Web page: http://www.geocities.com/Tokyo/1474/gimp/
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 *
 * $Id: gdyntext.c,v 1.31 2000/06/04 13:44:10 lm Exp lm $
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <ctype.h>
#include <gtk/gtk.h>
#include "gdyntext.h"
#include "font_selection.h"


static void gdt_query(void);
static void gdt_run(char *name, int nparams, GParam *param, int *nreturn_vals, GParam **return_vals);


GPlugInInfo PLUG_IN_INFO = 
{
	NULL,
	NULL,
	gdt_query,
	gdt_run
};

GdtVals gdtvals;


#ifndef DEBUG_UI
MAIN()
#endif


static void gdt_query(void)
{
	INIT_I18N_UI();

	{
		static GParamDef gdt_args[] = {
			/* standard params */
			{ PARAM_INT32,		_("run_mode"),				_("Interactive, non-interactive")},
			{ PARAM_IMAGE,		_("image"),						_("Input image") },
			{ PARAM_DRAWABLE,	_("drawable"),				_("Input drawable")},
			/* gdyntext params */
			{ PARAM_STRING,		_("text"),						_("Text to render")},
			{ PARAM_INT32,		_("antialias"),				_("Generate antialiased text")},
			{ PARAM_INT32,		_("alignment"),				_("Text alignment: { LEFT = 0, CENTER = 1, RIGHT = 2 }")},
			{ PARAM_INT32,		_("rotation"),				_("Text rotation (degrees)")},
			{ PARAM_INT32,		_("line_spacing"),		_("Line spacing")},
			{ PARAM_COLOR,		_("color"),						_("Text color")},
			{ PARAM_INT32,		_("layer_alignment"),	_("Layer alignment { NONE = 0, BOTTOM_LEFT = 1, BOTTOM_CENTER = 2, BOTTOM_RIGHT = 3, MIDDLE_LEFT = 4, CENTER = 5, MIDDLE_RIGHT = 6, TOP_LEFT = 7, TOP_CENTER = 8, TOP_RIGHT = 9 }")},
			{ PARAM_STRING,		_("fontname"),				_("The fontname (conforming to the X Logical Font Description Conventions)")},
		};
		static GParamDef gdt_rets[] = {
			{ PARAM_LAYER,		"layer",				_("The text layer")},
		};
		static int ngdt_args = sizeof(gdt_args) / sizeof(gdt_args[0]);
		static int ngdt_rets = sizeof(gdt_rets) / sizeof(gdt_rets[0]);

		gimp_install_procedure("plug_in_dynamic_text",
			_("GIMP Dynamic Text"),
			_(""),
			"Marco Lamberto <[e-mail]>",
			"Marco Lamberto",
			_("Jan 1999"),
			_("<Image>/Filters/Render/Dynamic Text..."),
			"RGB*,GRAY*,INDEXED*",
			PROC_PLUG_IN,
			ngdt_args, ngdt_rets, gdt_args, gdt_rets);
	}
}


static void gdt_run(char *name, int nparams, GParam *param, int *nreturn_vals,
	GParam **return_vals)
{
	static GParam values[2];
	GRunModeType run_mode;
	GdtVals oldvals;


	INIT_I18N_UI();

	gdtvals.valid							= TRUE;
	gdtvals.change_layer_name	= FALSE;
	run_mode									= param[0].data.d_int32;
	gdtvals.image_id					= param[1].data.d_image;
	gdtvals.drawable_id				= param[2].data.d_drawable;
	gdtvals.layer_id					= param[2].data.d_layer;
	gdtvals.messages					= NULL;
	gdtvals.preview						= TRUE;
	
	*nreturn_vals = 2;
	*return_vals = values;
	
	values[0].type = PARAM_STATUS;
	values[0].data.d_status = STATUS_SUCCESS;
	values[1].type = PARAM_LAYER;
	values[1].data.d_int32 = -1;

	switch(run_mode) {
		case RUN_INTERACTIVE:
			memset(&oldvals, 0, sizeof(GdtVals));
			gimp_get_data("plug_in_gdyntext", &oldvals);
			if (oldvals.valid) {
				strncpy(gdtvals.text, oldvals.text, sizeof(gdtvals.text));
				strncpy(gdtvals.xlfd, oldvals.xlfd, sizeof(gdtvals.xlfd));
				gdtvals.color						= oldvals.color;
				gdtvals.antialias				= oldvals.antialias;
				gdtvals.alignment				= oldvals.alignment;
				gdtvals.rotation				= oldvals.rotation;
				gdtvals.line_spacing		= oldvals.line_spacing;
				gdtvals.layer_alignment	= oldvals.layer_alignment;
				gdtvals.preview					= oldvals.preview;
			}
			gdt_load(&gdtvals);
			if (!gdt_create_ui(&gdtvals))
				return;
			break;
		case RUN_NONINTERACTIVE:
#ifdef DEBUG
			printf("%d\n", nparams);
#endif
			if (nparams != 11) {
				values[0].data.d_status = STATUS_CALLING_ERROR;
				return;
			} else {
				gdtvals.new_layer	= !gimp_drawable_has_alpha(gdtvals.drawable_id);
				strncpy(gdtvals.text, param[3].data.d_string, sizeof(gdtvals.text));
				gdtvals.antialias				= param[4].data.d_int32;
				gdtvals.alignment				= param[5].data.d_int32;
				gdtvals.rotation				= param[6].data.d_int32;
				gdtvals.line_spacing		= param[7].data.d_int32;
				gdtvals.color 					=
					(param[8].data.d_color.red << 16) +
					(param[8].data.d_color.green << 8) +
					param[8].data.d_color.blue;
				gdtvals.layer_alignment	= param[9].data.d_int32;
				strncpy(gdtvals.xlfd, param[10].data.d_string, sizeof(gdtvals.xlfd));
			}
			break;
		case RUN_WITH_LAST_VALS:
			gimp_get_data("plug_in_gdyntext", &gdtvals);
			gdtvals.image_id		= param[1].data.d_image;
			gdtvals.drawable_id	= param[2].data.d_drawable;
			gdtvals.layer_id		= param[2].data.d_layer;
			gdtvals.new_layer		= !gimp_drawable_has_alpha(gdtvals.drawable_id);
			break;
	}

	gdt_render_text(&gdtvals);

	if (run_mode == RUN_INTERACTIVE)
		gimp_set_data("plug_in_gdyntext", &gdtvals, sizeof(GdtVals));
	values[1].data.d_int32 = gdtvals.layer_id; 
}


void gdt_load(GdtVals *data)
{
	gchar *gdtparams = NULL;
	gchar *gdtparams0 = NULL;
	gchar **params = NULL;
	GimpParasite *parasite = NULL;

	
	if (gdt_compat_load(data))
		return;

	if ((parasite = gimp_drawable_parasite_find(data->drawable_id,
		GDYNTEXT_PARASITE)) != NULL)
	{
		gdtparams = g_strdup(gimp_parasite_data(parasite));
		gimp_parasite_free(parasite);
	}

	if (gdtparams == NULL)
		gdtparams = gimp_layer_get_name(data->layer_id);

	if (!gimp_drawable_has_alpha(data->drawable_id) ||
		strncmp(gdtparams, "GDT", 3) != 0)
	{
		data->messages = g_list_append(data->messages, _(
			" Current layer isn't a GDynText layer or it has no alpha channel."
			" Forcing new layer creation."));
		data->new_layer = TRUE;
		/*
		strcpy(data->text, "");
		strcpy(data->xlfd, "");
		{
			GParam *ret_vals;
			gint nret_vals;

			ret_vals = gimp_run_procedure("gimp_palette_get_foreground", &nret_vals,
				PARAM_END);
			data->color =
				(ret_vals[1].data.d_color.red << 16) +
				(ret_vals[1].data.d_color.green << 8) +
				ret_vals[1].data.d_color.blue;
			gimp_destroy_params(ret_vals, nret_vals);
		}
		data->antialias				= TRUE;
		data->alignment 			= LEFT;
		data->rotation				= 0;
		data->line_spacing		= 0;
		data->layer_alignment	= LA_NONE;
		*/
		return;
	}

#ifdef DEBUG
	printf("'%s'\n", gdtparams);
#endif
	{
		gchar *st;
		int len;

		st = strchr(gdtparams, '{') + 1;
		len = strrchr(st, '}') - st;
		gdtparams0 = g_strndup(st, len);
	}
#ifdef DEBUG
	printf("'%s'\n", gdtparams0);
#endif
	params = g_strsplit(gdtparams0, "}{", -1);
	g_free(gdtparams0);

	data->new_layer				= FALSE;
	data->antialias				= atoi(params[ANTIALIAS]);
	data->alignment				= atoi(params[ALIGNMENT]);
	data->rotation				= atoi(params[ROTATION]);
	data->line_spacing		= atoi(params[LINE_SPACING]);
	data->layer_alignment	= atoi(params[LAYER_ALIGNMENT]);
	data->color						= strtol(params[COLOR], (char **)NULL, 16);

	strncpy(data->xlfd, params[XLFD], sizeof(data->xlfd));
	strncpy(data->text, params[TEXT], sizeof(data->text));
	{
		gchar *text = strunescape(data->text);
		g_snprintf(data->text, sizeof(data->text), "%s", text);
		g_free(text);
	}
	g_free(gdtparams);
	g_strfreev(params);
}


void gdt_save(GdtVals *data)
{
	gchar *lname, *text;
	GimpParasite *parasite;

	text = strescape(data->text);
	lname = g_strdup_printf(GDYNTEXT_MAGIC
		"{%s}{%d}{%d}{%d}{%d}{%06X}{%d}{%s}",
		text,
		data->antialias, data->alignment, data->rotation, data->line_spacing,
		data->color, data->layer_alignment, data->xlfd);
	g_free(text);

	parasite = gimp_parasite_new(GDYNTEXT_PARASITE,
		PARASITE_PERSISTENT | PARASITE_UNDOABLE, strlen(lname), lname);
	gimp_drawable_attach_parasite(data->drawable_id, parasite);
	gimp_parasite_free(parasite);

	if (!data->change_layer_name) {
		gimp_layer_set_name(data->layer_id, _("GDynText Layer "));
		gimp_displays_flush();
		g_free(lname);
		return;