gdyntext.c

GIMP Dynamic Text是GIMP的插件程序

	}

	/* change the layer name as in GIMP 1.x */
	gimp_layer_set_name(data->layer_id, lname);
	gimp_displays_flush();
	g_free(lname);
}


void gdt_render_text(GdtVals *data)
{
	gdt_render_text_p(data, TRUE);
}


void gdt_render_text_p(GdtVals *data, gboolean show_progress)
{
	gint layer_ox, layer_oy, i, nret_vals, xoffs;
	gint32 layer_f, selection_empty, selection_channel;
	gint32 text_width, text_height;
  gint32 text_ascent, text_descent;
  gint32 layer_width, layer_height;
  gint32 image_width, image_height;
	gint32 space_width;
	gfloat font_size;
	gint32 font_size_type;
	gchar **text_xlfd, **text_lines;
	gint32 *text_lines_w;
	GParam *ret_vals;
	GParamColor old_color, text_color;

	if (show_progress)
		gimp_progress_init("GIMP Dynamic Text");

	/* undo start */
	ret_vals = gimp_run_procedure("gimp_undo_push_group_start", &nret_vals,
		PARAM_IMAGE, gdtvals.image_id, PARAM_END);
	gimp_destroy_params(ret_vals, nret_vals);

	/* save and remove current selection */
	ret_vals = gimp_run_procedure("gimp_selection_is_empty", &nret_vals,
		PARAM_IMAGE, data->image_id, PARAM_END);
	selection_empty = ret_vals[1].data.d_int32;
	gimp_destroy_params(ret_vals, nret_vals);
	if (selection_empty == FALSE) {
		/* there is an active selection to save */
		ret_vals = gimp_run_procedure("gimp_selection_save", &nret_vals,
			PARAM_IMAGE, data->image_id, PARAM_END);
		selection_channel = ret_vals[1].data.d_int32;
		gimp_destroy_params(ret_vals, nret_vals);
		ret_vals = gimp_run_procedure("gimp_selection_none", &nret_vals,
			PARAM_IMAGE, data->image_id, PARAM_END);
		gimp_destroy_params(ret_vals, nret_vals);
	}

	text_xlfd = g_strsplit(data->xlfd, "-", -1);
	if (!strlen(text_xlfd[XLFD_PIXEL_SIZE]) ||
		!strcmp(text_xlfd[XLFD_PIXEL_SIZE], "*"))
	{
		font_size = atof(text_xlfd[XLFD_POINT_SIZE]);
		font_size_type = FONT_METRIC_POINTS;
	} else {
		font_size = atof(text_xlfd[XLFD_PIXEL_SIZE]);
		font_size_type = FONT_METRIC_PIXELS;
	}
	g_strfreev(text_xlfd);

	/* retrieve space char width */
	ret_vals = gimp_run_procedure("gimp_text_get_extents_fontname", &nret_vals,
		PARAM_STRING, "A A",
		PARAM_FLOAT, font_size,
		PARAM_INT32, font_size_type,
		PARAM_STRING, data->xlfd,
		PARAM_END);
	space_width = ret_vals[1].data.d_int32;
	gimp_destroy_params(ret_vals, nret_vals);
	ret_vals = gimp_run_procedure("gimp_text_get_extents_fontname", &nret_vals,
		PARAM_STRING, "AA",
		PARAM_FLOAT, font_size,
		PARAM_INT32, font_size_type,
		PARAM_STRING, data->xlfd,
		PARAM_END);
	space_width -= ret_vals[1].data.d_int32;
	gimp_destroy_params(ret_vals, nret_vals);
#ifdef DEBUG
	printf("GDT: space width = %d\n", space_width);
#endif
	
	/* setup text and compute layer size */
	text_lines = g_strsplit(data->text, "\n", -1);
	for (i = 0; text_lines[i]; i++);
	text_lines_w = g_new0(gint32, i);
	layer_width = layer_height = 0;
	for (i = 0; text_lines[i]; i++) {
		ret_vals = gimp_run_procedure("gimp_text_get_extents_fontname", &nret_vals,
			PARAM_STRING, strlen(text_lines[i]) > 0 ? text_lines[i] : " ",
			PARAM_FLOAT, font_size,
			PARAM_INT32, font_size_type,
			PARAM_STRING, data->xlfd,
			PARAM_END);
		text_width = ret_vals[1].data.d_int32;
		text_height = ret_vals[2].data.d_int32;
		text_ascent = ret_vals[3].data.d_int32;
		text_descent = ret_vals[4].data.d_int32;
#ifdef DEBUG
    printf("GDT: %4dx%4d A:%3d D:%3d [%s]\n", text_width, text_height, text_ascent, text_descent, text_lines[i]);
#endif
		gimp_destroy_params(ret_vals, nret_vals);
		text_lines_w[i] = text_width;
		if (layer_width < text_width)
			layer_width = text_width;
		layer_height += text_height + data->line_spacing;
	}
	layer_height -= data->line_spacing;

	if (layer_height == 0) layer_height = 10;
	if (layer_width == 0) layer_width = 10;
	if (!data->new_layer) {
		/* resize the old layer */
		gimp_layer_resize(data->layer_id, layer_width, layer_height, 0, 0);
	} else {
		/* create a new layer */
		data->layer_id = data->drawable_id = gimp_layer_new(data->image_id,
			_("GDynText Layer "), layer_width, layer_height,
			(GDrawableType)(gimp_image_base_type(data->image_id) * 2 + 1),
			100.0, NORMAL_MODE);
		gimp_layer_add_alpha(data->layer_id);
		gimp_image_add_layer(data->image_id, data->layer_id, 0);
		gimp_image_set_active_layer(data->image_id, data->layer_id);
	}

	/* clear layer */
	gimp_layer_set_preserve_transparency(data->layer_id, 0);
	ret_vals = gimp_run_procedure("gimp_edit_clear", &nret_vals,
		PARAM_DRAWABLE, data->drawable_id,
		PARAM_END);
	gimp_destroy_params(ret_vals, nret_vals);

	/* get layer offsets */
	gimp_drawable_offsets(data->layer_id, &layer_ox, &layer_oy);

	/* get foreground color */
	ret_vals = gimp_run_procedure("gimp_palette_get_foreground", &nret_vals,
		PARAM_END);
	memcpy(&old_color, &ret_vals[1].data.d_color, sizeof(GParamColor));
	gimp_destroy_params(ret_vals, nret_vals);

	/* set foreground color to the wanted text color */
	text_color.red = (data->color & 0xff0000) >> 16;
	text_color.green = (data->color & 0xff00) >> 8;
	text_color.blue = data->color & 0xff;
	ret_vals = gimp_run_procedure("gimp_palette_set_foreground", &nret_vals,
		PARAM_COLOR, &text_color,
		PARAM_END);
	gimp_destroy_params(ret_vals, nret_vals);

	/* write text */
	for (i = 0; text_lines[i]; i++) {
		switch (data->alignment) {
			case LEFT:
				xoffs = 0;
				break;
			case RIGHT:
				xoffs = layer_width - text_lines_w[i];
				break;
			case CENTER:
				xoffs = (layer_width - text_lines_w[i]) / 2;
				break;
			default:
				xoffs = 0;
		}
		ret_vals = gimp_run_procedure("gimp_text_fontname", &nret_vals,
			PARAM_IMAGE, data->image_id,
			PARAM_DRAWABLE, data->drawable_id,
			PARAM_FLOAT, (gdouble)layer_ox + 
				strspn(text_lines[i], " ") * space_width + xoffs,	/* x */
			PARAM_FLOAT, (gdouble)layer_oy + i * (text_height + data->line_spacing),		/* y */
			PARAM_STRING, text_lines[i],
			PARAM_INT32, 0,																			/* border */
			PARAM_INT32, data->antialias,
			PARAM_FLOAT, font_size,
			PARAM_INT32, font_size_type,
			PARAM_STRING, data->xlfd,
			PARAM_END);
		layer_f = ret_vals[1].data.d_layer;
		gimp_destroy_params(ret_vals, nret_vals);
		
		/* FIXME: ascent/descent stuff, use gimp_layer_translate */
#ifdef DEBUG
		printf("GDT: MH:%d LH:%d\n", text_height, gimp_drawable_height(layer_f));
#endif

		ret_vals = gimp_run_procedure("gimp_floating_sel_anchor", &nret_vals,
			PARAM_LAYER, layer_f,
			PARAM_END);
		gimp_destroy_params(ret_vals, nret_vals);
		if (show_progress)
			gimp_progress_update((double)(i + 2) * 100.0 * (double)text_height /
				(double)layer_height);
	}
	g_strfreev(text_lines);
	g_free(text_lines_w);

	/* set foreground color to the old one */
	ret_vals = gimp_run_procedure("gimp_palette_set_foreground", &nret_vals,
		PARAM_COLOR, &old_color,
		PARAM_END);
	gimp_destroy_params(ret_vals, nret_vals);

	/* apply rotation */
	if (data->rotation != 0 && abs(data->rotation) != 360) {
		ret_vals = gimp_run_procedure("gimp_rotate", &nret_vals,
			PARAM_DRAWABLE, data->drawable_id,
			PARAM_INT32, TRUE,
			PARAM_FLOAT, (double)data->rotation * M_PI / 180.0,
			PARAM_END);
		gimp_destroy_params(ret_vals, nret_vals);
		gimp_layer_set_offsets(data->layer_id, layer_ox, layer_oy);
	}

	/* sets the layer alignment */
	layer_width = gimp_drawable_width(data->drawable_id);
	layer_height = gimp_drawable_height(data->drawable_id);
	image_width = gimp_image_width(data->image_id);
	image_height = gimp_image_height(data->image_id);
	switch (data->layer_alignment) {
	case LA_TOP_LEFT:
		gimp_layer_set_offsets(data->layer_id, 0, 0);
		break;
	case LA_TOP_CENTER:
		gimp_layer_set_offsets(data->layer_id, (image_width - layer_width) >> 1, 0);
		break;
	case LA_TOP_RIGHT:
		gimp_layer_set_offsets(data->layer_id, image_width - layer_width, 0);
		break;
	case LA_MIDDLE_LEFT:
		gimp_layer_set_offsets(data->layer_id, 0,
			(image_height - layer_height) >> 1);
		break;
	case LA_CENTER:
		gimp_layer_set_offsets(data->layer_id, (image_width - layer_width) >> 1,
			(image_height - layer_height) >> 1);
		break;
	case LA_MIDDLE_RIGHT:
		gimp_layer_set_offsets(data->layer_id, image_width - layer_width,
			(image_height - layer_height) >> 1);
		break;
	case LA_BOTTOM_LEFT:
		gimp_layer_set_offsets(data->layer_id, 0, image_height - layer_height);
		break;
	case LA_BOTTOM_CENTER:
		gimp_layer_set_offsets(data->layer_id, (image_width - layer_width) >> 1,
			image_height - layer_height);
		break;
	case LA_BOTTOM_RIGHT:
		gimp_layer_set_offsets(data->layer_id, image_width - layer_width,
			image_height - layer_height);
		break;
	case LA_NONE:
	default:
	}

	gimp_layer_set_preserve_transparency(data->layer_id, 1);

	/* restore old selection if any */
	if (selection_empty == FALSE) {
		ret_vals = gimp_run_procedure("gimp_selection_load", &nret_vals,
			PARAM_IMAGE, data->image_id,
			PARAM_CHANNEL, selection_channel, PARAM_END);
		gimp_destroy_params(ret_vals, nret_vals);
		gimp_image_remove_channel(data->image_id, selection_channel);
	}

	gdt_save(data);

	/* undo end */
	ret_vals = gimp_run_procedure("gimp_undo_push_group_end", &nret_vals,
		PARAM_IMAGE, gdtvals.image_id, PARAM_END);
	gimp_destroy_params(ret_vals, nret_vals);

	if (show_progress)
		gimp_progress_update(100.0);

	gimp_displays_flush();
}

/* vim: set ts=2 sw=2 tw=79 ai nowrap: */