gimp r25368 - in trunk: . app/pdb libgimp tools/pdbgen/pdb
- From: mitch svn gnome org
- To: svn-commits-list gnome org
- Subject: gimp r25368 - in trunk: . app/pdb libgimp tools/pdbgen/pdb
- Date: Fri, 4 Apr 2008 16:42:51 +0100 (BST)
Author: mitch
Date: Fri Apr 4 16:42:50 2008
New Revision: 25368
URL: http://svn.gnome.org/viewvc/gimp?rev=25368&view=rev
Log:
2008-04-04 Michael Natterer <mitch gimp org>
* tools/pdbgen/pdb/text_layer.pdb: reorder functions so getters
and setters are together, rename fontsize() functions to
font_size(), fix get_color() implementation.
* app/pdb/text-layer-cmds.c
* libgimp/gimptextlayer_pdb.[ch]: regenerated.
* libgimp/gimp.def: changed accordingly.
Modified:
trunk/ChangeLog
trunk/app/pdb/text-layer-cmds.c
trunk/libgimp/gimp.c
trunk/libgimp/gimp.def
trunk/libgimp/gimp.h
trunk/libgimp/gimptextlayer_pdb.c
trunk/libgimp/gimptextlayer_pdb.h
trunk/tools/pdbgen/pdb/text_layer.pdb
Modified: trunk/app/pdb/text-layer-cmds.c
==============================================================================
--- trunk/app/pdb/text-layer-cmds.c (original)
+++ trunk/app/pdb/text-layer-cmds.c Fri Apr 4 16:42:50 2008
@@ -102,7 +102,7 @@
}
static GValueArray *
-text_layer_set_text_invoker (GimpProcedure *procedure,
+text_layer_get_text_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
@@ -110,20 +110,19 @@
GError **error)
{
gboolean success = TRUE;
+ GValueArray *return_vals;
GimpLayer *layer;
- const gchar *text;
+ gchar *text = NULL;
layer = gimp_value_get_layer (&args->values[0], gimp);
- text = g_value_get_string (&args->values[1]);
if (success)
{
if (gimp_pdb_layer_is_text_layer (layer, error))
{
- gimp_text_layer_set (GIMP_TEXT_LAYER (layer),
- _("Set text layer attribute"),
- "text", text,
- NULL);
+ g_object_get (gimp_text_layer_get_text (GIMP_TEXT_LAYER (layer)),
+ "text", &text,
+ NULL);
}
else
{
@@ -131,11 +130,16 @@
}
}
- return gimp_procedure_get_return_values (procedure, success);
+ return_vals = gimp_procedure_get_return_values (procedure, success);
+
+ if (success)
+ g_value_take_string (&return_vals->values[1], text);
+
+ return return_vals;
}
static GValueArray *
-text_layer_set_font_invoker (GimpProcedure *procedure,
+text_layer_set_text_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
@@ -144,10 +148,10 @@
{
gboolean success = TRUE;
GimpLayer *layer;
- const gchar *font;
+ const gchar *text;
layer = gimp_value_get_layer (&args->values[0], gimp);
- font = g_value_get_string (&args->values[1]);
+ text = g_value_get_string (&args->values[1]);
if (success)
{
@@ -155,7 +159,7 @@
{
gimp_text_layer_set (GIMP_TEXT_LAYER (layer),
_("Set text layer attribute"),
- "font", font,
+ "text", text,
NULL);
}
else
@@ -168,31 +172,27 @@
}
static GValueArray *
-text_layer_set_fontsize_invoker (GimpProcedure *procedure,
- Gimp *gimp,
- GimpContext *context,
- GimpProgress *progress,
- const GValueArray *args,
- GError **error)
+text_layer_get_font_invoker (GimpProcedure *procedure,
+ Gimp *gimp,
+ GimpContext *context,
+ GimpProgress *progress,
+ const GValueArray *args,
+ GError **error)
{
gboolean success = TRUE;
+ GValueArray *return_vals;
GimpLayer *layer;
- gdouble font_size;
- GimpUnit unit;
+ gchar *font = NULL;
layer = gimp_value_get_layer (&args->values[0], gimp);
- font_size = g_value_get_double (&args->values[1]);
- unit = g_value_get_int (&args->values[2]);
if (success)
{
if (gimp_pdb_layer_is_text_layer (layer, error))
{
- gimp_text_layer_set (GIMP_TEXT_LAYER (layer),
- _("Set text layer attribute"),
- "font-size-unit", unit,
- "font-size", font_size,
- NULL);
+ g_object_get (gimp_text_layer_get_text (GIMP_TEXT_LAYER (layer)),
+ "font", &font,
+ NULL);
}
else
{
@@ -200,25 +200,28 @@
}
}
- return gimp_procedure_get_return_values (procedure, success);
+ return_vals = gimp_procedure_get_return_values (procedure, success);
+
+ if (success)
+ g_value_take_string (&return_vals->values[1], font);
+
+ return return_vals;
}
static GValueArray *
-text_layer_set_hinting_invoker (GimpProcedure *procedure,
- Gimp *gimp,
- GimpContext *context,
- GimpProgress *progress,
- const GValueArray *args,
- GError **error)
+text_layer_set_font_invoker (GimpProcedure *procedure,
+ Gimp *gimp,
+ GimpContext *context,
+ GimpProgress *progress,
+ const GValueArray *args,
+ GError **error)
{
gboolean success = TRUE;
GimpLayer *layer;
- gboolean hinting;
- gboolean autohint;
+ const gchar *font;
layer = gimp_value_get_layer (&args->values[0], gimp);
- hinting = g_value_get_boolean (&args->values[1]);
- autohint = g_value_get_boolean (&args->values[2]);
+ font = g_value_get_string (&args->values[1]);
if (success)
{
@@ -226,8 +229,7 @@
{
gimp_text_layer_set (GIMP_TEXT_LAYER (layer),
_("Set text layer attribute"),
- "hinting", hinting,
- "autohint", autohint,
+ "font", font,
NULL);
}
else
@@ -240,7 +242,7 @@
}
static GValueArray *
-text_layer_set_antialias_invoker (GimpProcedure *procedure,
+text_layer_get_font_size_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
@@ -248,20 +250,21 @@
GError **error)
{
gboolean success = TRUE;
+ GValueArray *return_vals;
GimpLayer *layer;
- gboolean antialias;
+ gdouble font_size = 0.0;
+ GimpUnit unit = 0;
layer = gimp_value_get_layer (&args->values[0], gimp);
- antialias = g_value_get_boolean (&args->values[1]);
if (success)
{
if (gimp_pdb_layer_is_text_layer (layer, error))
{
- gimp_text_layer_set (GIMP_TEXT_LAYER (layer),
- _("Set text layer attribute"),
- "antialias", antialias,
- NULL);
+ g_object_get (gimp_text_layer_get_text (GIMP_TEXT_LAYER (layer)),
+ "font-size", &font_size,
+ "font-size-unit", &unit,
+ NULL);
}
else
{
@@ -269,23 +272,33 @@
}
}
- return gimp_procedure_get_return_values (procedure, success);
+ return_vals = gimp_procedure_get_return_values (procedure, success);
+
+ if (success)
+ {
+ g_value_set_double (&return_vals->values[1], font_size);
+ g_value_set_int (&return_vals->values[2], unit);
+ }
+
+ return return_vals;
}
static GValueArray *
-text_layer_set_kerning_invoker (GimpProcedure *procedure,
- Gimp *gimp,
- GimpContext *context,
- GimpProgress *progress,
- const GValueArray *args,
- GError **error)
+text_layer_set_font_size_invoker (GimpProcedure *procedure,
+ Gimp *gimp,
+ GimpContext *context,
+ GimpProgress *progress,
+ const GValueArray *args,
+ GError **error)
{
gboolean success = TRUE;
GimpLayer *layer;
- gboolean kerning;
+ gdouble font_size;
+ GimpUnit unit;
layer = gimp_value_get_layer (&args->values[0], gimp);
- kerning = g_value_get_boolean (&args->values[1]);
+ font_size = g_value_get_double (&args->values[1]);
+ unit = g_value_get_int (&args->values[2]);
if (success)
{
@@ -293,7 +306,8 @@
{
gimp_text_layer_set (GIMP_TEXT_LAYER (layer),
_("Set text layer attribute"),
- "kerning", kerning,
+ "font-size-unit", unit,
+ "font-size", font_size,
NULL);
}
else
@@ -306,28 +320,29 @@
}
static GValueArray *
-text_layer_set_language_invoker (GimpProcedure *procedure,
- Gimp *gimp,
- GimpContext *context,
- GimpProgress *progress,
- const GValueArray *args,
- GError **error)
+text_layer_get_hinting_invoker (GimpProcedure *procedure,
+ Gimp *gimp,
+ GimpContext *context,
+ GimpProgress *progress,
+ const GValueArray *args,
+ GError **error)
{
gboolean success = TRUE;
+ GValueArray *return_vals;
GimpLayer *layer;
- const gchar *language;
+ gboolean hinting = FALSE;
+ gboolean autohint = FALSE;
layer = gimp_value_get_layer (&args->values[0], gimp);
- language = g_value_get_string (&args->values[1]);
if (success)
{
if (gimp_pdb_layer_is_text_layer (layer, error))
{
- gimp_text_layer_set (GIMP_TEXT_LAYER (layer),
- _("Set text layer attribute"),
- "language", language,
- NULL);
+ g_object_get (gimp_text_layer_get_text (GIMP_TEXT_LAYER (layer)),
+ "hinting", &hinting,
+ "autohint", &autohint,
+ NULL);
}
else
{
@@ -335,23 +350,33 @@
}
}
- return gimp_procedure_get_return_values (procedure, success);
+ return_vals = gimp_procedure_get_return_values (procedure, success);
+
+ if (success)
+ {
+ g_value_set_boolean (&return_vals->values[1], hinting);
+ g_value_set_boolean (&return_vals->values[2], autohint);
+ }
+
+ return return_vals;
}
static GValueArray *
-text_layer_set_base_direction_invoker (GimpProcedure *procedure,
- Gimp *gimp,
- GimpContext *context,
- GimpProgress *progress,
- const GValueArray *args,
- GError **error)
+text_layer_set_hinting_invoker (GimpProcedure *procedure,
+ Gimp *gimp,
+ GimpContext *context,
+ GimpProgress *progress,
+ const GValueArray *args,
+ GError **error)
{
gboolean success = TRUE;
GimpLayer *layer;
- gint32 direction;
+ gboolean hinting;
+ gboolean autohint;
layer = gimp_value_get_layer (&args->values[0], gimp);
- direction = g_value_get_enum (&args->values[1]);
+ hinting = g_value_get_boolean (&args->values[1]);
+ autohint = g_value_get_boolean (&args->values[2]);
if (success)
{
@@ -359,7 +384,8 @@
{
gimp_text_layer_set (GIMP_TEXT_LAYER (layer),
_("Set text layer attribute"),
- "base-direction", direction,
+ "hinting", hinting,
+ "autohint", autohint,
NULL);
}
else
@@ -372,28 +398,27 @@
}
static GValueArray *
-text_layer_set_justification_invoker (GimpProcedure *procedure,
- Gimp *gimp,
- GimpContext *context,
- GimpProgress *progress,
- const GValueArray *args,
- GError **error)
+text_layer_get_antialias_invoker (GimpProcedure *procedure,
+ Gimp *gimp,
+ GimpContext *context,
+ GimpProgress *progress,
+ const GValueArray *args,
+ GError **error)
{
gboolean success = TRUE;
+ GValueArray *return_vals;
GimpLayer *layer;
- gint32 justify;
+ gboolean antialias = FALSE;
layer = gimp_value_get_layer (&args->values[0], gimp);
- justify = g_value_get_enum (&args->values[1]);
if (success)
{
if (gimp_pdb_layer_is_text_layer (layer, error))
{
- gimp_text_layer_set (GIMP_TEXT_LAYER (layer),
- _("Set text layer attribute"),
- "justify", justify,
- NULL);
+ g_object_get (gimp_text_layer_get_text (GIMP_TEXT_LAYER (layer)),
+ "antialias", &antialias,
+ NULL);
}
else
{
@@ -401,23 +426,28 @@
}
}
- return gimp_procedure_get_return_values (procedure, success);
+ return_vals = gimp_procedure_get_return_values (procedure, success);
+
+ if (success)
+ g_value_set_boolean (&return_vals->values[1], antialias);
+
+ return return_vals;
}
static GValueArray *
-text_layer_set_color_invoker (GimpProcedure *procedure,
- Gimp *gimp,
- GimpContext *context,
- GimpProgress *progress,
- const GValueArray *args,
- GError **error)
+text_layer_set_antialias_invoker (GimpProcedure *procedure,
+ Gimp *gimp,
+ GimpContext *context,
+ GimpProgress *progress,
+ const GValueArray *args,
+ GError **error)
{
gboolean success = TRUE;
GimpLayer *layer;
- GimpRGB color;
+ gboolean antialias;
layer = gimp_value_get_layer (&args->values[0], gimp);
- gimp_value_get_rgb (&args->values[1], &color);
+ antialias = g_value_get_boolean (&args->values[1]);
if (success)
{
@@ -425,7 +455,7 @@
{
gimp_text_layer_set (GIMP_TEXT_LAYER (layer),
_("Set text layer attribute"),
- "color", &color,
+ "antialias", antialias,
NULL);
}
else
@@ -438,28 +468,27 @@
}
static GValueArray *
-text_layer_set_indent_invoker (GimpProcedure *procedure,
- Gimp *gimp,
- GimpContext *context,
- GimpProgress *progress,
- const GValueArray *args,
- GError **error)
+text_layer_get_kerning_invoker (GimpProcedure *procedure,
+ Gimp *gimp,
+ GimpContext *context,
+ GimpProgress *progress,
+ const GValueArray *args,
+ GError **error)
{
gboolean success = TRUE;
+ GValueArray *return_vals;
GimpLayer *layer;
- gdouble indent;
+ gboolean kerning = FALSE;
layer = gimp_value_get_layer (&args->values[0], gimp);
- indent = g_value_get_double (&args->values[1]);
if (success)
{
if (gimp_pdb_layer_is_text_layer (layer, error))
{
- gimp_text_layer_set (GIMP_TEXT_LAYER (layer),
- _("Set text layer attribute"),
- "indent", indent,
- NULL);
+ g_object_get (gimp_text_layer_get_text (GIMP_TEXT_LAYER (layer)),
+ "kerning", &kerning,
+ NULL);
}
else
{
@@ -467,23 +496,28 @@
}
}
- return gimp_procedure_get_return_values (procedure, success);
-}
+ return_vals = gimp_procedure_get_return_values (procedure, success);
-static GValueArray *
-text_layer_set_line_spacing_invoker (GimpProcedure *procedure,
- Gimp *gimp,
- GimpContext *context,
- GimpProgress *progress,
- const GValueArray *args,
- GError **error)
+ if (success)
+ g_value_set_boolean (&return_vals->values[1], kerning);
+
+ return return_vals;
+}
+
+static GValueArray *
+text_layer_set_kerning_invoker (GimpProcedure *procedure,
+ Gimp *gimp,
+ GimpContext *context,
+ GimpProgress *progress,
+ const GValueArray *args,
+ GError **error)
{
gboolean success = TRUE;
GimpLayer *layer;
- gdouble line_spacing;
+ gboolean kerning;
layer = gimp_value_get_layer (&args->values[0], gimp);
- line_spacing = g_value_get_double (&args->values[1]);
+ kerning = g_value_get_boolean (&args->values[1]);
if (success)
{
@@ -491,7 +525,7 @@
{
gimp_text_layer_set (GIMP_TEXT_LAYER (layer),
_("Set text layer attribute"),
- "line-spacing", line_spacing,
+ "kerning", kerning,
NULL);
}
else
@@ -504,28 +538,27 @@
}
static GValueArray *
-text_layer_set_letter_spacing_invoker (GimpProcedure *procedure,
- Gimp *gimp,
- GimpContext *context,
- GimpProgress *progress,
- const GValueArray *args,
- GError **error)
+text_layer_get_language_invoker (GimpProcedure *procedure,
+ Gimp *gimp,
+ GimpContext *context,
+ GimpProgress *progress,
+ const GValueArray *args,
+ GError **error)
{
gboolean success = TRUE;
+ GValueArray *return_vals;
GimpLayer *layer;
- gdouble letter_spacing;
+ gchar *language = NULL;
layer = gimp_value_get_layer (&args->values[0], gimp);
- letter_spacing = g_value_get_double (&args->values[1]);
if (success)
{
if (gimp_pdb_layer_is_text_layer (layer, error))
{
- gimp_text_layer_set (GIMP_TEXT_LAYER (layer),
- _("Set text layer attribute"),
- "letter-spacing", letter_spacing,
- NULL);
+ g_object_get (gimp_text_layer_get_text (GIMP_TEXT_LAYER (layer)),
+ "language", &language,
+ NULL);
}
else
{
@@ -533,31 +566,37 @@
}
}
- return gimp_procedure_get_return_values (procedure, success);
+ return_vals = gimp_procedure_get_return_values (procedure, success);
+
+ if (success)
+ g_value_take_string (&return_vals->values[1], language);
+
+ return return_vals;
}
static GValueArray *
-text_layer_get_text_invoker (GimpProcedure *procedure,
- Gimp *gimp,
- GimpContext *context,
- GimpProgress *progress,
- const GValueArray *args,
- GError **error)
+text_layer_set_language_invoker (GimpProcedure *procedure,
+ Gimp *gimp,
+ GimpContext *context,
+ GimpProgress *progress,
+ const GValueArray *args,
+ GError **error)
{
gboolean success = TRUE;
- GValueArray *return_vals;
GimpLayer *layer;
- gchar *text = NULL;
+ const gchar *language;
layer = gimp_value_get_layer (&args->values[0], gimp);
+ language = g_value_get_string (&args->values[1]);
if (success)
{
if (gimp_pdb_layer_is_text_layer (layer, error))
{
- g_object_get (gimp_text_layer_get_text (GIMP_TEXT_LAYER (layer)),
- "text", &text,
- NULL);
+ gimp_text_layer_set (GIMP_TEXT_LAYER (layer),
+ _("Set text layer attribute"),
+ "language", language,
+ NULL);
}
else
{
@@ -565,26 +604,21 @@
}
}
- return_vals = gimp_procedure_get_return_values (procedure, success);
-
- if (success)
- g_value_take_string (&return_vals->values[1], text);
-
- return return_vals;
+ return gimp_procedure_get_return_values (procedure, success);
}
static GValueArray *
-text_layer_get_font_invoker (GimpProcedure *procedure,
- Gimp *gimp,
- GimpContext *context,
- GimpProgress *progress,
- const GValueArray *args,
- GError **error)
+text_layer_get_base_direction_invoker (GimpProcedure *procedure,
+ Gimp *gimp,
+ GimpContext *context,
+ GimpProgress *progress,
+ const GValueArray *args,
+ GError **error)
{
gboolean success = TRUE;
GValueArray *return_vals;
GimpLayer *layer;
- gchar *font = NULL;
+ gint32 direction = 0;
layer = gimp_value_get_layer (&args->values[0], gimp);
@@ -593,7 +627,7 @@
if (gimp_pdb_layer_is_text_layer (layer, error))
{
g_object_get (gimp_text_layer_get_text (GIMP_TEXT_LAYER (layer)),
- "font", &font,
+ "base-direction", &direction,
NULL);
}
else
@@ -605,35 +639,34 @@
return_vals = gimp_procedure_get_return_values (procedure, success);
if (success)
- g_value_take_string (&return_vals->values[1], font);
+ g_value_set_enum (&return_vals->values[1], direction);
return return_vals;
}
static GValueArray *
-text_layer_get_fontsize_invoker (GimpProcedure *procedure,
- Gimp *gimp,
- GimpContext *context,
- GimpProgress *progress,
- const GValueArray *args,
- GError **error)
+text_layer_set_base_direction_invoker (GimpProcedure *procedure,
+ Gimp *gimp,
+ GimpContext *context,
+ GimpProgress *progress,
+ const GValueArray *args,
+ GError **error)
{
gboolean success = TRUE;
- GValueArray *return_vals;
GimpLayer *layer;
- gdouble font_size = 0.0;
- GimpUnit unit = 0;
+ gint32 direction;
layer = gimp_value_get_layer (&args->values[0], gimp);
+ direction = g_value_get_enum (&args->values[1]);
if (success)
{
if (gimp_pdb_layer_is_text_layer (layer, error))
{
- g_object_get (gimp_text_layer_get_text (GIMP_TEXT_LAYER (layer)),
- "font-size", &font_size,
- "font-size-unit", &unit,
- NULL);
+ gimp_text_layer_set (GIMP_TEXT_LAYER (layer),
+ _("Set text layer attribute"),
+ "base-direction", direction,
+ NULL);
}
else
{
@@ -641,30 +674,21 @@
}
}
- return_vals = gimp_procedure_get_return_values (procedure, success);
-
- if (success)
- {
- g_value_set_double (&return_vals->values[1], font_size);
- g_value_set_int (&return_vals->values[2], unit);
- }
-
- return return_vals;
+ return gimp_procedure_get_return_values (procedure, success);
}
static GValueArray *
-text_layer_get_hinting_invoker (GimpProcedure *procedure,
- Gimp *gimp,
- GimpContext *context,
- GimpProgress *progress,
- const GValueArray *args,
- GError **error)
+text_layer_get_justification_invoker (GimpProcedure *procedure,
+ Gimp *gimp,
+ GimpContext *context,
+ GimpProgress *progress,
+ const GValueArray *args,
+ GError **error)
{
gboolean success = TRUE;
GValueArray *return_vals;
GimpLayer *layer;
- gboolean hinting = FALSE;
- gboolean autohint = FALSE;
+ gint32 justify = 0;
layer = gimp_value_get_layer (&args->values[0], gimp);
@@ -673,8 +697,7 @@
if (gimp_pdb_layer_is_text_layer (layer, error))
{
g_object_get (gimp_text_layer_get_text (GIMP_TEXT_LAYER (layer)),
- "hinting", &hinting,
- "autohint", &autohint,
+ "justify", &justify,
NULL);
}
else
@@ -686,36 +709,34 @@
return_vals = gimp_procedure_get_return_values (procedure, success);
if (success)
- {
- g_value_set_boolean (&return_vals->values[1], hinting);
- g_value_set_boolean (&return_vals->values[2], autohint);
- }
+ g_value_set_enum (&return_vals->values[1], justify);
return return_vals;
}
static GValueArray *
-text_layer_get_antialias_invoker (GimpProcedure *procedure,
- Gimp *gimp,
- GimpContext *context,
- GimpProgress *progress,
- const GValueArray *args,
- GError **error)
+text_layer_set_justification_invoker (GimpProcedure *procedure,
+ Gimp *gimp,
+ GimpContext *context,
+ GimpProgress *progress,
+ const GValueArray *args,
+ GError **error)
{
gboolean success = TRUE;
- GValueArray *return_vals;
GimpLayer *layer;
- gboolean antialias = FALSE;
+ gint32 justify;
layer = gimp_value_get_layer (&args->values[0], gimp);
+ justify = g_value_get_enum (&args->values[1]);
if (success)
{
if (gimp_pdb_layer_is_text_layer (layer, error))
{
- g_object_get (gimp_text_layer_get_text (GIMP_TEXT_LAYER (layer)),
- "antialias", &antialias,
- NULL);
+ gimp_text_layer_set (GIMP_TEXT_LAYER (layer),
+ _("Set text layer attribute"),
+ "justify", justify,
+ NULL);
}
else
{
@@ -723,26 +744,21 @@
}
}
- return_vals = gimp_procedure_get_return_values (procedure, success);
-
- if (success)
- g_value_set_boolean (&return_vals->values[1], antialias);
-
- return return_vals;
+ return gimp_procedure_get_return_values (procedure, success);
}
static GValueArray *
-text_layer_get_kerning_invoker (GimpProcedure *procedure,
- Gimp *gimp,
- GimpContext *context,
- GimpProgress *progress,
- const GValueArray *args,
- GError **error)
+text_layer_get_color_invoker (GimpProcedure *procedure,
+ Gimp *gimp,
+ GimpContext *context,
+ GimpProgress *progress,
+ const GValueArray *args,
+ GError **error)
{
gboolean success = TRUE;
GValueArray *return_vals;
GimpLayer *layer;
- gboolean kerning = FALSE;
+ GimpRGB color = { 0.0, 0.0, 0.0, 1.0 };
layer = gimp_value_get_layer (&args->values[0], gimp);
@@ -750,9 +766,7 @@
{
if (gimp_pdb_layer_is_text_layer (layer, error))
{
- g_object_get (gimp_text_layer_get_text (GIMP_TEXT_LAYER (layer)),
- "kerning", &kerning,
- NULL);
+ color = gimp_text_layer_get_text (GIMP_TEXT_LAYER (layer))->color;
}
else
{
@@ -763,33 +777,34 @@
return_vals = gimp_procedure_get_return_values (procedure, success);
if (success)
- g_value_set_boolean (&return_vals->values[1], kerning);
+ gimp_value_set_rgb (&return_vals->values[1], &color);
return return_vals;
}
static GValueArray *
-text_layer_get_language_invoker (GimpProcedure *procedure,
- Gimp *gimp,
- GimpContext *context,
- GimpProgress *progress,
- const GValueArray *args,
- GError **error)
+text_layer_set_color_invoker (GimpProcedure *procedure,
+ Gimp *gimp,
+ GimpContext *context,
+ GimpProgress *progress,
+ const GValueArray *args,
+ GError **error)
{
gboolean success = TRUE;
- GValueArray *return_vals;
GimpLayer *layer;
- gchar *language = NULL;
+ GimpRGB color;
layer = gimp_value_get_layer (&args->values[0], gimp);
+ gimp_value_get_rgb (&args->values[1], &color);
if (success)
{
if (gimp_pdb_layer_is_text_layer (layer, error))
{
- g_object_get (gimp_text_layer_get_text (GIMP_TEXT_LAYER (layer)),
- "language", &language,
- NULL);
+ gimp_text_layer_set (GIMP_TEXT_LAYER (layer),
+ _("Set text layer attribute"),
+ "color", &color,
+ NULL);
}
else
{
@@ -797,26 +812,21 @@
}
}
- return_vals = gimp_procedure_get_return_values (procedure, success);
-
- if (success)
- g_value_take_string (&return_vals->values[1], language);
-
- return return_vals;
+ return gimp_procedure_get_return_values (procedure, success);
}
static GValueArray *
-text_layer_get_base_direction_invoker (GimpProcedure *procedure,
- Gimp *gimp,
- GimpContext *context,
- GimpProgress *progress,
- const GValueArray *args,
- GError **error)
+text_layer_get_indent_invoker (GimpProcedure *procedure,
+ Gimp *gimp,
+ GimpContext *context,
+ GimpProgress *progress,
+ const GValueArray *args,
+ GError **error)
{
gboolean success = TRUE;
GValueArray *return_vals;
GimpLayer *layer;
- gint32 direction = 0;
+ gdouble indent = 0.0;
layer = gimp_value_get_layer (&args->values[0], gimp);
@@ -825,7 +835,7 @@
if (gimp_pdb_layer_is_text_layer (layer, error))
{
g_object_get (gimp_text_layer_get_text (GIMP_TEXT_LAYER (layer)),
- "base-direction", &direction,
+ "indent", &indent,
NULL);
}
else
@@ -837,33 +847,34 @@
return_vals = gimp_procedure_get_return_values (procedure, success);
if (success)
- g_value_set_enum (&return_vals->values[1], direction);
+ g_value_set_double (&return_vals->values[1], indent);
return return_vals;
}
static GValueArray *
-text_layer_get_justification_invoker (GimpProcedure *procedure,
- Gimp *gimp,
- GimpContext *context,
- GimpProgress *progress,
- const GValueArray *args,
- GError **error)
+text_layer_set_indent_invoker (GimpProcedure *procedure,
+ Gimp *gimp,
+ GimpContext *context,
+ GimpProgress *progress,
+ const GValueArray *args,
+ GError **error)
{
gboolean success = TRUE;
- GValueArray *return_vals;
GimpLayer *layer;
- gint32 justify = 0;
+ gdouble indent;
layer = gimp_value_get_layer (&args->values[0], gimp);
+ indent = g_value_get_double (&args->values[1]);
if (success)
{
if (gimp_pdb_layer_is_text_layer (layer, error))
{
- g_object_get (gimp_text_layer_get_text (GIMP_TEXT_LAYER (layer)),
- "justify", &justify,
- NULL);
+ gimp_text_layer_set (GIMP_TEXT_LAYER (layer),
+ _("Set text layer attribute"),
+ "indent", indent,
+ NULL);
}
else
{
@@ -871,26 +882,21 @@
}
}
- return_vals = gimp_procedure_get_return_values (procedure, success);
-
- if (success)
- g_value_set_enum (&return_vals->values[1], justify);
-
- return return_vals;
+ return gimp_procedure_get_return_values (procedure, success);
}
static GValueArray *
-text_layer_get_color_invoker (GimpProcedure *procedure,
- Gimp *gimp,
- GimpContext *context,
- GimpProgress *progress,
- const GValueArray *args,
- GError **error)
+text_layer_get_line_spacing_invoker (GimpProcedure *procedure,
+ Gimp *gimp,
+ GimpContext *context,
+ GimpProgress *progress,
+ const GValueArray *args,
+ GError **error)
{
gboolean success = TRUE;
GValueArray *return_vals;
GimpLayer *layer;
- GimpRGB color = { 0.0, 0.0, 0.0, 1.0 };
+ gdouble line_spacing = 0.0;
layer = gimp_value_get_layer (&args->values[0], gimp);
@@ -899,7 +905,7 @@
if (gimp_pdb_layer_is_text_layer (layer, error))
{
g_object_get (gimp_text_layer_get_text (GIMP_TEXT_LAYER (layer)),
- "color", &color,
+ "line-spacing", &line_spacing,
NULL);
}
else
@@ -911,33 +917,34 @@
return_vals = gimp_procedure_get_return_values (procedure, success);
if (success)
- gimp_value_set_rgb (&return_vals->values[1], &color);
+ g_value_set_double (&return_vals->values[1], line_spacing);
return return_vals;
}
static GValueArray *
-text_layer_get_indent_invoker (GimpProcedure *procedure,
- Gimp *gimp,
- GimpContext *context,
- GimpProgress *progress,
- const GValueArray *args,
- GError **error)
+text_layer_set_line_spacing_invoker (GimpProcedure *procedure,
+ Gimp *gimp,
+ GimpContext *context,
+ GimpProgress *progress,
+ const GValueArray *args,
+ GError **error)
{
gboolean success = TRUE;
- GValueArray *return_vals;
GimpLayer *layer;
- gdouble indent = 0.0;
+ gdouble line_spacing;
layer = gimp_value_get_layer (&args->values[0], gimp);
+ line_spacing = g_value_get_double (&args->values[1]);
if (success)
{
if (gimp_pdb_layer_is_text_layer (layer, error))
{
- g_object_get (gimp_text_layer_get_text (GIMP_TEXT_LAYER (layer)),
- "indent", &indent,
- NULL);
+ gimp_text_layer_set (GIMP_TEXT_LAYER (layer),
+ _("Set text layer attribute"),
+ "line-spacing", line_spacing,
+ NULL);
}
else
{
@@ -945,26 +952,21 @@
}
}
- return_vals = gimp_procedure_get_return_values (procedure, success);
-
- if (success)
- g_value_set_double (&return_vals->values[1], indent);
-
- return return_vals;
+ return gimp_procedure_get_return_values (procedure, success);
}
static GValueArray *
-text_layer_get_line_spacing_invoker (GimpProcedure *procedure,
- Gimp *gimp,
- GimpContext *context,
- GimpProgress *progress,
- const GValueArray *args,
- GError **error)
+text_layer_get_letter_spacing_invoker (GimpProcedure *procedure,
+ Gimp *gimp,
+ GimpContext *context,
+ GimpProgress *progress,
+ const GValueArray *args,
+ GError **error)
{
gboolean success = TRUE;
GValueArray *return_vals;
GimpLayer *layer;
- gdouble line_spacing = 0.0;
+ gdouble letter_spacing = 0.0;
layer = gimp_value_get_layer (&args->values[0], gimp);
@@ -973,7 +975,7 @@
if (gimp_pdb_layer_is_text_layer (layer, error))
{
g_object_get (gimp_text_layer_get_text (GIMP_TEXT_LAYER (layer)),
- "line-spacing", &line_spacing,
+ "letter-spacing", &letter_spacing,
NULL);
}
else
@@ -985,13 +987,13 @@
return_vals = gimp_procedure_get_return_values (procedure, success);
if (success)
- g_value_set_double (&return_vals->values[1], line_spacing);
+ g_value_set_double (&return_vals->values[1], letter_spacing);
return return_vals;
}
static GValueArray *
-text_layer_get_letter_spacing_invoker (GimpProcedure *procedure,
+text_layer_set_letter_spacing_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
@@ -999,19 +1001,20 @@
GError **error)
{
gboolean success = TRUE;
- GValueArray *return_vals;
GimpLayer *layer;
- gdouble letter_spacing = 0.0;
+ gdouble letter_spacing;
layer = gimp_value_get_layer (&args->values[0], gimp);
+ letter_spacing = g_value_get_double (&args->values[1]);
if (success)
{
if (gimp_pdb_layer_is_text_layer (layer, error))
{
- g_object_get (gimp_text_layer_get_text (GIMP_TEXT_LAYER (layer)),
- "letter-spacing", &letter_spacing,
- NULL);
+ gimp_text_layer_set (GIMP_TEXT_LAYER (layer),
+ _("Set text layer attribute"),
+ "letter-spacing", letter_spacing,
+ NULL);
}
else
{
@@ -1019,12 +1022,7 @@
}
}
- return_vals = gimp_procedure_get_return_values (procedure, success);
-
- if (success)
- g_value_set_double (&return_vals->values[1], letter_spacing);
-
- return return_vals;
+ return gimp_procedure_get_return_values (procedure, success);
}
void
@@ -1090,6 +1088,36 @@
g_object_unref (procedure);
/*
+ * gimp-text-layer-get-text
+ */
+ procedure = gimp_procedure_new (text_layer_get_text_invoker);
+ gimp_object_set_static_name (GIMP_OBJECT (procedure),
+ "gimp-text-layer-get-text");
+ gimp_procedure_set_static_strings (procedure,
+ "gimp-text-layer-get-text",
+ "Get the text from a text layer as string.",
+ "This procedure returns the text from a text layer as a string.",
+ "Marcus Heese <heese cip ifi lmu de>",
+ "Marcus Heese",
+ "2008",
+ NULL);
+ gimp_procedure_add_argument (procedure,
+ gimp_param_spec_layer_id ("layer",
+ "layer",
+ "The text layer",
+ pdb->gimp, FALSE,
+ GIMP_PARAM_READWRITE));
+ gimp_procedure_add_return_value (procedure,
+ gimp_param_spec_string ("text",
+ "text",
+ "The text from the specified text layer.",
+ FALSE, FALSE, FALSE,
+ NULL,
+ GIMP_PARAM_READWRITE));
+ gimp_pdb_register_procedure (pdb, procedure);
+ g_object_unref (procedure);
+
+ /*
* gimp-text-layer-set-text
*/
procedure = gimp_procedure_new (text_layer_set_text_invoker);
@@ -1120,6 +1148,36 @@
g_object_unref (procedure);
/*
+ * gimp-text-layer-get-font
+ */
+ procedure = gimp_procedure_new (text_layer_get_font_invoker);
+ gimp_object_set_static_name (GIMP_OBJECT (procedure),
+ "gimp-text-layer-get-font");
+ gimp_procedure_set_static_strings (procedure,
+ "gimp-text-layer-get-font",
+ "Get the font from a text layer as string.",
+ "This procedure returns the name of the font from a text layer.",
+ "Marcus Heese <heese cip ifi lmu de>",
+ "Marcus Heese",
+ "2008",
+ NULL);
+ gimp_procedure_add_argument (procedure,
+ gimp_param_spec_layer_id ("layer",
+ "layer",
+ "The text layer",
+ pdb->gimp, FALSE,
+ GIMP_PARAM_READWRITE));
+ gimp_procedure_add_return_value (procedure,
+ gimp_param_spec_string ("font",
+ "font",
+ "The font which is used in the specified text layer.",
+ FALSE, FALSE, FALSE,
+ NULL,
+ GIMP_PARAM_READWRITE));
+ gimp_pdb_register_procedure (pdb, procedure);
+ g_object_unref (procedure);
+
+ /*
* gimp-text-layer-set-font
*/
procedure = gimp_procedure_new (text_layer_set_font_invoker);
@@ -1150,13 +1208,50 @@
g_object_unref (procedure);
/*
- * gimp-text-layer-set-fontsize
+ * gimp-text-layer-get-font-size
+ */
+ procedure = gimp_procedure_new (text_layer_get_font_size_invoker);
+ gimp_object_set_static_name (GIMP_OBJECT (procedure),
+ "gimp-text-layer-get-font-size");
+ gimp_procedure_set_static_strings (procedure,
+ "gimp-text-layer-get-font-size",
+ "Get the font size from a text layer.",
+ "This procedure returns the size of the font which is used in a text layer. You will receive the size as a float 'font-size' in 'unit' units.",
+ "Marcus Heese <heese cip ifi lmu de>",
+ "Marcus Heese",
+ "2008",
+ NULL);
+ gimp_procedure_add_argument (procedure,
+ gimp_param_spec_layer_id ("layer",
+ "layer",
+ "The text layer",
+ pdb->gimp, FALSE,
+ GIMP_PARAM_READWRITE));
+ gimp_procedure_add_return_value (procedure,
+ g_param_spec_double ("font-size",
+ "font size",
+ "The font size",
+ -G_MAXDOUBLE, G_MAXDOUBLE, 0,
+ GIMP_PARAM_READWRITE));
+ gimp_procedure_add_return_value (procedure,
+ gimp_param_spec_unit ("unit",
+ "unit",
+ "The unit used for the font size",
+ TRUE,
+ FALSE,
+ GIMP_UNIT_PIXEL,
+ GIMP_PARAM_READWRITE));
+ gimp_pdb_register_procedure (pdb, procedure);
+ g_object_unref (procedure);
+
+ /*
+ * gimp-text-layer-set-font-size
*/
- procedure = gimp_procedure_new (text_layer_set_fontsize_invoker);
+ procedure = gimp_procedure_new (text_layer_set_font_size_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
- "gimp-text-layer-set-fontsize");
+ "gimp-text-layer-set-font-size");
gimp_procedure_set_static_strings (procedure,
- "gimp-text-layer-set-fontsize",
+ "gimp-text-layer-set-font-size",
"Set the font size.",
"This procedure changes the font size of a text layer. The size of your font will be a double 'font-size' of 'unit' units.",
"Marcus Heese <heese cip ifi lmu de>",
@@ -1187,6 +1282,41 @@
g_object_unref (procedure);
/*
+ * gimp-text-layer-get-hinting
+ */
+ procedure = gimp_procedure_new (text_layer_get_hinting_invoker);
+ gimp_object_set_static_name (GIMP_OBJECT (procedure),
+ "gimp-text-layer-get-hinting");
+ gimp_procedure_set_static_strings (procedure,
+ "gimp-text-layer-get-hinting",
+ "Get information about hinting in the specified text layer.",
+ "This procedure provides information about the hinting that is being used in a text layer.",
+ "Marcus Heese <heese cip ifi lmu de>",
+ "Marcus Heese",
+ "2008",
+ NULL);
+ gimp_procedure_add_argument (procedure,
+ gimp_param_spec_layer_id ("layer",
+ "layer",
+ "The text layer",
+ pdb->gimp, FALSE,
+ GIMP_PARAM_READWRITE));
+ gimp_procedure_add_return_value (procedure,
+ g_param_spec_boolean ("hinting",
+ "hinting",
+ "A flag which is true if hinting is used on the font.",
+ FALSE,
+ GIMP_PARAM_READWRITE));
+ gimp_procedure_add_return_value (procedure,
+ g_param_spec_boolean ("autohint",
+ "autohint",
+ "A flag which is true if the text layer is forced to use the autohinter from FreeType.",
+ FALSE,
+ GIMP_PARAM_READWRITE));
+ gimp_pdb_register_procedure (pdb, procedure);
+ g_object_unref (procedure);
+
+ /*
* gimp-text-layer-set-hinting
*/
procedure = gimp_procedure_new (text_layer_set_hinting_invoker);
@@ -1222,280 +1352,15 @@
g_object_unref (procedure);
/*
- * gimp-text-layer-set-antialias
+ * gimp-text-layer-get-antialias
*/
- procedure = gimp_procedure_new (text_layer_set_antialias_invoker);
+ procedure = gimp_procedure_new (text_layer_get_antialias_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
- "gimp-text-layer-set-antialias");
+ "gimp-text-layer-get-antialias");
gimp_procedure_set_static_strings (procedure,
- "gimp-text-layer-set-antialias",
- "Enable/disable anti-aliasing in a text layer.",
- "This procedure enables or disables anti-aliasing of the text in a text layer.",
- "Marcus Heese <heese cip ifi lmu de>",
- "Marcus Heese",
- "2008",
- NULL);
- gimp_procedure_add_argument (procedure,
- gimp_param_spec_layer_id ("layer",
- "layer",
- "The text layer",
- pdb->gimp, FALSE,
- GIMP_PARAM_READWRITE));
- gimp_procedure_add_argument (procedure,
- g_param_spec_boolean ("antialias",
- "antialias",
- "Enable/disable antialiasing of the text",
- FALSE,
- GIMP_PARAM_READWRITE));
- gimp_pdb_register_procedure (pdb, procedure);
- g_object_unref (procedure);
-
- /*
- * gimp-text-layer-set-kerning
- */
- procedure = gimp_procedure_new (text_layer_set_kerning_invoker);
- gimp_object_set_static_name (GIMP_OBJECT (procedure),
- "gimp-text-layer-set-kerning");
- gimp_procedure_set_static_strings (procedure,
- "gimp-text-layer-set-kerning",
- "Enable/disable kerning in a text layer.",
- "This procedure enables or disables kerning in a text layer.",
- "Marcus Heese <heese cip ifi lmu de>",
- "Marcus Heese",
- "2008",
- NULL);
- gimp_procedure_add_argument (procedure,
- gimp_param_spec_layer_id ("layer",
- "layer",
- "The text layer",
- pdb->gimp, FALSE,
- GIMP_PARAM_READWRITE));
- gimp_procedure_add_argument (procedure,
- g_param_spec_boolean ("kerning",
- "kerning",
- "Enable/disable kerning in the text",
- FALSE,
- GIMP_PARAM_READWRITE));
- gimp_pdb_register_procedure (pdb, procedure);
- g_object_unref (procedure);
-
- /*
- * gimp-text-layer-set-language
- */
- procedure = gimp_procedure_new (text_layer_set_language_invoker);
- gimp_object_set_static_name (GIMP_OBJECT (procedure),
- "gimp-text-layer-set-language");
- gimp_procedure_set_static_strings (procedure,
- "gimp-text-layer-set-language",
- "Set the language of the text layer.",
- "This procedure sets the language of the text in text layer. For some scripts the language has an influence of how the text is rendered.",
- "Marcus Heese <heese cip ifi lmu de>",
- "Marcus Heese",
- "2008",
- NULL);
- gimp_procedure_add_argument (procedure,
- gimp_param_spec_layer_id ("layer",
- "layer",
- "The text layer",
- pdb->gimp, FALSE,
- GIMP_PARAM_READWRITE));
- gimp_procedure_add_argument (procedure,
- gimp_param_spec_string ("language",
- "language",
- "The new language to use for the text layer",
- FALSE, FALSE, FALSE,
- NULL,
- GIMP_PARAM_READWRITE));
- gimp_pdb_register_procedure (pdb, procedure);
- g_object_unref (procedure);
-
- /*
- * gimp-text-layer-set-base-direction
- */
- procedure = gimp_procedure_new (text_layer_set_base_direction_invoker);
- gimp_object_set_static_name (GIMP_OBJECT (procedure),
- "gimp-text-layer-set-base-direction");
- gimp_procedure_set_static_strings (procedure,
- "gimp-text-layer-set-base-direction",
- "Set the base direction in the text layer.",
- "This procedure sets the base direction used in applying the Unicode bidirectional algorithm when rendering the text.",
- "Marcus Heese <heese cip ifi lmu de>",
- "Marcus Heese",
- "2008",
- NULL);
- gimp_procedure_add_argument (procedure,
- gimp_param_spec_layer_id ("layer",
- "layer",
- "The text layer",
- pdb->gimp, FALSE,
- GIMP_PARAM_READWRITE));
- gimp_procedure_add_argument (procedure,
- g_param_spec_enum ("direction",
- "direction",
- "The base direction of the text.",
- GIMP_TYPE_TEXT_DIRECTION,
- GIMP_TEXT_DIRECTION_LTR,
- GIMP_PARAM_READWRITE));
- gimp_pdb_register_procedure (pdb, procedure);
- g_object_unref (procedure);
-
- /*
- * gimp-text-layer-set-justification
- */
- procedure = gimp_procedure_new (text_layer_set_justification_invoker);
- gimp_object_set_static_name (GIMP_OBJECT (procedure),
- "gimp-text-layer-set-justification");
- gimp_procedure_set_static_strings (procedure,
- "gimp-text-layer-set-justification",
- "Set the justification of the text in a text layer.",
- "This procedure sets the alignment of the lines in the text layer relative to each other.",
- "Marcus Heese <heese cip ifi lmu de>",
- "Marcus Heese",
- "2008",
- NULL);
- gimp_procedure_add_argument (procedure,
- gimp_param_spec_layer_id ("layer",
- "layer",
- "The text layer",
- pdb->gimp, FALSE,
- GIMP_PARAM_READWRITE));
- gimp_procedure_add_argument (procedure,
- g_param_spec_enum ("justify",
- "justify",
- "The justification for your text.",
- GIMP_TYPE_TEXT_JUSTIFICATION,
- GIMP_TEXT_JUSTIFY_LEFT,
- GIMP_PARAM_READWRITE));
- gimp_pdb_register_procedure (pdb, procedure);
- g_object_unref (procedure);
-
- /*
- * gimp-text-layer-set-color
- */
- procedure = gimp_procedure_new (text_layer_set_color_invoker);
- gimp_object_set_static_name (GIMP_OBJECT (procedure),
- "gimp-text-layer-set-color");
- gimp_procedure_set_static_strings (procedure,
- "gimp-text-layer-set-color",
- "Set the color of the text in the text layer.",
- "This procedure sets the text color in the text layer 'layer'.",
- "Marcus Heese <heese cip ifi lmu de>",
- "Marcus Heese",
- "2008",
- NULL);
- gimp_procedure_add_argument (procedure,
- gimp_param_spec_layer_id ("layer",
- "layer",
- "The text layer",
- pdb->gimp, FALSE,
- GIMP_PARAM_READWRITE));
- gimp_procedure_add_argument (procedure,
- gimp_param_spec_rgb ("color",
- "color",
- "The color to use for the text",
- FALSE,
- NULL,
- GIMP_PARAM_READWRITE));
- gimp_pdb_register_procedure (pdb, procedure);
- g_object_unref (procedure);
-
- /*
- * gimp-text-layer-set-indent
- */
- procedure = gimp_procedure_new (text_layer_set_indent_invoker);
- gimp_object_set_static_name (GIMP_OBJECT (procedure),
- "gimp-text-layer-set-indent");
- gimp_procedure_set_static_strings (procedure,
- "gimp-text-layer-set-indent",
- "Set the indentation of the first line in a text layer.",
- "This procedure sets the indentation of the first line in the text layer.",
- "Marcus Heese <heese cip ifi lmu de>",
- "Marcus Heese",
- "2008",
- NULL);
- gimp_procedure_add_argument (procedure,
- gimp_param_spec_layer_id ("layer",
- "layer",
- "The text layer",
- pdb->gimp, FALSE,
- GIMP_PARAM_READWRITE));
- gimp_procedure_add_argument (procedure,
- g_param_spec_double ("indent",
- "indent",
- "The indentation for the first line.",
- -8192.0, 8192.0, -8192.0,
- GIMP_PARAM_READWRITE));
- gimp_pdb_register_procedure (pdb, procedure);
- g_object_unref (procedure);
-
- /*
- * gimp-text-layer-set-line-spacing
- */
- procedure = gimp_procedure_new (text_layer_set_line_spacing_invoker);
- gimp_object_set_static_name (GIMP_OBJECT (procedure),
- "gimp-text-layer-set-line-spacing");
- gimp_procedure_set_static_strings (procedure,
- "gimp-text-layer-set-line-spacing",
- "Adjust the line spacing in a text layer.",
- "This procedure sets the additional spacing used between lines a text layer.",
- "Marcus Heese <heese cip ifi lmu de>",
- "Marcus Heese",
- "2008",
- NULL);
- gimp_procedure_add_argument (procedure,
- gimp_param_spec_layer_id ("layer",
- "layer",
- "The text layer",
- pdb->gimp, FALSE,
- GIMP_PARAM_READWRITE));
- gimp_procedure_add_argument (procedure,
- g_param_spec_double ("line-spacing",
- "line spacing",
- "The additional line spacing to use.",
- -8192.0, 8192.0, -8192.0,
- GIMP_PARAM_READWRITE));
- gimp_pdb_register_procedure (pdb, procedure);
- g_object_unref (procedure);
-
- /*
- * gimp-text-layer-set-letter-spacing
- */
- procedure = gimp_procedure_new (text_layer_set_letter_spacing_invoker);
- gimp_object_set_static_name (GIMP_OBJECT (procedure),
- "gimp-text-layer-set-letter-spacing");
- gimp_procedure_set_static_strings (procedure,
- "gimp-text-layer-set-letter-spacing",
- "Adjust the letter spacing in a text layer.",
- "This procedure sets the additional spacing between the single glyphs in a text layer.",
- "Marcus Heese <heese cip ifi lmu de>",
- "Marcus Heese",
- "2008",
- NULL);
- gimp_procedure_add_argument (procedure,
- gimp_param_spec_layer_id ("layer",
- "layer",
- "The text layer",
- pdb->gimp, FALSE,
- GIMP_PARAM_READWRITE));
- gimp_procedure_add_argument (procedure,
- g_param_spec_double ("letter-spacing",
- "letter spacing",
- "The additional letter spacing to use.",
- -8192.0, 8192.0, -8192.0,
- GIMP_PARAM_READWRITE));
- gimp_pdb_register_procedure (pdb, procedure);
- g_object_unref (procedure);
-
- /*
- * gimp-text-layer-get-text
- */
- procedure = gimp_procedure_new (text_layer_get_text_invoker);
- gimp_object_set_static_name (GIMP_OBJECT (procedure),
- "gimp-text-layer-get-text");
- gimp_procedure_set_static_strings (procedure,
- "gimp-text-layer-get-text",
- "Get the text from a text layer as string.",
- "This procedure returns the text from a text layer as a string.",
+ "gimp-text-layer-get-antialias",
+ "Check if antialiasing is used in the text layer.",
+ "This procedure checks if antialiasing is enabled in the specified text layer.",
"Marcus Heese <heese cip ifi lmu de>",
"Marcus Heese",
"2008",
@@ -1507,127 +1372,24 @@
pdb->gimp, FALSE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
- gimp_param_spec_string ("text",
- "text",
- "The text from the specified text layer.",
- FALSE, FALSE, FALSE,
- NULL,
- GIMP_PARAM_READWRITE));
- gimp_pdb_register_procedure (pdb, procedure);
- g_object_unref (procedure);
-
- /*
- * gimp-text-layer-get-font
- */
- procedure = gimp_procedure_new (text_layer_get_font_invoker);
- gimp_object_set_static_name (GIMP_OBJECT (procedure),
- "gimp-text-layer-get-font");
- gimp_procedure_set_static_strings (procedure,
- "gimp-text-layer-get-font",
- "Get the font from a text layer as string.",
- "This procedure returns the name of the font from a text layer.",
- "Marcus Heese <heese cip ifi lmu de>",
- "Marcus Heese",
- "2008",
- NULL);
- gimp_procedure_add_argument (procedure,
- gimp_param_spec_layer_id ("layer",
- "layer",
- "The text layer",
- pdb->gimp, FALSE,
- GIMP_PARAM_READWRITE));
- gimp_procedure_add_return_value (procedure,
- gimp_param_spec_string ("font",
- "font",
- "The font which is used in the specified text layer.",
- FALSE, FALSE, FALSE,
- NULL,
- GIMP_PARAM_READWRITE));
- gimp_pdb_register_procedure (pdb, procedure);
- g_object_unref (procedure);
-
- /*
- * gimp-text-layer-get-fontsize
- */
- procedure = gimp_procedure_new (text_layer_get_fontsize_invoker);
- gimp_object_set_static_name (GIMP_OBJECT (procedure),
- "gimp-text-layer-get-fontsize");
- gimp_procedure_set_static_strings (procedure,
- "gimp-text-layer-get-fontsize",
- "Get the font size from a text layer.",
- "This procedure returns the size of the font which is used in a text layer. You will receive the size as a float 'font-size' in 'unit' units.",
- "Marcus Heese <heese cip ifi lmu de>",
- "Marcus Heese",
- "2008",
- NULL);
- gimp_procedure_add_argument (procedure,
- gimp_param_spec_layer_id ("layer",
- "layer",
- "The text layer",
- pdb->gimp, FALSE,
- GIMP_PARAM_READWRITE));
- gimp_procedure_add_return_value (procedure,
- g_param_spec_double ("font-size",
- "font size",
- "The font size",
- -G_MAXDOUBLE, G_MAXDOUBLE, 0,
- GIMP_PARAM_READWRITE));
- gimp_procedure_add_return_value (procedure,
- gimp_param_spec_unit ("unit",
- "unit",
- "The unit used for the font size",
- TRUE,
- FALSE,
- GIMP_UNIT_PIXEL,
- GIMP_PARAM_READWRITE));
- gimp_pdb_register_procedure (pdb, procedure);
- g_object_unref (procedure);
-
- /*
- * gimp-text-layer-get-hinting
- */
- procedure = gimp_procedure_new (text_layer_get_hinting_invoker);
- gimp_object_set_static_name (GIMP_OBJECT (procedure),
- "gimp-text-layer-get-hinting");
- gimp_procedure_set_static_strings (procedure,
- "gimp-text-layer-get-hinting",
- "Get information about hinting in the specified text layer.",
- "This procedure provides information about the hinting that is being used in a text layer.",
- "Marcus Heese <heese cip ifi lmu de>",
- "Marcus Heese",
- "2008",
- NULL);
- gimp_procedure_add_argument (procedure,
- gimp_param_spec_layer_id ("layer",
- "layer",
- "The text layer",
- pdb->gimp, FALSE,
- GIMP_PARAM_READWRITE));
- gimp_procedure_add_return_value (procedure,
- g_param_spec_boolean ("hinting",
- "hinting",
- "A flag which is true if hinting is used on the font.",
- FALSE,
- GIMP_PARAM_READWRITE));
- gimp_procedure_add_return_value (procedure,
- g_param_spec_boolean ("autohint",
- "autohint",
- "A flag which is true if the text layer is forced to use the autohinter from FreeType.",
+ g_param_spec_boolean ("antialias",
+ "antialias",
+ "A flag which is true if antialiasing is used for rendering the font in the text layer.",
FALSE,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
- * gimp-text-layer-get-antialias
+ * gimp-text-layer-set-antialias
*/
- procedure = gimp_procedure_new (text_layer_get_antialias_invoker);
+ procedure = gimp_procedure_new (text_layer_set_antialias_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
- "gimp-text-layer-get-antialias");
+ "gimp-text-layer-set-antialias");
gimp_procedure_set_static_strings (procedure,
- "gimp-text-layer-get-antialias",
- "Check if antialiasing is used in the text layer.",
- "This procedure checks if antialiasing is enabled in the specified text layer.",
+ "gimp-text-layer-set-antialias",
+ "Enable/disable anti-aliasing in a text layer.",
+ "This procedure enables or disables anti-aliasing of the text in a text layer.",
"Marcus Heese <heese cip ifi lmu de>",
"Marcus Heese",
"2008",
@@ -1638,12 +1400,12 @@
"The text layer",
pdb->gimp, FALSE,
GIMP_PARAM_READWRITE));
- gimp_procedure_add_return_value (procedure,
- g_param_spec_boolean ("antialias",
- "antialias",
- "A flag which is true if antialiasing is used for rendering the font in the text layer.",
- FALSE,
- GIMP_PARAM_READWRITE));
+ gimp_procedure_add_argument (procedure,
+ g_param_spec_boolean ("antialias",
+ "antialias",
+ "Enable/disable antialiasing of the text",
+ FALSE,
+ GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
@@ -1677,6 +1439,35 @@
g_object_unref (procedure);
/*
+ * gimp-text-layer-set-kerning
+ */
+ procedure = gimp_procedure_new (text_layer_set_kerning_invoker);
+ gimp_object_set_static_name (GIMP_OBJECT (procedure),
+ "gimp-text-layer-set-kerning");
+ gimp_procedure_set_static_strings (procedure,
+ "gimp-text-layer-set-kerning",
+ "Enable/disable kerning in a text layer.",
+ "This procedure enables or disables kerning in a text layer.",
+ "Marcus Heese <heese cip ifi lmu de>",
+ "Marcus Heese",
+ "2008",
+ NULL);
+ gimp_procedure_add_argument (procedure,
+ gimp_param_spec_layer_id ("layer",
+ "layer",
+ "The text layer",
+ pdb->gimp, FALSE,
+ GIMP_PARAM_READWRITE));
+ gimp_procedure_add_argument (procedure,
+ g_param_spec_boolean ("kerning",
+ "kerning",
+ "Enable/disable kerning in the text",
+ FALSE,
+ GIMP_PARAM_READWRITE));
+ gimp_pdb_register_procedure (pdb, procedure);
+ g_object_unref (procedure);
+
+ /*
* gimp-text-layer-get-language
*/
procedure = gimp_procedure_new (text_layer_get_language_invoker);
@@ -1707,6 +1498,36 @@
g_object_unref (procedure);
/*
+ * gimp-text-layer-set-language
+ */
+ procedure = gimp_procedure_new (text_layer_set_language_invoker);
+ gimp_object_set_static_name (GIMP_OBJECT (procedure),
+ "gimp-text-layer-set-language");
+ gimp_procedure_set_static_strings (procedure,
+ "gimp-text-layer-set-language",
+ "Set the language of the text layer.",
+ "This procedure sets the language of the text in text layer. For some scripts the language has an influence of how the text is rendered.",
+ "Marcus Heese <heese cip ifi lmu de>",
+ "Marcus Heese",
+ "2008",
+ NULL);
+ gimp_procedure_add_argument (procedure,
+ gimp_param_spec_layer_id ("layer",
+ "layer",
+ "The text layer",
+ pdb->gimp, FALSE,
+ GIMP_PARAM_READWRITE));
+ gimp_procedure_add_argument (procedure,
+ gimp_param_spec_string ("language",
+ "language",
+ "The new language to use for the text layer",
+ FALSE, FALSE, FALSE,
+ NULL,
+ GIMP_PARAM_READWRITE));
+ gimp_pdb_register_procedure (pdb, procedure);
+ g_object_unref (procedure);
+
+ /*
* gimp-text-layer-get-base-direction
*/
procedure = gimp_procedure_new (text_layer_get_base_direction_invoker);
@@ -1737,6 +1558,36 @@
g_object_unref (procedure);
/*
+ * gimp-text-layer-set-base-direction
+ */
+ procedure = gimp_procedure_new (text_layer_set_base_direction_invoker);
+ gimp_object_set_static_name (GIMP_OBJECT (procedure),
+ "gimp-text-layer-set-base-direction");
+ gimp_procedure_set_static_strings (procedure,
+ "gimp-text-layer-set-base-direction",
+ "Set the base direction in the text layer.",
+ "This procedure sets the base direction used in applying the Unicode bidirectional algorithm when rendering the text.",
+ "Marcus Heese <heese cip ifi lmu de>",
+ "Marcus Heese",
+ "2008",
+ NULL);
+ gimp_procedure_add_argument (procedure,
+ gimp_param_spec_layer_id ("layer",
+ "layer",
+ "The text layer",
+ pdb->gimp, FALSE,
+ GIMP_PARAM_READWRITE));
+ gimp_procedure_add_argument (procedure,
+ g_param_spec_enum ("direction",
+ "direction",
+ "The base direction of the text.",
+ GIMP_TYPE_TEXT_DIRECTION,
+ GIMP_TEXT_DIRECTION_LTR,
+ GIMP_PARAM_READWRITE));
+ gimp_pdb_register_procedure (pdb, procedure);
+ g_object_unref (procedure);
+
+ /*
* gimp-text-layer-get-justification
*/
procedure = gimp_procedure_new (text_layer_get_justification_invoker);
@@ -1767,6 +1618,36 @@
g_object_unref (procedure);
/*
+ * gimp-text-layer-set-justification
+ */
+ procedure = gimp_procedure_new (text_layer_set_justification_invoker);
+ gimp_object_set_static_name (GIMP_OBJECT (procedure),
+ "gimp-text-layer-set-justification");
+ gimp_procedure_set_static_strings (procedure,
+ "gimp-text-layer-set-justification",
+ "Set the justification of the text in a text layer.",
+ "This procedure sets the alignment of the lines in the text layer relative to each other.",
+ "Marcus Heese <heese cip ifi lmu de>",
+ "Marcus Heese",
+ "2008",
+ NULL);
+ gimp_procedure_add_argument (procedure,
+ gimp_param_spec_layer_id ("layer",
+ "layer",
+ "The text layer",
+ pdb->gimp, FALSE,
+ GIMP_PARAM_READWRITE));
+ gimp_procedure_add_argument (procedure,
+ g_param_spec_enum ("justify",
+ "justify",
+ "The justification for your text.",
+ GIMP_TYPE_TEXT_JUSTIFICATION,
+ GIMP_TEXT_JUSTIFY_LEFT,
+ GIMP_PARAM_READWRITE));
+ gimp_pdb_register_procedure (pdb, procedure);
+ g_object_unref (procedure);
+
+ /*
* gimp-text-layer-get-color
*/
procedure = gimp_procedure_new (text_layer_get_color_invoker);
@@ -1797,6 +1678,36 @@
g_object_unref (procedure);
/*
+ * gimp-text-layer-set-color
+ */
+ procedure = gimp_procedure_new (text_layer_set_color_invoker);
+ gimp_object_set_static_name (GIMP_OBJECT (procedure),
+ "gimp-text-layer-set-color");
+ gimp_procedure_set_static_strings (procedure,
+ "gimp-text-layer-set-color",
+ "Set the color of the text in the text layer.",
+ "This procedure sets the text color in the text layer 'layer'.",
+ "Marcus Heese <heese cip ifi lmu de>",
+ "Marcus Heese",
+ "2008",
+ NULL);
+ gimp_procedure_add_argument (procedure,
+ gimp_param_spec_layer_id ("layer",
+ "layer",
+ "The text layer",
+ pdb->gimp, FALSE,
+ GIMP_PARAM_READWRITE));
+ gimp_procedure_add_argument (procedure,
+ gimp_param_spec_rgb ("color",
+ "color",
+ "The color to use for the text",
+ FALSE,
+ NULL,
+ GIMP_PARAM_READWRITE));
+ gimp_pdb_register_procedure (pdb, procedure);
+ g_object_unref (procedure);
+
+ /*
* gimp-text-layer-get-indent
*/
procedure = gimp_procedure_new (text_layer_get_indent_invoker);
@@ -1826,6 +1737,35 @@
g_object_unref (procedure);
/*
+ * gimp-text-layer-set-indent
+ */
+ procedure = gimp_procedure_new (text_layer_set_indent_invoker);
+ gimp_object_set_static_name (GIMP_OBJECT (procedure),
+ "gimp-text-layer-set-indent");
+ gimp_procedure_set_static_strings (procedure,
+ "gimp-text-layer-set-indent",
+ "Set the indentation of the first line in a text layer.",
+ "This procedure sets the indentation of the first line in the text layer.",
+ "Marcus Heese <heese cip ifi lmu de>",
+ "Marcus Heese",
+ "2008",
+ NULL);
+ gimp_procedure_add_argument (procedure,
+ gimp_param_spec_layer_id ("layer",
+ "layer",
+ "The text layer",
+ pdb->gimp, FALSE,
+ GIMP_PARAM_READWRITE));
+ gimp_procedure_add_argument (procedure,
+ g_param_spec_double ("indent",
+ "indent",
+ "The indentation for the first line.",
+ -8192.0, 8192.0, -8192.0,
+ GIMP_PARAM_READWRITE));
+ gimp_pdb_register_procedure (pdb, procedure);
+ g_object_unref (procedure);
+
+ /*
* gimp-text-layer-get-line-spacing
*/
procedure = gimp_procedure_new (text_layer_get_line_spacing_invoker);
@@ -1855,6 +1795,35 @@
g_object_unref (procedure);
/*
+ * gimp-text-layer-set-line-spacing
+ */
+ procedure = gimp_procedure_new (text_layer_set_line_spacing_invoker);
+ gimp_object_set_static_name (GIMP_OBJECT (procedure),
+ "gimp-text-layer-set-line-spacing");
+ gimp_procedure_set_static_strings (procedure,
+ "gimp-text-layer-set-line-spacing",
+ "Adjust the line spacing in a text layer.",
+ "This procedure sets the additional spacing used between lines a text layer.",
+ "Marcus Heese <heese cip ifi lmu de>",
+ "Marcus Heese",
+ "2008",
+ NULL);
+ gimp_procedure_add_argument (procedure,
+ gimp_param_spec_layer_id ("layer",
+ "layer",
+ "The text layer",
+ pdb->gimp, FALSE,
+ GIMP_PARAM_READWRITE));
+ gimp_procedure_add_argument (procedure,
+ g_param_spec_double ("line-spacing",
+ "line spacing",
+ "The additional line spacing to use.",
+ -8192.0, 8192.0, -8192.0,
+ GIMP_PARAM_READWRITE));
+ gimp_pdb_register_procedure (pdb, procedure);
+ g_object_unref (procedure);
+
+ /*
* gimp-text-layer-get-letter-spacing
*/
procedure = gimp_procedure_new (text_layer_get_letter_spacing_invoker);
@@ -1882,4 +1851,33 @@
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
+
+ /*
+ * gimp-text-layer-set-letter-spacing
+ */
+ procedure = gimp_procedure_new (text_layer_set_letter_spacing_invoker);
+ gimp_object_set_static_name (GIMP_OBJECT (procedure),
+ "gimp-text-layer-set-letter-spacing");
+ gimp_procedure_set_static_strings (procedure,
+ "gimp-text-layer-set-letter-spacing",
+ "Adjust the letter spacing in a text layer.",
+ "This procedure sets the additional spacing between the single glyphs in a text layer.",
+ "Marcus Heese <heese cip ifi lmu de>",
+ "Marcus Heese",
+ "2008",
+ NULL);
+ gimp_procedure_add_argument (procedure,
+ gimp_param_spec_layer_id ("layer",
+ "layer",
+ "The text layer",
+ pdb->gimp, FALSE,
+ GIMP_PARAM_READWRITE));
+ gimp_procedure_add_argument (procedure,
+ g_param_spec_double ("letter-spacing",
+ "letter spacing",
+ "The additional letter spacing to use.",
+ -8192.0, 8192.0, -8192.0,
+ GIMP_PARAM_READWRITE));
+ gimp_pdb_register_procedure (pdb, procedure);
+ g_object_unref (procedure);
}
Modified: trunk/libgimp/gimp.c
==============================================================================
--- trunk/libgimp/gimp.c (original)
+++ trunk/libgimp/gimp.c Fri Apr 4 16:42:50 2008
@@ -690,6 +690,193 @@
}
}
+#if 0
+static GimpParam *
+gimp_run_procedure_internal (const gchar *name,
+ gint *n_return_vals,
+ gboolean async,
+ GimpProcedureReturn retval_callback,
+ gpointer retval_data,
+ va_list args)
+{
+ GimpPDBArgType param_type;
+ GimpParam *return_vals;
+ GimpParam *params = NULL;
+ gint n_params = 0;
+ gint i;
+
+ g_return_val_if_fail (name != NULL, NULL);
+ g_return_val_if_fail (n_return_vals != NULL, NULL);
+
+ param_type = va_arg (args, GimpPDBArgType);
+
+ while (param_type != GIMP_PDB_END)
+ {
+ switch (param_type)
+ {
+ case GIMP_PDB_INT32:
+ case GIMP_PDB_DISPLAY:
+ case GIMP_PDB_IMAGE:
+ case GIMP_PDB_LAYER:
+ case GIMP_PDB_CHANNEL:
+ case GIMP_PDB_DRAWABLE:
+ case GIMP_PDB_SELECTION:
+ case GIMP_PDB_BOUNDARY:
+ case GIMP_PDB_VECTORS:
+ case GIMP_PDB_STATUS:
+ (void) va_arg (args, gint);
+ break;
+ case GIMP_PDB_INT16:
+ (void) va_arg (args, gint);
+ break;
+ case GIMP_PDB_INT8:
+ (void) va_arg (args, gint);
+ break;
+ case GIMP_PDB_FLOAT:
+ (void) va_arg (args, gdouble);
+ break;
+ case GIMP_PDB_STRING:
+ (void) va_arg (args, gchar *);
+ break;
+ case GIMP_PDB_INT32ARRAY:
+ (void) va_arg (args, gint32 *);
+ break;
+ case GIMP_PDB_INT16ARRAY:
+ (void) va_arg (args, gint16 *);
+ break;
+ case GIMP_PDB_INT8ARRAY:
+ (void) va_arg (args, gint8 *);
+ break;
+ case GIMP_PDB_FLOATARRAY:
+ (void) va_arg (args, gdouble *);
+ break;
+ case GIMP_PDB_STRINGARRAY:
+ (void) va_arg (args, gchar **);
+ break;
+ case GIMP_PDB_COLOR:
+ (void) va_arg (args, GimpRGB *);
+ break;
+ case GIMP_PDB_PARASITE:
+ (void) va_arg (args, GimpParasite *);
+ break;
+ case GIMP_PDB_REGION:
+ break;
+ case GIMP_PDB_END:
+ break;
+ }
+
+ n_params++;
+
+ param_type = va_arg (args, GimpPDBArgType);
+ }
+
+ va_end (args);
+
+ params = g_new0 (GimpParam, n_params);
+
+ va_start (args, n_return_vals);
+
+ for (i = 0; i < n_params; i++)
+ {
+ params[i].type = va_arg (args, GimpPDBArgType);
+
+ switch (params[i].type)
+ {
+ case GIMP_PDB_INT32:
+ params[i].data.d_int32 = (gint32) va_arg (args, gint);
+ break;
+ case GIMP_PDB_INT16:
+ params[i].data.d_int16 = (gint16) va_arg (args, gint);
+ break;
+ case GIMP_PDB_INT8:
+ params[i].data.d_int8 = (guint8) va_arg (args, gint);
+ break;
+ case GIMP_PDB_FLOAT:
+ params[i].data.d_float = (gdouble) va_arg (args, gdouble);
+ break;
+ case GIMP_PDB_STRING:
+ params[i].data.d_string = va_arg (args, gchar *);
+ break;
+ case GIMP_PDB_INT32ARRAY:
+ params[i].data.d_int32array = va_arg (args, gint32 *);
+ break;
+ case GIMP_PDB_INT16ARRAY:
+ params[i].data.d_int16array = va_arg (args, gint16 *);
+ break;
+ case GIMP_PDB_INT8ARRAY:
+ params[i].data.d_int8array = va_arg (args, guint8 *);
+ break;
+ case GIMP_PDB_FLOATARRAY:
+ params[i].data.d_floatarray = va_arg (args, gdouble *);
+ break;
+ case GIMP_PDB_STRINGARRAY:
+ params[i].data.d_stringarray = va_arg (args, gchar **);
+ break;
+ case GIMP_PDB_COLOR:
+ params[i].data.d_color = *va_arg (args, GimpRGB *);
+ break;
+ case GIMP_PDB_REGION:
+ break;
+ case GIMP_PDB_DISPLAY:
+ params[i].data.d_display = va_arg (args, gint32);
+ break;
+ case GIMP_PDB_IMAGE:
+ params[i].data.d_image = va_arg (args, gint32);
+ break;
+ case GIMP_PDB_LAYER:
+ params[i].data.d_layer = va_arg (args, gint32);
+ break;
+ case GIMP_PDB_CHANNEL:
+ params[i].data.d_channel = va_arg (args, gint32);
+ break;
+ case GIMP_PDB_DRAWABLE:
+ params[i].data.d_drawable = va_arg (args, gint32);
+ break;
+ case GIMP_PDB_SELECTION:
+ params[i].data.d_selection = va_arg (args, gint32);
+ break;
+ case GIMP_PDB_BOUNDARY:
+ params[i].data.d_boundary = va_arg (args, gint32);
+ break;
+ case GIMP_PDB_VECTORS:
+ params[i].data.d_vectors = va_arg (args, gint32);
+ break;
+ case GIMP_PDB_PARASITE:
+ {
+ GimpParasite *parasite = va_arg (args, GimpParasite *);
+
+ if (parasite == NULL)
+ {
+ params[i].data.d_parasite.name = NULL;
+ params[i].data.d_parasite.data = NULL;
+ }
+ else
+ {
+ params[i].data.d_parasite.name = parasite->name;
+ params[i].data.d_parasite.flags = parasite->flags;
+ params[i].data.d_parasite.size = parasite->size;
+ params[i].data.d_parasite.data = parasite->data;
+ }
+ }
+ break;
+ case GIMP_PDB_STATUS:
+ params[i].data.d_status = va_arg (args, gint32);
+ break;
+ case GIMP_PDB_END:
+ break;
+ }
+ }
+
+ va_end (args);
+
+ return_vals = gimp_run_procedure2 (name, n_return_vals, n_params, params);
+
+ g_free (params);
+
+ return return_vals;
+}
+#endif
+
/**
* gimp_run_procedure:
* @name: the name of the procedure to run
Modified: trunk/libgimp/gimp.def
==============================================================================
--- trunk/libgimp/gimp.def (original)
+++ trunk/libgimp/gimp.def Fri Apr 4 16:42:50 2008
@@ -613,7 +613,7 @@
gimp_text_layer_get_base_direction
gimp_text_layer_get_color
gimp_text_layer_get_font
- gimp_text_layer_get_fontsize
+ gimp_text_layer_get_font_size
gimp_text_layer_get_hinting
gimp_text_layer_get_indent
gimp_text_layer_get_justification
@@ -627,7 +627,7 @@
gimp_text_layer_set_base_direction
gimp_text_layer_set_color
gimp_text_layer_set_font
- gimp_text_layer_set_fontsize
+ gimp_text_layer_set_font_size
gimp_text_layer_set_hinting
gimp_text_layer_set_indent
gimp_text_layer_set_justification
Modified: trunk/libgimp/gimp.h
==============================================================================
--- trunk/libgimp/gimp.h (original)
+++ trunk/libgimp/gimp.h Fri Apr 4 16:42:50 2008
@@ -272,6 +272,11 @@
*/
void gimp_extension_process (guint timeout);
+
+typedef void (* GimpProcedureReturn) (GimpParam *return_vals,
+ gint n_return_vals,
+ gpointer user_data);
+
/* Run a procedure in the procedure database. The parameters are
* specified via the variable length argument list. The return
* values are returned in the 'GimpParam*' array.
@@ -279,6 +284,11 @@
GimpParam * gimp_run_procedure (const gchar *name,
gint *n_return_vals,
...);
+void gimp_run_procedure_async (const gchar *name,
+ gint *n_return_vals,
+ GimpProcedureReturn retval_callback,
+ gpointer retval_data,
+ ...);
/* Run a procedure in the procedure database. The parameters are
* specified as an array of GimpParam. The return
@@ -288,6 +298,12 @@
gint *n_return_vals,
gint n_params,
const GimpParam *params);
+void gimp_run_procedure2_async (const gchar *name,
+ gint *n_return_vals,
+ gint n_params,
+ const GimpParam *params,
+ GimpProcedureReturn retval_callback,
+ gpointer retval_data);
/* Destroy the an array of parameters. This is useful for
* destroying the return values returned by a call to
Modified: trunk/libgimp/gimptextlayer_pdb.c
==============================================================================
--- trunk/libgimp/gimptextlayer_pdb.c (original)
+++ trunk/libgimp/gimptextlayer_pdb.c Fri Apr 4 16:42:50 2008
@@ -75,64 +75,62 @@
}
/**
- * gimp_text_layer_set_text:
+ * gimp_text_layer_get_text:
* @layer_ID: The text layer.
- * @text: The new text to set.
*
- * Set the text of a text layer.
+ * Get the text from a text layer as string.
*
- * This procedure changes the text of a text layer.
+ * This procedure returns the text from a text layer as a string.
*
- * Returns: TRUE on success.
+ * Returns: The text from the specified text layer.
*
* Since: GIMP 2.6
*/
-gboolean
-gimp_text_layer_set_text (gint32 layer_ID,
- const gchar *text)
+gchar *
+gimp_text_layer_get_text (gint32 layer_ID)
{
GimpParam *return_vals;
gint nreturn_vals;
- gboolean success = TRUE;
+ gchar *text = NULL;
- return_vals = gimp_run_procedure ("gimp-text-layer-set-text",
+ return_vals = gimp_run_procedure ("gimp-text-layer-get-text",
&nreturn_vals,
GIMP_PDB_LAYER, layer_ID,
- GIMP_PDB_STRING, text,
GIMP_PDB_END);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
+ text = g_strdup (return_vals[1].data.d_string);
gimp_destroy_params (return_vals, nreturn_vals);
- return success;
+ return text;
}
/**
- * gimp_text_layer_set_font:
+ * gimp_text_layer_set_text:
* @layer_ID: The text layer.
- * @font: The new font to use.
+ * @text: The new text to set.
*
- * Set the font of a text layer.
+ * Set the text of a text layer.
*
- * This procedure modifies the font used in the specified text layer.
+ * This procedure changes the text of a text layer.
*
* Returns: TRUE on success.
*
* Since: GIMP 2.6
*/
gboolean
-gimp_text_layer_set_font (gint32 layer_ID,
- const gchar *font)
+gimp_text_layer_set_text (gint32 layer_ID,
+ const gchar *text)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-text-layer-set-font",
+ return_vals = gimp_run_procedure ("gimp-text-layer-set-text",
&nreturn_vals,
GIMP_PDB_LAYER, layer_ID,
- GIMP_PDB_STRING, font,
+ GIMP_PDB_STRING, text,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@@ -143,73 +141,62 @@
}
/**
- * gimp_text_layer_set_fontsize:
+ * gimp_text_layer_get_font:
* @layer_ID: The text layer.
- * @font_size: The font size.
- * @unit: The unit to use for the font size.
*
- * Set the font size.
+ * Get the font from a text layer as string.
*
- * This procedure changes the font size of a text layer. The size of
- * your font will be a double 'font-size' of 'unit' units.
+ * This procedure returns the name of the font from a text layer.
*
- * Returns: TRUE on success.
+ * Returns: The font which is used in the specified text layer.
*
* Since: GIMP 2.6
*/
-gboolean
-gimp_text_layer_set_fontsize (gint32 layer_ID,
- gdouble font_size,
- GimpUnit unit)
+gchar *
+gimp_text_layer_get_font (gint32 layer_ID)
{
GimpParam *return_vals;
gint nreturn_vals;
- gboolean success = TRUE;
+ gchar *font = NULL;
- return_vals = gimp_run_procedure ("gimp-text-layer-set-fontsize",
+ return_vals = gimp_run_procedure ("gimp-text-layer-get-font",
&nreturn_vals,
GIMP_PDB_LAYER, layer_ID,
- GIMP_PDB_FLOAT, font_size,
- GIMP_PDB_INT32, unit,
GIMP_PDB_END);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
+ font = g_strdup (return_vals[1].data.d_string);
gimp_destroy_params (return_vals, nreturn_vals);
- return success;
+ return font;
}
/**
- * gimp_text_layer_set_hinting:
+ * gimp_text_layer_set_font:
* @layer_ID: The text layer.
- * @hinting: Enable/disable the use of hinting on the text.
- * @autohint: Force the use of the autohinter provided through FreeType.
+ * @font: The new font to use.
*
- * Enable/disable the use of hinting in a text layer.
+ * Set the font of a text layer.
*
- * This procedure enables or disables hinting on the text of a text
- * layer. If you enable 'auto-hint', FreeType\'s automatic hinter will
- * be used and hinting information from the font will be ignored.
+ * This procedure modifies the font used in the specified text layer.
*
* Returns: TRUE on success.
*
* Since: GIMP 2.6
*/
gboolean
-gimp_text_layer_set_hinting (gint32 layer_ID,
- gboolean hinting,
- gboolean autohint)
+gimp_text_layer_set_font (gint32 layer_ID,
+ const gchar *font)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-text-layer-set-hinting",
+ return_vals = gimp_run_procedure ("gimp-text-layer-set-font",
&nreturn_vals,
GIMP_PDB_LAYER, layer_ID,
- GIMP_PDB_INT32, hinting,
- GIMP_PDB_INT32, autohint,
+ GIMP_PDB_STRING, font,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@@ -220,65 +207,73 @@
}
/**
- * gimp_text_layer_set_antialias:
+ * gimp_text_layer_get_font_size:
* @layer_ID: The text layer.
- * @antialias: Enable/disable antialiasing of the text.
+ * @unit: The unit used for the font size.
*
- * Enable/disable anti-aliasing in a text layer.
+ * Get the font size from a text layer.
*
- * This procedure enables or disables anti-aliasing of the text in a
- * text layer.
+ * This procedure returns the size of the font which is used in a text
+ * layer. You will receive the size as a float 'font-size' in 'unit'
+ * units.
*
- * Returns: TRUE on success.
+ * Returns: The font size.
*
* Since: GIMP 2.6
*/
-gboolean
-gimp_text_layer_set_antialias (gint32 layer_ID,
- gboolean antialias)
+gdouble
+gimp_text_layer_get_font_size (gint32 layer_ID,
+ GimpUnit *unit)
{
GimpParam *return_vals;
gint nreturn_vals;
- gboolean success = TRUE;
+ gdouble font_size = 0.0;
- return_vals = gimp_run_procedure ("gimp-text-layer-set-antialias",
+ return_vals = gimp_run_procedure ("gimp-text-layer-get-font-size",
&nreturn_vals,
GIMP_PDB_LAYER, layer_ID,
- GIMP_PDB_INT32, antialias,
GIMP_PDB_END);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
+ {
+ font_size = return_vals[1].data.d_float;
+ *unit = return_vals[2].data.d_unit;
+ }
gimp_destroy_params (return_vals, nreturn_vals);
- return success;
+ return font_size;
}
/**
- * gimp_text_layer_set_kerning:
+ * gimp_text_layer_set_font_size:
* @layer_ID: The text layer.
- * @kerning: Enable/disable kerning in the text.
+ * @font_size: The font size.
+ * @unit: The unit to use for the font size.
*
- * Enable/disable kerning in a text layer.
+ * Set the font size.
*
- * This procedure enables or disables kerning in a text layer.
+ * This procedure changes the font size of a text layer. The size of
+ * your font will be a double 'font-size' of 'unit' units.
*
* Returns: TRUE on success.
*
* Since: GIMP 2.6
*/
gboolean
-gimp_text_layer_set_kerning (gint32 layer_ID,
- gboolean kerning)
+gimp_text_layer_set_font_size (gint32 layer_ID,
+ gdouble font_size,
+ GimpUnit unit)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-text-layer-set-kerning",
+ return_vals = gimp_run_procedure ("gimp-text-layer-set-font-size",
&nreturn_vals,
GIMP_PDB_LAYER, layer_ID,
- GIMP_PDB_INT32, kerning,
+ GIMP_PDB_FLOAT, font_size,
+ GIMP_PDB_INT32, unit,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@@ -289,66 +284,73 @@
}
/**
- * gimp_text_layer_set_language:
+ * gimp_text_layer_get_hinting:
* @layer_ID: The text layer.
- * @language: The new language to use for the text layer.
+ * @autohint: A flag which is true if the text layer is forced to use the autohinter from FreeType.
*
- * Set the language of the text layer.
+ * Get information about hinting in the specified text layer.
*
- * This procedure sets the language of the text in text layer. For some
- * scripts the language has an influence of how the text is rendered.
+ * This procedure provides information about the hinting that is being
+ * used in a text layer.
*
- * Returns: TRUE on success.
+ * Returns: A flag which is true if hinting is used on the font.
*
* Since: GIMP 2.6
*/
gboolean
-gimp_text_layer_set_language (gint32 layer_ID,
- const gchar *language)
+gimp_text_layer_get_hinting (gint32 layer_ID,
+ gboolean *autohint)
{
GimpParam *return_vals;
gint nreturn_vals;
- gboolean success = TRUE;
+ gboolean hinting = FALSE;
- return_vals = gimp_run_procedure ("gimp-text-layer-set-language",
+ return_vals = gimp_run_procedure ("gimp-text-layer-get-hinting",
&nreturn_vals,
GIMP_PDB_LAYER, layer_ID,
- GIMP_PDB_STRING, language,
GIMP_PDB_END);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
+ {
+ hinting = return_vals[1].data.d_int32;
+ *autohint = return_vals[2].data.d_int32;
+ }
gimp_destroy_params (return_vals, nreturn_vals);
- return success;
+ return hinting;
}
/**
- * gimp_text_layer_set_base_direction:
+ * gimp_text_layer_set_hinting:
* @layer_ID: The text layer.
- * @direction: The base direction of the text.
+ * @hinting: Enable/disable the use of hinting on the text.
+ * @autohint: Force the use of the autohinter provided through FreeType.
*
- * Set the base direction in the text layer.
+ * Enable/disable the use of hinting in a text layer.
*
- * This procedure sets the base direction used in applying the Unicode
- * bidirectional algorithm when rendering the text.
+ * This procedure enables or disables hinting on the text of a text
+ * layer. If you enable 'auto-hint', FreeType\'s automatic hinter will
+ * be used and hinting information from the font will be ignored.
*
* Returns: TRUE on success.
*
* Since: GIMP 2.6
*/
gboolean
-gimp_text_layer_set_base_direction (gint32 layer_ID,
- GimpTextDirection direction)
+gimp_text_layer_set_hinting (gint32 layer_ID,
+ gboolean hinting,
+ gboolean autohint)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-text-layer-set-base-direction",
+ return_vals = gimp_run_procedure ("gimp-text-layer-set-hinting",
&nreturn_vals,
GIMP_PDB_LAYER, layer_ID,
- GIMP_PDB_INT32, direction,
+ GIMP_PDB_INT32, hinting,
+ GIMP_PDB_INT32, autohint,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@@ -359,65 +361,64 @@
}
/**
- * gimp_text_layer_set_justification:
+ * gimp_text_layer_get_antialias:
* @layer_ID: The text layer.
- * @justify: The justification for your text.
*
- * Set the justification of the text in a text layer.
+ * Check if antialiasing is used in the text layer.
*
- * This procedure sets the alignment of the lines in the text layer
- * relative to each other.
+ * This procedure checks if antialiasing is enabled in the specified
+ * text layer.
*
- * Returns: TRUE on success.
+ * Returns: A flag which is true if antialiasing is used for rendering the font in the text layer.
*
* Since: GIMP 2.6
*/
gboolean
-gimp_text_layer_set_justification (gint32 layer_ID,
- GimpTextJustification justify)
+gimp_text_layer_get_antialias (gint32 layer_ID)
{
GimpParam *return_vals;
gint nreturn_vals;
- gboolean success = TRUE;
+ gboolean antialias = FALSE;
- return_vals = gimp_run_procedure ("gimp-text-layer-set-justification",
+ return_vals = gimp_run_procedure ("gimp-text-layer-get-antialias",
&nreturn_vals,
GIMP_PDB_LAYER, layer_ID,
- GIMP_PDB_INT32, justify,
GIMP_PDB_END);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
+ antialias = return_vals[1].data.d_int32;
gimp_destroy_params (return_vals, nreturn_vals);
- return success;
+ return antialias;
}
/**
- * gimp_text_layer_set_color:
+ * gimp_text_layer_set_antialias:
* @layer_ID: The text layer.
- * @color: The color to use for the text.
+ * @antialias: Enable/disable antialiasing of the text.
*
- * Set the color of the text in the text layer.
+ * Enable/disable anti-aliasing in a text layer.
*
- * This procedure sets the text color in the text layer 'layer'.
+ * This procedure enables or disables anti-aliasing of the text in a
+ * text layer.
*
* Returns: TRUE on success.
*
* Since: GIMP 2.6
*/
gboolean
-gimp_text_layer_set_color (gint32 layer_ID,
- const GimpRGB *color)
+gimp_text_layer_set_antialias (gint32 layer_ID,
+ gboolean antialias)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-text-layer-set-color",
+ return_vals = gimp_run_procedure ("gimp-text-layer-set-antialias",
&nreturn_vals,
GIMP_PDB_LAYER, layer_ID,
- GIMP_PDB_COLOR, color,
+ GIMP_PDB_INT32, antialias,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@@ -428,66 +429,63 @@
}
/**
- * gimp_text_layer_set_indent:
+ * gimp_text_layer_get_kerning:
* @layer_ID: The text layer.
- * @indent: The indentation for the first line.
*
- * Set the indentation of the first line in a text layer.
+ * Check if kerning is used in the text layer.
*
- * This procedure sets the indentation of the first line in the text
+ * This procedure checks if kerning is enabled in the specified text
* layer.
*
- * Returns: TRUE on success.
+ * Returns: A flag which is true if kerning is used in the text layer.
*
* Since: GIMP 2.6
*/
gboolean
-gimp_text_layer_set_indent (gint32 layer_ID,
- gdouble indent)
+gimp_text_layer_get_kerning (gint32 layer_ID)
{
GimpParam *return_vals;
gint nreturn_vals;
- gboolean success = TRUE;
+ gboolean kerning = FALSE;
- return_vals = gimp_run_procedure ("gimp-text-layer-set-indent",
+ return_vals = gimp_run_procedure ("gimp-text-layer-get-kerning",
&nreturn_vals,
GIMP_PDB_LAYER, layer_ID,
- GIMP_PDB_FLOAT, indent,
GIMP_PDB_END);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
+ kerning = return_vals[1].data.d_int32;
gimp_destroy_params (return_vals, nreturn_vals);
- return success;
+ return kerning;
}
/**
- * gimp_text_layer_set_line_spacing:
+ * gimp_text_layer_set_kerning:
* @layer_ID: The text layer.
- * @line_spacing: The additional line spacing to use.
+ * @kerning: Enable/disable kerning in the text.
*
- * Adjust the line spacing in a text layer.
+ * Enable/disable kerning in a text layer.
*
- * This procedure sets the additional spacing used between lines a text
- * layer.
+ * This procedure enables or disables kerning in a text layer.
*
* Returns: TRUE on success.
*
* Since: GIMP 2.6
*/
gboolean
-gimp_text_layer_set_line_spacing (gint32 layer_ID,
- gdouble line_spacing)
+gimp_text_layer_set_kerning (gint32 layer_ID,
+ gboolean kerning)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-text-layer-set-line-spacing",
+ return_vals = gimp_run_procedure ("gimp-text-layer-set-kerning",
&nreturn_vals,
GIMP_PDB_LAYER, layer_ID,
- GIMP_PDB_FLOAT, line_spacing,
+ GIMP_PDB_INT32, kerning,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@@ -498,477 +496,479 @@
}
/**
- * gimp_text_layer_set_letter_spacing:
+ * gimp_text_layer_get_language:
* @layer_ID: The text layer.
- * @letter_spacing: The additional letter spacing to use.
*
- * Adjust the letter spacing in a text layer.
+ * Get the language used in the text layer.
*
- * This procedure sets the additional spacing between the single glyphs
- * in a text layer.
+ * This procedure returns the language string which is set for the text
+ * in the text layer.
*
- * Returns: TRUE on success.
+ * Returns: The language used in the text layer.
*
* Since: GIMP 2.6
*/
-gboolean
-gimp_text_layer_set_letter_spacing (gint32 layer_ID,
- gdouble letter_spacing)
+gchar *
+gimp_text_layer_get_language (gint32 layer_ID)
{
GimpParam *return_vals;
gint nreturn_vals;
- gboolean success = TRUE;
+ gchar *language = NULL;
- return_vals = gimp_run_procedure ("gimp-text-layer-set-letter-spacing",
+ return_vals = gimp_run_procedure ("gimp-text-layer-get-language",
&nreturn_vals,
GIMP_PDB_LAYER, layer_ID,
- GIMP_PDB_FLOAT, letter_spacing,
GIMP_PDB_END);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
+ language = g_strdup (return_vals[1].data.d_string);
gimp_destroy_params (return_vals, nreturn_vals);
- return success;
+ return language;
}
/**
- * gimp_text_layer_get_text:
+ * gimp_text_layer_set_language:
* @layer_ID: The text layer.
+ * @language: The new language to use for the text layer.
*
- * Get the text from a text layer as string.
+ * Set the language of the text layer.
*
- * This procedure returns the text from a text layer as a string.
+ * This procedure sets the language of the text in text layer. For some
+ * scripts the language has an influence of how the text is rendered.
*
- * Returns: The text from the specified text layer.
+ * Returns: TRUE on success.
*
* Since: GIMP 2.6
*/
-gchar *
-gimp_text_layer_get_text (gint32 layer_ID)
+gboolean
+gimp_text_layer_set_language (gint32 layer_ID,
+ const gchar *language)
{
GimpParam *return_vals;
gint nreturn_vals;
- gchar *text = NULL;
+ gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-text-layer-get-text",
+ return_vals = gimp_run_procedure ("gimp-text-layer-set-language",
&nreturn_vals,
GIMP_PDB_LAYER, layer_ID,
+ GIMP_PDB_STRING, language,
GIMP_PDB_END);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- text = g_strdup (return_vals[1].data.d_string);
+ success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
gimp_destroy_params (return_vals, nreturn_vals);
- return text;
+ return success;
}
/**
- * gimp_text_layer_get_font:
+ * gimp_text_layer_get_base_direction:
* @layer_ID: The text layer.
*
- * Get the font from a text layer as string.
+ * Get the base direction used for rendering the text layer.
*
- * This procedure returns the name of the font from a text layer.
+ * This procedure returns the base direction used for rendering the
+ * text in the text layer
*
- * Returns: The font which is used in the specified text layer.
+ * Returns: The based direction used for the text layer.
*
* Since: GIMP 2.6
*/
-gchar *
-gimp_text_layer_get_font (gint32 layer_ID)
+GimpTextDirection
+gimp_text_layer_get_base_direction (gint32 layer_ID)
{
GimpParam *return_vals;
gint nreturn_vals;
- gchar *font = NULL;
+ GimpTextDirection direction = 0;
- return_vals = gimp_run_procedure ("gimp-text-layer-get-font",
+ return_vals = gimp_run_procedure ("gimp-text-layer-get-base-direction",
&nreturn_vals,
GIMP_PDB_LAYER, layer_ID,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- font = g_strdup (return_vals[1].data.d_string);
+ direction = return_vals[1].data.d_int32;
gimp_destroy_params (return_vals, nreturn_vals);
- return font;
+ return direction;
}
/**
- * gimp_text_layer_get_fontsize:
+ * gimp_text_layer_set_base_direction:
* @layer_ID: The text layer.
- * @unit: The unit used for the font size.
+ * @direction: The base direction of the text.
*
- * Get the font size from a text layer.
+ * Set the base direction in the text layer.
*
- * This procedure returns the size of the font which is used in a text
- * layer. You will receive the size as a float 'font-size' in 'unit'
- * units.
+ * This procedure sets the base direction used in applying the Unicode
+ * bidirectional algorithm when rendering the text.
*
- * Returns: The font size.
+ * Returns: TRUE on success.
*
* Since: GIMP 2.6
*/
-gdouble
-gimp_text_layer_get_fontsize (gint32 layer_ID,
- GimpUnit *unit)
+gboolean
+gimp_text_layer_set_base_direction (gint32 layer_ID,
+ GimpTextDirection direction)
{
GimpParam *return_vals;
gint nreturn_vals;
- gdouble font_size = 0.0;
+ gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-text-layer-get-fontsize",
+ return_vals = gimp_run_procedure ("gimp-text-layer-set-base-direction",
&nreturn_vals,
GIMP_PDB_LAYER, layer_ID,
+ GIMP_PDB_INT32, direction,
GIMP_PDB_END);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- {
- font_size = return_vals[1].data.d_float;
- *unit = return_vals[2].data.d_unit;
- }
+ success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
gimp_destroy_params (return_vals, nreturn_vals);
- return font_size;
+ return success;
}
/**
- * gimp_text_layer_get_hinting:
+ * gimp_text_layer_get_justification:
* @layer_ID: The text layer.
- * @autohint: A flag which is true if the text layer is forced to use the autohinter from FreeType.
*
- * Get information about hinting in the specified text layer.
+ * Get the text justification information of the text layer.
*
- * This procedure provides information about the hinting that is being
- * used in a text layer.
+ * This procedure returns the alignment of the lines in the text layer
+ * relative to each other.
*
- * Returns: A flag which is true if hinting is used on the font.
+ * Returns: The justification used in the text layer.
*
* Since: GIMP 2.6
*/
-gboolean
-gimp_text_layer_get_hinting (gint32 layer_ID,
- gboolean *autohint)
+GimpTextJustification
+gimp_text_layer_get_justification (gint32 layer_ID)
{
GimpParam *return_vals;
gint nreturn_vals;
- gboolean hinting = FALSE;
+ GimpTextJustification justify = 0;
- return_vals = gimp_run_procedure ("gimp-text-layer-get-hinting",
+ return_vals = gimp_run_procedure ("gimp-text-layer-get-justification",
&nreturn_vals,
GIMP_PDB_LAYER, layer_ID,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- {
- hinting = return_vals[1].data.d_int32;
- *autohint = return_vals[2].data.d_int32;
- }
+ justify = return_vals[1].data.d_int32;
gimp_destroy_params (return_vals, nreturn_vals);
- return hinting;
+ return justify;
}
/**
- * gimp_text_layer_get_antialias:
+ * gimp_text_layer_set_justification:
* @layer_ID: The text layer.
+ * @justify: The justification for your text.
*
- * Check if antialiasing is used in the text layer.
+ * Set the justification of the text in a text layer.
*
- * This procedure checks if antialiasing is enabled in the specified
- * text layer.
+ * This procedure sets the alignment of the lines in the text layer
+ * relative to each other.
*
- * Returns: A flag which is true if antialiasing is used for rendering the font in the text layer.
+ * Returns: TRUE on success.
*
* Since: GIMP 2.6
*/
gboolean
-gimp_text_layer_get_antialias (gint32 layer_ID)
+gimp_text_layer_set_justification (gint32 layer_ID,
+ GimpTextJustification justify)
{
GimpParam *return_vals;
gint nreturn_vals;
- gboolean antialias = FALSE;
+ gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-text-layer-get-antialias",
+ return_vals = gimp_run_procedure ("gimp-text-layer-set-justification",
&nreturn_vals,
GIMP_PDB_LAYER, layer_ID,
+ GIMP_PDB_INT32, justify,
GIMP_PDB_END);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- antialias = return_vals[1].data.d_int32;
+ success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
gimp_destroy_params (return_vals, nreturn_vals);
- return antialias;
+ return success;
}
/**
- * gimp_text_layer_get_kerning:
+ * gimp_text_layer_get_color:
* @layer_ID: The text layer.
+ * @color: The color of the text.
*
- * Check if kerning is used in the text layer.
+ * Get the color of the text in a text layer.
*
- * This procedure checks if kerning is enabled in the specified text
- * layer.
+ * This procedure returns the color of the text in a text layer.
*
- * Returns: A flag which is true if kerning is used in the text layer.
+ * Returns: TRUE on success.
*
* Since: GIMP 2.6
*/
gboolean
-gimp_text_layer_get_kerning (gint32 layer_ID)
+gimp_text_layer_get_color (gint32 layer_ID,
+ GimpRGB *color)
{
GimpParam *return_vals;
gint nreturn_vals;
- gboolean kerning = FALSE;
+ gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-text-layer-get-kerning",
+ return_vals = gimp_run_procedure ("gimp-text-layer-get-color",
&nreturn_vals,
GIMP_PDB_LAYER, layer_ID,
GIMP_PDB_END);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- kerning = return_vals[1].data.d_int32;
+ success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+
+ if (success)
+ *color = return_vals[1].data.d_color;
gimp_destroy_params (return_vals, nreturn_vals);
- return kerning;
+ return success;
}
/**
- * gimp_text_layer_get_language:
+ * gimp_text_layer_set_color:
* @layer_ID: The text layer.
+ * @color: The color to use for the text.
*
- * Get the language used in the text layer.
+ * Set the color of the text in the text layer.
*
- * This procedure returns the language string which is set for the text
- * in the text layer.
+ * This procedure sets the text color in the text layer 'layer'.
*
- * Returns: The language used in the text layer.
+ * Returns: TRUE on success.
*
* Since: GIMP 2.6
*/
-gchar *
-gimp_text_layer_get_language (gint32 layer_ID)
+gboolean
+gimp_text_layer_set_color (gint32 layer_ID,
+ const GimpRGB *color)
{
GimpParam *return_vals;
gint nreturn_vals;
- gchar *language = NULL;
+ gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-text-layer-get-language",
+ return_vals = gimp_run_procedure ("gimp-text-layer-set-color",
&nreturn_vals,
GIMP_PDB_LAYER, layer_ID,
+ GIMP_PDB_COLOR, color,
GIMP_PDB_END);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- language = g_strdup (return_vals[1].data.d_string);
+ success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
gimp_destroy_params (return_vals, nreturn_vals);
- return language;
+ return success;
}
/**
- * gimp_text_layer_get_base_direction:
+ * gimp_text_layer_get_indent:
* @layer_ID: The text layer.
*
- * Get the base direction used for rendering the text layer.
+ * Get the line indentation of text layer.
*
- * This procedure returns the base direction used for rendering the
- * text in the text layer
+ * This procedure returns the indentation of the first line in a text
+ * layer.
*
- * Returns: The based direction used for the text layer.
+ * Returns: The indentation value of the first line.
*
* Since: GIMP 2.6
*/
-GimpTextDirection
-gimp_text_layer_get_base_direction (gint32 layer_ID)
+gdouble
+gimp_text_layer_get_indent (gint32 layer_ID)
{
GimpParam *return_vals;
gint nreturn_vals;
- GimpTextDirection direction = 0;
+ gdouble indent = 0.0;
- return_vals = gimp_run_procedure ("gimp-text-layer-get-base-direction",
+ return_vals = gimp_run_procedure ("gimp-text-layer-get-indent",
&nreturn_vals,
GIMP_PDB_LAYER, layer_ID,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- direction = return_vals[1].data.d_int32;
+ indent = return_vals[1].data.d_float;
gimp_destroy_params (return_vals, nreturn_vals);
- return direction;
+ return indent;
}
/**
- * gimp_text_layer_get_justification:
+ * gimp_text_layer_set_indent:
* @layer_ID: The text layer.
+ * @indent: The indentation for the first line.
*
- * Get the text justification information of the text layer.
+ * Set the indentation of the first line in a text layer.
*
- * This procedure returns the alignment of the lines in the text layer
- * relative to each other.
+ * This procedure sets the indentation of the first line in the text
+ * layer.
*
- * Returns: The justification used in the text layer.
+ * Returns: TRUE on success.
*
* Since: GIMP 2.6
*/
-GimpTextJustification
-gimp_text_layer_get_justification (gint32 layer_ID)
+gboolean
+gimp_text_layer_set_indent (gint32 layer_ID,
+ gdouble indent)
{
GimpParam *return_vals;
gint nreturn_vals;
- GimpTextJustification justify = 0;
+ gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-text-layer-get-justification",
+ return_vals = gimp_run_procedure ("gimp-text-layer-set-indent",
&nreturn_vals,
GIMP_PDB_LAYER, layer_ID,
+ GIMP_PDB_FLOAT, indent,
GIMP_PDB_END);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- justify = return_vals[1].data.d_int32;
+ success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
gimp_destroy_params (return_vals, nreturn_vals);
- return justify;
+ return success;
}
/**
- * gimp_text_layer_get_color:
+ * gimp_text_layer_get_line_spacing:
* @layer_ID: The text layer.
- * @color: The color of the text.
*
- * Get the color of the text in a text layer.
+ * Get the spacing between lines of text.
*
- * This procedure returns the color of the text in a text layer.
+ * This procedure returns the line-spacing between lines of text in a
+ * text layer.
*
- * Returns: TRUE on success.
+ * Returns: The line-spacing value.
*
* Since: GIMP 2.6
*/
-gboolean
-gimp_text_layer_get_color (gint32 layer_ID,
- GimpRGB *color)
+gdouble
+gimp_text_layer_get_line_spacing (gint32 layer_ID)
{
GimpParam *return_vals;
gint nreturn_vals;
- gboolean success = TRUE;
+ gdouble line_spacing = 0.0;
- return_vals = gimp_run_procedure ("gimp-text-layer-get-color",
+ return_vals = gimp_run_procedure ("gimp-text-layer-get-line-spacing",
&nreturn_vals,
GIMP_PDB_LAYER, layer_ID,
GIMP_PDB_END);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
-
- if (success)
- *color = return_vals[1].data.d_color;
+ if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
+ line_spacing = return_vals[1].data.d_float;
gimp_destroy_params (return_vals, nreturn_vals);
- return success;
+ return line_spacing;
}
/**
- * gimp_text_layer_get_indent:
+ * gimp_text_layer_set_line_spacing:
* @layer_ID: The text layer.
+ * @line_spacing: The additional line spacing to use.
*
- * Get the line indentation of text layer.
+ * Adjust the line spacing in a text layer.
*
- * This procedure returns the indentation of the first line in a text
+ * This procedure sets the additional spacing used between lines a text
* layer.
*
- * Returns: The indentation value of the first line.
+ * Returns: TRUE on success.
*
* Since: GIMP 2.6
*/
-gdouble
-gimp_text_layer_get_indent (gint32 layer_ID)
+gboolean
+gimp_text_layer_set_line_spacing (gint32 layer_ID,
+ gdouble line_spacing)
{
GimpParam *return_vals;
gint nreturn_vals;
- gdouble indent = 0.0;
+ gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-text-layer-get-indent",
+ return_vals = gimp_run_procedure ("gimp-text-layer-set-line-spacing",
&nreturn_vals,
GIMP_PDB_LAYER, layer_ID,
+ GIMP_PDB_FLOAT, line_spacing,
GIMP_PDB_END);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- indent = return_vals[1].data.d_float;
+ success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
gimp_destroy_params (return_vals, nreturn_vals);
- return indent;
+ return success;
}
/**
- * gimp_text_layer_get_line_spacing:
+ * gimp_text_layer_get_letter_spacing:
* @layer_ID: The text layer.
*
- * Get the spacing between lines of text.
+ * Get the letter spacing used in a text layer.
*
- * This procedure returns the line-spacing between lines of text in a
- * text layer.
+ * This procedure returns the additional spacing between the single
+ * glyps in a text layer.
*
- * Returns: The line-spacing value.
+ * Returns: The letter-spacing value.
*
* Since: GIMP 2.6
*/
gdouble
-gimp_text_layer_get_line_spacing (gint32 layer_ID)
+gimp_text_layer_get_letter_spacing (gint32 layer_ID)
{
GimpParam *return_vals;
gint nreturn_vals;
- gdouble line_spacing = 0.0;
+ gdouble letter_spacing = 0.0;
- return_vals = gimp_run_procedure ("gimp-text-layer-get-line-spacing",
+ return_vals = gimp_run_procedure ("gimp-text-layer-get-letter-spacing",
&nreturn_vals,
GIMP_PDB_LAYER, layer_ID,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- line_spacing = return_vals[1].data.d_float;
+ letter_spacing = return_vals[1].data.d_float;
gimp_destroy_params (return_vals, nreturn_vals);
- return line_spacing;
+ return letter_spacing;
}
/**
- * gimp_text_layer_get_letter_spacing:
+ * gimp_text_layer_set_letter_spacing:
* @layer_ID: The text layer.
+ * @letter_spacing: The additional letter spacing to use.
*
- * Get the letter spacing used in a text layer.
+ * Adjust the letter spacing in a text layer.
*
- * This procedure returns the additional spacing between the single
- * glyps in a text layer.
+ * This procedure sets the additional spacing between the single glyphs
+ * in a text layer.
*
- * Returns: The letter-spacing value.
+ * Returns: TRUE on success.
*
* Since: GIMP 2.6
*/
-gdouble
-gimp_text_layer_get_letter_spacing (gint32 layer_ID)
+gboolean
+gimp_text_layer_set_letter_spacing (gint32 layer_ID,
+ gdouble letter_spacing)
{
GimpParam *return_vals;
gint nreturn_vals;
- gdouble letter_spacing = 0.0;
+ gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-text-layer-get-letter-spacing",
+ return_vals = gimp_run_procedure ("gimp-text-layer-set-letter-spacing",
&nreturn_vals,
GIMP_PDB_LAYER, layer_ID,
+ GIMP_PDB_FLOAT, letter_spacing,
GIMP_PDB_END);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- letter_spacing = return_vals[1].data.d_float;
+ success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
gimp_destroy_params (return_vals, nreturn_vals);
- return letter_spacing;
+ return success;
}
Modified: trunk/libgimp/gimptextlayer_pdb.h
==============================================================================
--- trunk/libgimp/gimptextlayer_pdb.h (original)
+++ trunk/libgimp/gimptextlayer_pdb.h Fri Apr 4 16:42:50 2008
@@ -34,50 +34,50 @@
const gchar *fontname,
gdouble size,
GimpUnit unit);
+gchar* gimp_text_layer_get_text (gint32 layer_ID);
gboolean gimp_text_layer_set_text (gint32 layer_ID,
const gchar *text);
+gchar* gimp_text_layer_get_font (gint32 layer_ID);
gboolean gimp_text_layer_set_font (gint32 layer_ID,
const gchar *font);
-gboolean gimp_text_layer_set_fontsize (gint32 layer_ID,
+gdouble gimp_text_layer_get_font_size (gint32 layer_ID,
+ GimpUnit *unit);
+gboolean gimp_text_layer_set_font_size (gint32 layer_ID,
gdouble font_size,
GimpUnit unit);
+gboolean gimp_text_layer_get_hinting (gint32 layer_ID,
+ gboolean *autohint);
gboolean gimp_text_layer_set_hinting (gint32 layer_ID,
gboolean hinting,
gboolean autohint);
+gboolean gimp_text_layer_get_antialias (gint32 layer_ID);
gboolean gimp_text_layer_set_antialias (gint32 layer_ID,
gboolean antialias);
+gboolean gimp_text_layer_get_kerning (gint32 layer_ID);
gboolean gimp_text_layer_set_kerning (gint32 layer_ID,
gboolean kerning);
+gchar* gimp_text_layer_get_language (gint32 layer_ID);
gboolean gimp_text_layer_set_language (gint32 layer_ID,
const gchar *language);
+GimpTextDirection gimp_text_layer_get_base_direction (gint32 layer_ID);
gboolean gimp_text_layer_set_base_direction (gint32 layer_ID,
GimpTextDirection direction);
+GimpTextJustification gimp_text_layer_get_justification (gint32 layer_ID);
gboolean gimp_text_layer_set_justification (gint32 layer_ID,
GimpTextJustification justify);
+gboolean gimp_text_layer_get_color (gint32 layer_ID,
+ GimpRGB *color);
gboolean gimp_text_layer_set_color (gint32 layer_ID,
const GimpRGB *color);
+gdouble gimp_text_layer_get_indent (gint32 layer_ID);
gboolean gimp_text_layer_set_indent (gint32 layer_ID,
gdouble indent);
+gdouble gimp_text_layer_get_line_spacing (gint32 layer_ID);
gboolean gimp_text_layer_set_line_spacing (gint32 layer_ID,
gdouble line_spacing);
+gdouble gimp_text_layer_get_letter_spacing (gint32 layer_ID);
gboolean gimp_text_layer_set_letter_spacing (gint32 layer_ID,
gdouble letter_spacing);
-gchar* gimp_text_layer_get_text (gint32 layer_ID);
-gchar* gimp_text_layer_get_font (gint32 layer_ID);
-gdouble gimp_text_layer_get_fontsize (gint32 layer_ID,
- GimpUnit *unit);
-gboolean gimp_text_layer_get_hinting (gint32 layer_ID,
- gboolean *autohint);
-gboolean gimp_text_layer_get_antialias (gint32 layer_ID);
-gboolean gimp_text_layer_get_kerning (gint32 layer_ID);
-gchar* gimp_text_layer_get_language (gint32 layer_ID);
-GimpTextDirection gimp_text_layer_get_base_direction (gint32 layer_ID);
-GimpTextJustification gimp_text_layer_get_justification (gint32 layer_ID);
-gboolean gimp_text_layer_get_color (gint32 layer_ID,
- GimpRGB *color);
-gdouble gimp_text_layer_get_indent (gint32 layer_ID);
-gdouble gimp_text_layer_get_line_spacing (gint32 layer_ID);
-gdouble gimp_text_layer_get_letter_spacing (gint32 layer_ID);
G_END_DECLS
Modified: trunk/tools/pdbgen/pdb/text_layer.pdb
==============================================================================
--- trunk/tools/pdbgen/pdb/text_layer.pdb (original)
+++ trunk/tools/pdbgen/pdb/text_layer.pdb Fri Apr 4 16:42:50 2008
@@ -23,7 +23,11 @@
$blurb = 'Creates a new text layer.';
$help = <<'HELP';
-This procedure creates a new text layer. The arguments are kept as simple as necessary for the normal case. All text attributes, however, can be modified with the appropriate gimp_text_layer_set_*() procedures. The new layer still needs to be added to the image, as this is not automatic. Add the new layer using gimp_image_add_layer().
+This procedure creates a new text layer. The arguments are kept as
+simple as necessary for the normal case. All text attributes, however,
+can be modified with the appropriate gimp_text_layer_set_*()
+procedures. The new layer still needs to be added to the image, as
+this is not automatic. Add the new layer using gimp_image_add_layer().
HELP
&marcus_pdb_misc('2008', '2.6');
@@ -77,31 +81,33 @@
);
}
-sub text_layer_set_text {
- $blurb = 'Set the text of a text layer.';
+sub text_layer_get_text {
+ $blurb = 'Get the text from a text layer as string.';
$help = <<'HELP';
-This procedure changes the text of a text layer.
+This procedure returns the text from a text layer as a string.
HELP
&marcus_pdb_misc('2008', '2.6');
@inargs = (
{ name => 'layer', type => 'layer',
- desc => 'The text layer' },
- { name => 'text', type => 'string',
- desc => 'The new text to set' }
+ desc => 'The text layer' }
);
+ @outargs = (
+ { name => 'text', type => 'string',
+ desc => 'The text from the specified text layer.' }
+ );
+
%invoke = (
code => <<'CODE'
{
if (gimp_pdb_layer_is_text_layer (layer, error))
{
- gimp_text_layer_set (GIMP_TEXT_LAYER (layer),
- _("Set text layer attribute"),
- "text", text,
- NULL);
+ g_object_get (gimp_text_layer_get_text (GIMP_TEXT_LAYER (layer)),
+ "text", &text,
+ NULL);
}
else
{
@@ -112,11 +118,11 @@
);
}
-sub text_layer_set_font {
- $blurb = 'Set the font of a text layer.';
+sub text_layer_set_text {
+ $blurb = 'Set the text of a text layer.';
$help = <<'HELP';
-This procedure modifies the font used in the specified text layer.
+This procedure changes the text of a text layer.
HELP
&marcus_pdb_misc('2008', '2.6');
@@ -124,8 +130,8 @@
@inargs = (
{ name => 'layer', type => 'layer',
desc => 'The text layer' },
- { name => 'font', type => 'string',
- desc => 'The new font to use' }
+ { name => 'text', type => 'string',
+ desc => 'The new text to set' }
);
%invoke = (
@@ -135,7 +141,7 @@
{
gimp_text_layer_set (GIMP_TEXT_LAYER (layer),
_("Set text layer attribute"),
- "font", font,
+ "text", text,
NULL);
}
else
@@ -147,34 +153,33 @@
);
}
-sub text_layer_set_fontsize {
- $blurb = 'Set the font size.';
+sub text_layer_get_font {
+ $blurb = 'Get the font from a text layer as string.';
$help = <<'HELP';
-This procedure changes the font size of a text layer. The size of your font will be a double 'font-size' of 'unit' units.
+This procedure returns the name of the font from a text layer.
HELP
&marcus_pdb_misc('2008', '2.6');
@inargs = (
{ name => 'layer', type => 'layer',
- desc => 'The text layer' },
- { name => 'font_size', type => '0.0 <= float <= 8192.0',
- desc => 'The font size' },
- { name => 'unit', type => 'unit',
- desc => 'The unit to use for the font size' }
+ desc => 'The text layer' }
);
+ @outargs = (
+ { name => 'font', type => 'string',
+ desc => 'The font which is used in the specified text layer.' }
+ );
+
%invoke = (
code => <<'CODE'
{
if (gimp_pdb_layer_is_text_layer (layer, error))
{
- gimp_text_layer_set (GIMP_TEXT_LAYER (layer),
- _("Set text layer attribute"),
- "font-size-unit", unit,
- "font-size", font_size,
- NULL);
+ g_object_get (gimp_text_layer_get_text (GIMP_TEXT_LAYER (layer)),
+ "font", &font,
+ NULL);
}
else
{
@@ -185,11 +190,11 @@
);
}
-sub text_layer_set_hinting {
- $blurb = 'Enable/disable the use of hinting in a text layer.';
+sub text_layer_set_font {
+ $blurb = 'Set the font of a text layer.';
$help = <<'HELP';
-This procedure enables or disables hinting on the text of a text layer. If you enable 'auto-hint', FreeType\'s automatic hinter will be used and hinting information from the font will be ignored.
+This procedure modifies the font used in the specified text layer.
HELP
&marcus_pdb_misc('2008', '2.6');
@@ -197,10 +202,8 @@
@inargs = (
{ name => 'layer', type => 'layer',
desc => 'The text layer' },
- { name => 'hinting', type => 'boolean',
- desc => 'Enable/disable the use of hinting on the text' },
- { name => 'autohint', type => 'boolean',
- desc => 'Force the use of the autohinter provided through FreeType' }
+ { name => 'font', type => 'string',
+ desc => 'The new font to use' }
);
%invoke = (
@@ -210,8 +213,7 @@
{
gimp_text_layer_set (GIMP_TEXT_LAYER (layer),
_("Set text layer attribute"),
- "hinting", hinting,
- "autohint", autohint,
+ "font", font,
NULL);
}
else
@@ -223,31 +225,38 @@
);
}
-sub text_layer_set_antialias {
- $blurb = 'Enable/disable anti-aliasing in a text layer.';
+sub text_layer_get_font_size {
+ $blurb = 'Get the font size from a text layer.';
$help = <<'HELP';
-This procedure enables or disables anti-aliasing of the text in a text layer.
+This procedure returns the size of the font which is used in a text
+layer. You will receive the size as a float 'font-size' in 'unit'
+units.
HELP
&marcus_pdb_misc('2008', '2.6');
@inargs = (
{ name => 'layer', type => 'layer',
- desc => 'The text layer' },
- { name => 'antialias', type => 'boolean',
- desc => 'Enable/disable antialiasing of the text' }
+ desc => 'The text layer' }
);
+ @outargs = (
+ { name => 'font_size', type => 'float',
+ desc => 'The font size' },
+ { name => 'unit', type => 'unit',
+ desc => 'The unit used for the font size' }
+ );
+
%invoke = (
code => <<'CODE'
{
if (gimp_pdb_layer_is_text_layer (layer, error))
{
- gimp_text_layer_set (GIMP_TEXT_LAYER (layer),
- _("Set text layer attribute"),
- "antialias", antialias,
- NULL);
+ g_object_get (gimp_text_layer_get_text (GIMP_TEXT_LAYER (layer)),
+ "font-size", &font_size,
+ "font-size-unit", &unit,
+ NULL);
}
else
{
@@ -258,11 +267,12 @@
);
}
-sub text_layer_set_kerning {
- $blurb = 'Enable/disable kerning in a text layer.';
+sub text_layer_set_font_size {
+ $blurb = 'Set the font size.';
$help = <<'HELP';
-This procedure enables or disables kerning in a text layer.
+This procedure changes the font size of a text layer. The size of your
+font will be a double 'font-size' of 'unit' units.
HELP
&marcus_pdb_misc('2008', '2.6');
@@ -270,8 +280,10 @@
@inargs = (
{ name => 'layer', type => 'layer',
desc => 'The text layer' },
- { name => 'kerning', type => 'boolean',
- desc => 'Enable/disable kerning in the text' }
+ { name => 'font_size', type => '0.0 <= float <= 8192.0',
+ desc => 'The font size' },
+ { name => 'unit', type => 'unit',
+ desc => 'The unit to use for the font size' }
);
%invoke = (
@@ -281,7 +293,8 @@
{
gimp_text_layer_set (GIMP_TEXT_LAYER (layer),
_("Set text layer attribute"),
- "kerning", kerning,
+ "font-size-unit", unit,
+ "font-size", font_size,
NULL);
}
else
@@ -293,31 +306,37 @@
);
}
-sub text_layer_set_language {
- $blurb = 'Set the language of the text layer.';
+sub text_layer_get_hinting {
+ $blurb = 'Get information about hinting in the specified text layer.';
$help = <<'HELP';
-This procedure sets the language of the text in text layer. For some scripts the language has an influence of how the text is rendered.
+This procedure provides information about the hinting that is being
+used in a text layer.
HELP
&marcus_pdb_misc('2008', '2.6');
@inargs = (
{ name => 'layer', type => 'layer',
- desc => 'The text layer' },
- { name => 'language', type => 'string',
- desc => 'The new language to use for the text layer' }
+ desc => 'The text layer' }
);
+ @outargs = (
+ { name => 'hinting', type => 'boolean',
+ desc => 'A flag which is true if hinting is used on the font.' },
+ { name => 'autohint', type => 'boolean',
+ desc => 'A flag which is true if the text layer is forced to use the autohinter from FreeType.' }
+ );
+
%invoke = (
code => <<'CODE'
{
if (gimp_pdb_layer_is_text_layer (layer, error))
{
- gimp_text_layer_set (GIMP_TEXT_LAYER (layer),
- _("Set text layer attribute"),
- "language", language,
- NULL);
+ g_object_get (gimp_text_layer_get_text (GIMP_TEXT_LAYER (layer)),
+ "hinting", &hinting,
+ "autohint", &autohint,
+ NULL);
}
else
{
@@ -328,11 +347,13 @@
);
}
-sub text_layer_set_base_direction {
- $blurb = 'Set the base direction in the text layer.';
+sub text_layer_set_hinting {
+ $blurb = 'Enable/disable the use of hinting in a text layer.';
$help = <<'HELP';
-This procedure sets the base direction used in applying the Unicode bidirectional algorithm when rendering the text.
+This procedure enables or disables hinting on the text of a text
+layer. If you enable 'auto-hint', FreeType\'s automatic hinter will be
+used and hinting information from the font will be ignored.
HELP
&marcus_pdb_misc('2008', '2.6');
@@ -340,8 +361,10 @@
@inargs = (
{ name => 'layer', type => 'layer',
desc => 'The text layer' },
- { name => 'direction', type => 'enum GimpTextDirection',
- desc => 'The base direction of the text.' }
+ { name => 'hinting', type => 'boolean',
+ desc => 'Enable/disable the use of hinting on the text' },
+ { name => 'autohint', type => 'boolean',
+ desc => 'Force the use of the autohinter provided through FreeType' }
);
%invoke = (
@@ -351,7 +374,8 @@
{
gimp_text_layer_set (GIMP_TEXT_LAYER (layer),
_("Set text layer attribute"),
- "base-direction", direction,
+ "hinting", hinting,
+ "autohint", autohint,
NULL);
}
else
@@ -363,20 +387,23 @@
);
}
-sub text_layer_set_justification {
- $blurb = 'Set the justification of the text in a text layer.';
+sub text_layer_get_antialias {
+ $blurb = 'Check if antialiasing is used in the text layer.';
$help = <<'HELP';
-This procedure sets the alignment of the lines in the text layer relative to each other.
+This procedure checks if antialiasing is enabled in the specified text layer.
HELP
&marcus_pdb_misc('2008', '2.6');
@inargs = (
{ name => 'layer', type => 'layer',
- desc => 'The text layer' },
- { name => 'justify', type => 'enum GimpTextJustification',
- desc => 'The justification for your text.' }
+ desc => 'The text layer' }
+ );
+
+ @outargs = (
+ { name => 'antialias', type => 'boolean',
+ desc => 'A flag which is true if antialiasing is used for rendering the font in the text layer.' }
);
%invoke = (
@@ -384,10 +411,9 @@
{
if (gimp_pdb_layer_is_text_layer (layer, error))
{
- gimp_text_layer_set (GIMP_TEXT_LAYER (layer),
- _("Set text layer attribute"),
- "justify", justify,
- NULL);
+ g_object_get (gimp_text_layer_get_text (GIMP_TEXT_LAYER (layer)),
+ "antialias", &antialias,
+ NULL);
}
else
{
@@ -398,11 +424,11 @@
);
}
-sub text_layer_set_color {
- $blurb = 'Set the color of the text in the text layer.';
+sub text_layer_set_antialias {
+ $blurb = 'Enable/disable anti-aliasing in a text layer.';
$help = <<'HELP';
-This procedure sets the text color in the text layer 'layer'.
+This procedure enables or disables anti-aliasing of the text in a text layer.
HELP
&marcus_pdb_misc('2008', '2.6');
@@ -410,8 +436,8 @@
@inargs = (
{ name => 'layer', type => 'layer',
desc => 'The text layer' },
- { name => 'color', type => 'color',
- desc => 'The color to use for the text' }
+ { name => 'antialias', type => 'boolean',
+ desc => 'Enable/disable antialiasing of the text' }
);
%invoke = (
@@ -421,7 +447,7 @@
{
gimp_text_layer_set (GIMP_TEXT_LAYER (layer),
_("Set text layer attribute"),
- "color", &color,
+ "antialias", antialias,
NULL);
}
else
@@ -433,31 +459,33 @@
);
}
-sub text_layer_set_indent {
- $blurb = 'Set the indentation of the first line in a text layer.';
+sub text_layer_get_kerning {
+ $blurb = 'Check if kerning is used in the text layer.';
$help = <<'HELP';
-This procedure sets the indentation of the first line in the text layer.
+This procedure checks if kerning is enabled in the specified text layer.
HELP
&marcus_pdb_misc('2008', '2.6');
@inargs = (
{ name => 'layer', type => 'layer',
- desc => 'The text layer' },
- { name => 'indent', type => '-8192.0 <= float <= 8192.0',
- desc => 'The indentation for the first line.' }
- );
+ desc => 'The text layer' }
+ );
- %invoke = (
- code => <<'CODE'
+ @outargs = (
+ { name => 'kerning', type => 'boolean',
+ desc => 'A flag which is true if kerning is used in the text layer.' }
+ );
+
+ %invoke = (
+ code => <<'CODE'
{
if (gimp_pdb_layer_is_text_layer (layer, error))
{
- gimp_text_layer_set (GIMP_TEXT_LAYER (layer),
- _("Set text layer attribute"),
- "indent", indent,
- NULL);
+ g_object_get (gimp_text_layer_get_text (GIMP_TEXT_LAYER (layer)),
+ "kerning", &kerning,
+ NULL);
}
else
{
@@ -468,11 +496,11 @@
);
}
-sub text_layer_set_line_spacing {
- $blurb = 'Adjust the line spacing in a text layer.';
+sub text_layer_set_kerning {
+ $blurb = 'Enable/disable kerning in a text layer.';
$help = <<'HELP';
-This procedure sets the additional spacing used between lines a text layer.
+This procedure enables or disables kerning in a text layer.
HELP
&marcus_pdb_misc('2008', '2.6');
@@ -480,8 +508,8 @@
@inargs = (
{ name => 'layer', type => 'layer',
desc => 'The text layer' },
- { name => 'line_spacing', type => '-8192.0 <= float <= 8192.0',
- desc => 'The additional line spacing to use.' }
+ { name => 'kerning', type => 'boolean',
+ desc => 'Enable/disable kerning in the text' }
);
%invoke = (
@@ -491,7 +519,7 @@
{
gimp_text_layer_set (GIMP_TEXT_LAYER (layer),
_("Set text layer attribute"),
- "line-spacing", line_spacing,
+ "kerning", kerning,
NULL);
}
else
@@ -503,31 +531,34 @@
);
}
-sub text_layer_set_letter_spacing {
- $blurb = 'Adjust the letter spacing in a text layer.';
+sub text_layer_get_language {
+ $blurb = 'Get the language used in the text layer.';
$help = <<'HELP';
-This procedure sets the additional spacing between the single glyphs in a text layer.
+This procedure returns the language string which is set for the text
+in the text layer.
HELP
&marcus_pdb_misc('2008', '2.6');
@inargs = (
{ name => 'layer', type => 'layer',
- desc => 'The text layer' },
- { name => 'letter_spacing', type => '-8192.0 <= float <= 8192.0',
- desc => 'The additional letter spacing to use.' }
+ desc => 'The text layer.' }
);
-
- %invoke = (
+
+ @outargs = (
+ { name => 'language', type => 'string',
+ desc => 'The language used in the text layer.' }
+ );
+
+ %invoke = (
code => <<'CODE'
{
if (gimp_pdb_layer_is_text_layer (layer, error))
{
- gimp_text_layer_set (GIMP_TEXT_LAYER (layer),
- _("Set text layer attribute"),
- "letter-spacing", letter_spacing,
- NULL);
+ g_object_get (gimp_text_layer_get_text (GIMP_TEXT_LAYER (layer)),
+ "language", &language,
+ NULL);
}
else
{
@@ -538,33 +569,32 @@
);
}
-sub text_layer_get_text {
- $blurb = 'Get the text from a text layer as string.';
+sub text_layer_set_language {
+ $blurb = 'Set the language of the text layer.';
$help = <<'HELP';
-This procedure returns the text from a text layer as a string.
+This procedure sets the language of the text in text layer. For some
+scripts the language has an influence of how the text is rendered.
HELP
&marcus_pdb_misc('2008', '2.6');
@inargs = (
{ name => 'layer', type => 'layer',
- desc => 'The text layer' }
+ desc => 'The text layer' },
+ { name => 'language', type => 'string',
+ desc => 'The new language to use for the text layer' }
);
- @outargs = (
- { name => 'text', type => 'string',
- desc => 'The text from the specified text layer.' }
- );
-
%invoke = (
code => <<'CODE'
{
if (gimp_pdb_layer_is_text_layer (layer, error))
{
- g_object_get (gimp_text_layer_get_text (GIMP_TEXT_LAYER (layer)),
- "text", &text,
- NULL);
+ gimp_text_layer_set (GIMP_TEXT_LAYER (layer),
+ _("Set text layer attribute"),
+ "language", language,
+ NULL);
}
else
{
@@ -575,32 +605,33 @@
);
}
-sub text_layer_get_font {
- $blurb = 'Get the font from a text layer as string.';
+sub text_layer_get_base_direction {
+ $blurb = 'Get the base direction used for rendering the text layer.';
$help = <<'HELP';
-This procedure returns the name of the font from a text layer.
+This procedure returns the base direction used for rendering the text
+in the text layer
HELP
&marcus_pdb_misc('2008', '2.6');
@inargs = (
{ name => 'layer', type => 'layer',
- desc => 'The text layer' }
+ desc => 'The text layer.' }
);
@outargs = (
- { name => 'font', type => 'string',
- desc => 'The font which is used in the specified text layer.' }
+ { name => 'direction', type => 'enum GimpTextDirection',
+ desc => 'The based direction used for the text layer.' }
);
-
+
%invoke = (
code => <<'CODE'
{
if (gimp_pdb_layer_is_text_layer (layer, error))
{
g_object_get (gimp_text_layer_get_text (GIMP_TEXT_LAYER (layer)),
- "font", &font,
+ "base-direction", &direction,
NULL);
}
else
@@ -612,36 +643,32 @@
);
}
-sub text_layer_get_fontsize {
- $blurb = 'Get the font size from a text layer.';
+sub text_layer_set_base_direction {
+ $blurb = 'Set the base direction in the text layer.';
$help = <<'HELP';
-This procedure returns the size of the font which is used in a text layer. You will receive the size as a float 'font-size' in 'unit' units.
+This procedure sets the base direction used in applying the Unicode
+bidirectional algorithm when rendering the text.
HELP
&marcus_pdb_misc('2008', '2.6');
@inargs = (
{ name => 'layer', type => 'layer',
- desc => 'The text layer' }
+ desc => 'The text layer' },
+ { name => 'direction', type => 'enum GimpTextDirection',
+ desc => 'The base direction of the text.' }
);
- @outargs = (
- { name => 'font_size', type => 'float',
- desc => 'The font size' },
- { name => 'unit', type => 'unit',
- desc => 'The unit used for the font size' }
- );
-
%invoke = (
code => <<'CODE'
{
if (gimp_pdb_layer_is_text_layer (layer, error))
{
- g_object_get (gimp_text_layer_get_text (GIMP_TEXT_LAYER (layer)),
- "font-size", &font_size,
- "font-size-unit", &unit,
- NULL);
+ gimp_text_layer_set (GIMP_TEXT_LAYER (layer),
+ _("Set text layer attribute"),
+ "base-direction", direction,
+ NULL);
}
else
{
@@ -652,35 +679,33 @@
);
}
-sub text_layer_get_hinting {
- $blurb = 'Get information about hinting in the specified text layer.';
+sub text_layer_get_justification {
+ $blurb = 'Get the text justification information of the text layer.';
$help = <<'HELP';
-This procedure provides information about the hinting that is being used in a text layer.
+This procedure returns the alignment of the lines in the text layer
+relative to each other.
HELP
&marcus_pdb_misc('2008', '2.6');
@inargs = (
{ name => 'layer', type => 'layer',
- desc => 'The text layer' }
+ desc => 'The text layer.' }
);
@outargs = (
- { name => 'hinting', type => 'boolean',
- desc => 'A flag which is true if hinting is used on the font.' },
- { name => 'autohint', type => 'boolean',
- desc => 'A flag which is true if the text layer is forced to use the autohinter from FreeType.' }
+ { name => 'justify', type => 'enum GimpTextJustification',
+ desc => 'The justification used in the text layer.' }
);
-
+
%invoke = (
code => <<'CODE'
{
if (gimp_pdb_layer_is_text_layer (layer, error))
{
g_object_get (gimp_text_layer_get_text (GIMP_TEXT_LAYER (layer)),
- "hinting", &hinting,
- "autohint", &autohint,
+ "justify", &justify,
NULL);
}
else
@@ -692,23 +717,21 @@
);
}
-sub text_layer_get_antialias {
- $blurb = 'Check if antialiasing is used in the text layer.';
+sub text_layer_set_justification {
+ $blurb = 'Set the justification of the text in a text layer.';
$help = <<'HELP';
-This procedure checks if antialiasing is enabled in the specified text layer.
+This procedure sets the alignment of the lines in the text layer
+relative to each other.
HELP
&marcus_pdb_misc('2008', '2.6');
@inargs = (
{ name => 'layer', type => 'layer',
- desc => 'The text layer' }
- );
-
- @outargs = (
- { name => 'antialias', type => 'boolean',
- desc => 'A flag which is true if antialiasing is used for rendering the font in the text layer.' }
+ desc => 'The text layer' },
+ { name => 'justify', type => 'enum GimpTextJustification',
+ desc => 'The justification for your text.' }
);
%invoke = (
@@ -716,9 +739,10 @@
{
if (gimp_pdb_layer_is_text_layer (layer, error))
{
- g_object_get (gimp_text_layer_get_text (GIMP_TEXT_LAYER (layer)),
- "antialias", &antialias,
- NULL);
+ gimp_text_layer_set (GIMP_TEXT_LAYER (layer),
+ _("Set text layer attribute"),
+ "justify", justify,
+ NULL);
}
else
{
@@ -729,23 +753,23 @@
);
}
-sub text_layer_get_kerning {
- $blurb = 'Check if kerning is used in the text layer.';
+sub text_layer_get_color {
+ $blurb = 'Get the color of the text in a text layer.';
$help = <<'HELP';
-This procedure checks if kerning is enabled in the specified text layer.
+This procedure returns the color of the text in a text layer.
HELP
&marcus_pdb_misc('2008', '2.6');
@inargs = (
{ name => 'layer', type => 'layer',
- desc => 'The text layer' }
+ desc => 'The text layer.' }
);
@outargs = (
- { name => 'kerning', type => 'boolean',
- desc => 'A flag which is true if kerning is used in the text layer.' }
+ { name => 'color', type => 'color', void_ret => 1,
+ desc => 'The color of the text.' }
);
%invoke = (
@@ -753,9 +777,7 @@
{
if (gimp_pdb_layer_is_text_layer (layer, error))
{
- g_object_get (gimp_text_layer_get_text (GIMP_TEXT_LAYER (layer)),
- "kerning", &kerning,
- NULL);
+ color = gimp_text_layer_get_text (GIMP_TEXT_LAYER (layer))->color;
}
else
{
@@ -766,23 +788,20 @@
);
}
-sub text_layer_get_language {
- $blurb = 'Get the language used in the text layer.';
+sub text_layer_set_color {
+ $blurb = 'Set the color of the text in the text layer.';
$help = <<'HELP';
-This procedure returns the language string which is set for the text in the text layer.
+This procedure sets the text color in the text layer 'layer'.
HELP
&marcus_pdb_misc('2008', '2.6');
@inargs = (
{ name => 'layer', type => 'layer',
- desc => 'The text layer.' }
- );
-
- @outargs = (
- { name => 'language', type => 'string',
- desc => 'The language used in the text layer.' }
+ desc => 'The text layer' },
+ { name => 'color', type => 'color',
+ desc => 'The color to use for the text' }
);
%invoke = (
@@ -790,9 +809,10 @@
{
if (gimp_pdb_layer_is_text_layer (layer, error))
{
- g_object_get (gimp_text_layer_get_text (GIMP_TEXT_LAYER (layer)),
- "language", &language,
- NULL);
+ gimp_text_layer_set (GIMP_TEXT_LAYER (layer),
+ _("Set text layer attribute"),
+ "color", &color,
+ NULL);
}
else
{
@@ -803,11 +823,11 @@
);
}
-sub text_layer_get_base_direction {
- $blurb = 'Get the base direction used for rendering the text layer.';
+sub text_layer_get_indent {
+ $blurb = 'Get the line indentation of text layer.';
$help = <<'HELP';
-This procedure returns the base direction used for rendering the text in the text layer
+This procedure returns the indentation of the first line in a text layer.
HELP
&marcus_pdb_misc('2008', '2.6');
@@ -818,8 +838,8 @@
);
@outargs = (
- { name => 'direction', type => 'enum GimpTextDirection',
- desc => 'The based direction used for the text layer.' }
+ { name => 'indent', type => 'float',
+ desc => 'The indentation value of the first line.' }
);
%invoke = (
@@ -828,7 +848,7 @@
if (gimp_pdb_layer_is_text_layer (layer, error))
{
g_object_get (gimp_text_layer_get_text (GIMP_TEXT_LAYER (layer)),
- "base-direction", &direction,
+ "indent", &indent,
NULL);
}
else
@@ -840,34 +860,31 @@
);
}
-
-sub text_layer_get_justification {
- $blurb = 'Get the text justification information of the text layer.';
+sub text_layer_set_indent {
+ $blurb = 'Set the indentation of the first line in a text layer.';
$help = <<'HELP';
-This procedure returns the alignment of the lines in the text layer relative to each other.
+This procedure sets the indentation of the first line in the text layer.
HELP
&marcus_pdb_misc('2008', '2.6');
@inargs = (
{ name => 'layer', type => 'layer',
- desc => 'The text layer.' }
- );
-
- @outargs = (
- { name => 'justify', type => 'enum GimpTextJustification',
- desc => 'The justification used in the text layer.' }
- );
+ desc => 'The text layer' },
+ { name => 'indent', type => '-8192.0 <= float <= 8192.0',
+ desc => 'The indentation for the first line.' }
+ );
- %invoke = (
- code => <<'CODE'
+ %invoke = (
+ code => <<'CODE'
{
if (gimp_pdb_layer_is_text_layer (layer, error))
{
- g_object_get (gimp_text_layer_get_text (GIMP_TEXT_LAYER (layer)),
- "justify", &justify,
- NULL);
+ gimp_text_layer_set (GIMP_TEXT_LAYER (layer),
+ _("Set text layer attribute"),
+ "indent", indent,
+ NULL);
}
else
{
@@ -878,11 +895,11 @@
);
}
-sub text_layer_get_color {
- $blurb = 'Get the color of the text in a text layer.';
+sub text_layer_get_line_spacing {
+ $blurb = 'Get the spacing between lines of text.';
$help = <<'HELP';
-This procedure returns the color of the text in a text layer.
+This procedure returns the line-spacing between lines of text in a text layer.
HELP
&marcus_pdb_misc('2008', '2.6');
@@ -893,8 +910,8 @@
);
@outargs = (
- { name => 'color', type => 'color', void_ret => 1,
- desc => 'The color of the text.' }
+ { name => 'line_spacing', type => 'float',
+ desc => 'The line-spacing value.' }
);
%invoke = (
@@ -903,7 +920,7 @@
if (gimp_pdb_layer_is_text_layer (layer, error))
{
g_object_get (gimp_text_layer_get_text (GIMP_TEXT_LAYER (layer)),
- "color", &color,
+ "line-spacing", &line_spacing,
NULL);
}
else
@@ -915,23 +932,20 @@
);
}
-sub text_layer_get_indent {
- $blurb = 'Get the line indentation of text layer.';
+sub text_layer_set_line_spacing {
+ $blurb = 'Adjust the line spacing in a text layer.';
$help = <<'HELP';
-This procedure returns the indentation of the first line in a text layer.
+This procedure sets the additional spacing used between lines a text layer.
HELP
&marcus_pdb_misc('2008', '2.6');
@inargs = (
{ name => 'layer', type => 'layer',
- desc => 'The text layer.' }
- );
-
- @outargs = (
- { name => 'indent', type => 'float',
- desc => 'The indentation value of the first line.' }
+ desc => 'The text layer' },
+ { name => 'line_spacing', type => '-8192.0 <= float <= 8192.0',
+ desc => 'The additional line spacing to use.' }
);
%invoke = (
@@ -939,9 +953,10 @@
{
if (gimp_pdb_layer_is_text_layer (layer, error))
{
- g_object_get (gimp_text_layer_get_text (GIMP_TEXT_LAYER (layer)),
- "indent", &indent,
- NULL);
+ gimp_text_layer_set (GIMP_TEXT_LAYER (layer),
+ _("Set text layer attribute"),
+ "line-spacing", line_spacing,
+ NULL);
}
else
{
@@ -952,11 +967,12 @@
);
}
-sub text_layer_get_line_spacing {
- $blurb = 'Get the spacing between lines of text.';
+sub text_layer_get_letter_spacing {
+ $blurb = 'Get the letter spacing used in a text layer.';
$help = <<'HELP';
-This procedure returns the line-spacing between lines of text in a text layer.
+This procedure returns the additional spacing between the single glyps
+in a text layer.
HELP
&marcus_pdb_misc('2008', '2.6');
@@ -967,8 +983,8 @@
);
@outargs = (
- { name => 'line_spacing', type => 'float',
- desc => 'The line-spacing value.' }
+ { name => 'letter_spacing', type => 'float',
+ desc => 'The letter-spacing value.' }
);
%invoke = (
@@ -977,7 +993,7 @@
if (gimp_pdb_layer_is_text_layer (layer, error))
{
g_object_get (gimp_text_layer_get_text (GIMP_TEXT_LAYER (layer)),
- "line-spacing", &line_spacing,
+ "letter-spacing", &letter_spacing,
NULL);
}
else
@@ -989,33 +1005,32 @@
);
}
-sub text_layer_get_letter_spacing {
- $blurb = 'Get the letter spacing used in a text layer.';
+sub text_layer_set_letter_spacing {
+ $blurb = 'Adjust the letter spacing in a text layer.';
$help = <<'HELP';
-This procedure returns the additional spacing between the single glyps in a text layer.
+This procedure sets the additional spacing between the single glyphs
+in a text layer.
HELP
&marcus_pdb_misc('2008', '2.6');
@inargs = (
{ name => 'layer', type => 'layer',
- desc => 'The text layer.' }
- );
-
- @outargs = (
- { name => 'letter_spacing', type => 'float',
- desc => 'The letter-spacing value.' }
+ desc => 'The text layer' },
+ { name => 'letter_spacing', type => '-8192.0 <= float <= 8192.0',
+ desc => 'The additional letter spacing to use.' }
);
-
- %invoke = (
+
+ %invoke = (
code => <<'CODE'
{
if (gimp_pdb_layer_is_text_layer (layer, error))
{
- g_object_get (gimp_text_layer_get_text (GIMP_TEXT_LAYER (layer)),
- "letter-spacing", &letter_spacing,
- NULL);
+ gimp_text_layer_set (GIMP_TEXT_LAYER (layer),
+ _("Set text layer attribute"),
+ "letter-spacing", letter_spacing,
+ NULL);
}
else
{
@@ -1029,37 +1044,39 @@
@headers = qw("libgimpbase/gimpbase.h"
"core/gimpcontext.h"
- "text/gimptext.h" "text/gimptextlayer.h"
- "gimppdb-utils.h" "gimppdberror.h"
+ "text/gimptext.h"
+ "text/gimptextlayer.h"
+ "gimppdb-utils.h"
+ "gimppdberror.h"
"gimp-intl.h");
@procs = qw(text_layer_new
- text_layer_set_text
- text_layer_set_font
- text_layer_set_fontsize
- text_layer_set_hinting
- text_layer_set_antialias
- text_layer_set_kerning
- text_layer_set_language
- text_layer_set_base_direction
- text_layer_set_justification
- text_layer_set_color
- text_layer_set_indent
- text_layer_set_line_spacing
- text_layer_set_letter_spacing
text_layer_get_text
+ text_layer_set_text
text_layer_get_font
- text_layer_get_fontsize
+ text_layer_set_font
+ text_layer_get_font_size
+ text_layer_set_font_size
text_layer_get_hinting
+ text_layer_set_hinting
text_layer_get_antialias
+ text_layer_set_antialias
text_layer_get_kerning
+ text_layer_set_kerning
text_layer_get_language
+ text_layer_set_language
text_layer_get_base_direction
+ text_layer_set_base_direction
text_layer_get_justification
+ text_layer_set_justification
text_layer_get_color
+ text_layer_set_color
text_layer_get_indent
+ text_layer_set_indent
text_layer_get_line_spacing
- text_layer_get_letter_spacing);
+ text_layer_set_line_spacing
+ text_layer_get_letter_spacing
+ text_layer_set_letter_spacing);
%exports = (app => [ procs], lib => [ procs]);
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
