dnrops
/
gimp
mirror of https://github.com/GNOME/gimp.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Don't store human readable and translatable enum/flag strings in 

2004-10-25  Michael Natterer  <mitch@gimp.org>

	Don't store human readable and translatable enum/flag strings in
	GEnumValue's and GTypeValue's fields but attach them to their
	GType using separate structs and utility functions:

	* tools/gimp-mkenums: added params and perl voodoo to support
	generating a second array of values, which is used by the
	Makefiles below to create and register arrays of value
	descriptions.

	* libgimpbase/gimpbasetypes.[ch]: added API to attach/retreive
	arrays of translatable strings to/from enum and flags types. Added
	structs GimpEnumDesc and GimpFlagsDesc for that purpose.

	* libgimpbase/gimputils.[ch]: changed existing enum utility
	functions, added new ones and added a symmetric API for flags.

	* app/base/Makefile.am
	* app/core/Makefile.am
	* app/display/Makefile.am
	* app/paint/Makefile.am
	* app/text/Makefile.am
	* app/tools/Makefile.am
	* app/widgets/Makefile.am
	* libgimp/Makefile.am
	* libgimpbase/Makefile.am: changed *-enums.c generation rules
	accordingly.

	* app/base/base-enums.c
	* app/core/core-enums.c
	* app/display/display-enums.c
	* app/paint/paint-enums.c
	* app/text/text-enums.c
	* app/tools/tools-enums.c
	* app/widgets/widgets-enums.c
	* libgimpbase/gimpbaseenums.c: regenerated.

	* app/widgets/gimpenumstore.c
	* app/widgets/gimpenumwidgets.c
	* app/widgets/gimptemplateeditor.c
	* libgimpwidgets/gimppreviewarea.c: follow the enum utility
	function API changes.
This commit is contained in:
Michael Natterer 2004-10-25 17:55:25 +00:00 committed by Michael Natterer
parent 14b1e0c258
commit 6711646648
31 changed files with 1877 additions and 447 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

44
ChangeLog
View File

@ -1,3 +1,47 @@
2004-10-25 Michael Natterer <mitch@gimp.org>
Don't store human readable and translatable enum/flag strings in
GEnumValue's and GTypeValue's fields but attach them to their
GType using separate structs and utility functions:
* tools/gimp-mkenums: added params and perl voodoo to support
generating a second array of values, which is used by the
Makefiles below to create and register arrays of value
descriptions.
* libgimpbase/gimpbasetypes.[ch]: added API to attach/retreive
arrays of translatable strings to/from enum and flags types. Added
structs GimpEnumDesc and GimpFlagsDesc for that purpose.
* libgimpbase/gimputils.[ch]: changed existing enum utility
functions, added new ones and added a symmetric API for flags.
* app/base/Makefile.am
* app/core/Makefile.am
* app/display/Makefile.am
* app/paint/Makefile.am
* app/text/Makefile.am
* app/tools/Makefile.am
* app/widgets/Makefile.am
* libgimp/Makefile.am
* libgimpbase/Makefile.am: changed *-enums.c generation rules
accordingly.
* app/base/base-enums.c
* app/core/core-enums.c
* app/display/display-enums.c
* app/paint/paint-enums.c
* app/text/text-enums.c
* app/tools/tools-enums.c
* app/widgets/widgets-enums.c
* libgimpbase/gimpbaseenums.c: regenerated.
* app/widgets/gimpenumstore.c
* app/widgets/gimpenumwidgets.c
* app/widgets/gimptemplateeditor.c
* libgimpwidgets/gimppreviewarea.c: follow the enum utility
function API changes.
2004-10-25 Sven Neumann <sven@gimp.org>
* plug-ins/imagemap/imap_cmd_gimp_guides.c

9
app/base/Makefile.am
View File

@ -90,11 +90,14 @@ CLEANFILES = $(EXTRA_PROGRAMS) $(gen_sources)
$(srcdir)/base-enums.c: $(srcdir)/base-enums.h $(GIMP_MKENUMS)
$(GIMP_MKENUMS) \
--fhead "#include \"config.h\"\n#include <glib-object.h>\n#include \"base-enums.h\"\n#include \"gimp-intl.h\"" \
--fhead "#include \"config.h\"\n#include <glib-object.h>\n#include \"libgimpbase/gimpbase.h\"\n#include \"base-enums.h\"\n#include \"gimp-intl.h\"" \
--fprod "\n/* enumerations from \"@filename@\" */" \
--vhead "GType\n@enum_name@_get_type (void)\n{\n static const G@Type@Value values[] =\n {" \
--vprod " { @VALUENAME@, @valuedesc@, \"@valuenick@\" }," \
--vtail " { 0, NULL, NULL }\n };\n\n static GType type = 0;\n\n if (! type)\n type = g_@type@_register_static (\"@EnumName@\", values);\n\n return type;\n}\n" \
--vprod " { @VALUENAME@, \"@VALUENAME@\", \"@valuenick@\" }," \
--vtail " { 0, NULL, NULL }\n };\n" \
--dhead " static const Gimp@Type@Desc descs[] =\n {" \
--dprod " { @VALUENAME@, @valuedesc@, @valuehelp@ }," \
--dtail " { 0, NULL, NULL }\n };\n\n static GType type = 0;\n\n if (! type)\n {\n type = g_@type@_register_static (\"@EnumName@\", values);\n gimp_@type@_set_value_descriptions (type, descs);\n }\n\n return type;\n}\n" \
$(srcdir)/base-enums.h > xgen-bec \
&& cp xgen-bec $(@F) \
&& rm -f xgen-bec

116
app/base/base-enums.c
View File

@ -3,6 +3,7 @@
#include "config.h"
#include <glib-object.h>
#include "libgimpbase/gimpbase.h"
#include "base-enums.h"
#include "gimp-intl.h"
@ -12,15 +13,25 @@ gimp_curve_type_get_type (void)
{
static const GEnumValue values[] =
{
{ GIMP_CURVE_SMOOTH, N_("Smooth"), "smooth" },
{ GIMP_CURVE_FREE, N_("Freehand"), "free" },
{ GIMP_CURVE_SMOOTH, "GIMP_CURVE_SMOOTH", "smooth" },
{ GIMP_CURVE_FREE, "GIMP_CURVE_FREE", "free" },
{ 0, NULL, NULL }
};
static const GimpEnumDesc descs[] =
{
{ GIMP_CURVE_SMOOTH, N_("Smooth"), NULL },
{ GIMP_CURVE_FREE, N_("Freehand"), NULL },
{ 0, NULL, NULL }
};
static GType type = 0;
if (! type)
type = g_enum_register_static ("GimpCurveType", values);
{
type = g_enum_register_static ("GimpCurveType", values);
gimp_enum_set_value_descriptions (type, descs);
}
return type;
}
@ -30,19 +41,33 @@ gimp_histogram_channel_get_type (void)
{
static const GEnumValue values[] =
{
{ GIMP_HISTOGRAM_VALUE, N_("Value"), "value" },
{ GIMP_HISTOGRAM_RED, N_("Red"), "red" },
{ GIMP_HISTOGRAM_GREEN, N_("Green"), "green" },
{ GIMP_HISTOGRAM_BLUE, N_("Blue"), "blue" },
{ GIMP_HISTOGRAM_ALPHA, N_("Alpha"), "alpha" },
{ GIMP_HISTOGRAM_RGB, N_("RGB"), "rgb" },
{ GIMP_HISTOGRAM_VALUE, "GIMP_HISTOGRAM_VALUE", "value" },
{ GIMP_HISTOGRAM_RED, "GIMP_HISTOGRAM_RED", "red" },
{ GIMP_HISTOGRAM_GREEN, "GIMP_HISTOGRAM_GREEN", "green" },
{ GIMP_HISTOGRAM_BLUE, "GIMP_HISTOGRAM_BLUE", "blue" },
{ GIMP_HISTOGRAM_ALPHA, "GIMP_HISTOGRAM_ALPHA", "alpha" },
{ GIMP_HISTOGRAM_RGB, "GIMP_HISTOGRAM_RGB", "rgb" },
{ 0, NULL, NULL }
};
static const GimpEnumDesc descs[] =
{
{ GIMP_HISTOGRAM_VALUE, N_("Value"), NULL },
{ GIMP_HISTOGRAM_RED, N_("Red"), NULL },
{ GIMP_HISTOGRAM_GREEN, N_("Green"), NULL },
{ GIMP_HISTOGRAM_BLUE, N_("Blue"), NULL },
{ GIMP_HISTOGRAM_ALPHA, N_("Alpha"), NULL },
{ GIMP_HISTOGRAM_RGB, N_("RGB"), NULL },
{ 0, NULL, NULL }
};
static GType type = 0;
if (! type)
type = g_enum_register_static ("GimpHistogramChannel", values);
{
type = g_enum_register_static ("GimpHistogramChannel", values);
gimp_enum_set_value_descriptions (type, descs);
}
return type;
}
@ -52,16 +77,27 @@ gimp_interpolation_type_get_type (void)
{
static const GEnumValue values[] =
{
{ GIMP_INTERPOLATION_NONE, N_("None (Fastest)"), "none" },
{ GIMP_INTERPOLATION_LINEAR, N_("Linear"), "linear" },
{ GIMP_INTERPOLATION_CUBIC, N_("Cubic (Best)"), "cubic" },
{ GIMP_INTERPOLATION_NONE, "GIMP_INTERPOLATION_NONE", "none" },
{ GIMP_INTERPOLATION_LINEAR, "GIMP_INTERPOLATION_LINEAR", "linear" },
{ GIMP_INTERPOLATION_CUBIC, "GIMP_INTERPOLATION_CUBIC", "cubic" },
{ 0, NULL, NULL }
};
static const GimpEnumDesc descs[] =
{
{ GIMP_INTERPOLATION_NONE, N_("None (Fastest)"), NULL },
{ GIMP_INTERPOLATION_LINEAR, N_("Linear"), NULL },
{ GIMP_INTERPOLATION_CUBIC, N_("Cubic (Best)"), NULL },
{ 0, NULL, NULL }
};
static GType type = 0;
if (! type)
type = g_enum_register_static ("GimpInterpolationType", values);
{
type = g_enum_register_static ("GimpInterpolationType", values);
gimp_enum_set_value_descriptions (type, descs);
}
return type;
}
@ -97,10 +133,41 @@ gimp_layer_mode_effects_get_type (void)
{ 0, NULL, NULL }
};
static const GimpEnumDesc descs[] =
{
{ GIMP_NORMAL_MODE, "GIMP_NORMAL_MODE", NULL },
{ GIMP_DISSOLVE_MODE, "GIMP_DISSOLVE_MODE", NULL },
{ GIMP_BEHIND_MODE, "GIMP_BEHIND_MODE", NULL },
{ GIMP_MULTIPLY_MODE, "GIMP_MULTIPLY_MODE", NULL },
{ GIMP_SCREEN_MODE, "GIMP_SCREEN_MODE", NULL },
{ GIMP_OVERLAY_MODE, "GIMP_OVERLAY_MODE", NULL },
{ GIMP_DIFFERENCE_MODE, "GIMP_DIFFERENCE_MODE", NULL },
{ GIMP_ADDITION_MODE, "GIMP_ADDITION_MODE", NULL },
{ GIMP_SUBTRACT_MODE, "GIMP_SUBTRACT_MODE", NULL },
{ GIMP_DARKEN_ONLY_MODE, "GIMP_DARKEN_ONLY_MODE", NULL },
{ GIMP_LIGHTEN_ONLY_MODE, "GIMP_LIGHTEN_ONLY_MODE", NULL },
{ GIMP_HUE_MODE, "GIMP_HUE_MODE", NULL },
{ GIMP_SATURATION_MODE, "GIMP_SATURATION_MODE", NULL },
{ GIMP_COLOR_MODE, "GIMP_COLOR_MODE", NULL },
{ GIMP_VALUE_MODE, "GIMP_VALUE_MODE", NULL },
{ GIMP_DIVIDE_MODE, "GIMP_DIVIDE_MODE", NULL },
{ GIMP_DODGE_MODE, "GIMP_DODGE_MODE", NULL },
{ GIMP_BURN_MODE, "GIMP_BURN_MODE", NULL },
{ GIMP_HARDLIGHT_MODE, "GIMP_HARDLIGHT_MODE", NULL },
{ GIMP_SOFTLIGHT_MODE, "GIMP_SOFTLIGHT_MODE", NULL },
{ GIMP_GRAIN_EXTRACT_MODE, "GIMP_GRAIN_EXTRACT_MODE", NULL },
{ GIMP_GRAIN_MERGE_MODE, "GIMP_GRAIN_MERGE_MODE", NULL },
{ GIMP_COLOR_ERASE_MODE, "GIMP_COLOR_ERASE_MODE", NULL },
{ 0, NULL, NULL }
};
static GType type = 0;
if (! type)
type = g_enum_register_static ("GimpLayerModeEffects", values);
{
type = g_enum_register_static ("GimpLayerModeEffects", values);
gimp_enum_set_value_descriptions (type, descs);
}
return type;
}
@ -110,16 +177,27 @@ gimp_transfer_mode_get_type (void)
{
static const GEnumValue values[] =
{
{ GIMP_SHADOWS, N_("Shadows"), "shadows" },
{ GIMP_MIDTONES, N_("Midtones"), "midtones" },
{ GIMP_HIGHLIGHTS, N_("Highlights"), "highlights" },
{ GIMP_SHADOWS, "GIMP_SHADOWS", "shadows" },
{ GIMP_MIDTONES, "GIMP_MIDTONES", "midtones" },
{ GIMP_HIGHLIGHTS, "GIMP_HIGHLIGHTS", "highlights" },
{ 0, NULL, NULL }
};
static const GimpEnumDesc descs[] =
{
{ GIMP_SHADOWS, N_("Shadows"), NULL },
{ GIMP_MIDTONES, N_("Midtones"), NULL },
{ GIMP_HIGHLIGHTS, N_("Highlights"), NULL },
{ 0, NULL, NULL }
};
static GType type = 0;
if (! type)
type = g_enum_register_static ("GimpTransferMode", values);
{
type = g_enum_register_static ("GimpTransferMode", values);
gimp_enum_set_value_descriptions (type, descs);
}
return type;
}

9
app/core/Makefile.am
View File

@ -253,11 +253,14 @@ $(srcdir)/gimpmarshal.c: $(srcdir)/gimpmarshal.h
$(srcdir)/core-enums.c: $(srcdir)/core-enums.h $(GIMP_MKENUMS)
$(GIMP_MKENUMS) \
--fhead "#include \"config.h\"\n#include <glib-object.h>\n#include \"core-enums.h\"\n#include \"gimp-intl.h\"" \
--fhead "#include \"config.h\"\n#include <glib-object.h>\n#include \"libgimpbase/gimpbase.h\"\n#include \"core-enums.h\"\n#include \"gimp-intl.h\"" \
--fprod "\n/* enumerations from \"@filename@\" */" \
--vhead "GType\n@enum_name@_get_type (void)\n{\n static const G@Type@Value values[] =\n {" \
--vprod " { @VALUENAME@, @valuedesc@, \"@valuenick@\" }," \
--vtail " { 0, NULL, NULL }\n };\n\n static GType type = 0;\n\n if (! type)\n type = g_@type@_register_static (\"@EnumName@\", values);\n\n return type;\n}\n" \
--vprod " { @VALUENAME@, \"@VALUENAME@\", \"@valuenick@\" }," \
--vtail " { 0, NULL, NULL }\n };\n" \
--dhead " static const Gimp@Type@Desc descs[] =\n {" \
--dprod " { @VALUENAME@, @valuedesc@, @valuehelp@ }," \
--dtail " { 0, NULL, NULL }\n };\n\n static GType type = 0;\n\n if (! type)\n {\n type = g_@type@_register_static (\"@EnumName@\", values);\n gimp_@type@_set_value_descriptions (type, descs);\n }\n\n return type;\n}\n" \
$(srcdir)/core-enums.h > xgen-cec \
&& cp xgen-cec $(@F) \
&& rm -f xgen-cec

867
app/core/core-enums.c
View File

File diff suppressed because it is too large Load Diff

9
app/display/Makefile.am
View File

@ -86,11 +86,14 @@ CLEANFILES = $(gen_sources)
$(srcdir)/display-enums.c: $(srcdir)/display-enums.h $(GIMP_MKENUMS)
$(GIMP_MKENUMS) \
--fhead "#include \"config.h\"\n#include <glib-object.h>\n#include \"display-enums.h\"\n#include\"gimp-intl.h\"" \
--fhead "#include \"config.h\"\n#include <glib-object.h>\n#include \"libgimpbase/gimpbase.h\"\n#include \"display-enums.h\"\n#include\"gimp-intl.h\"" \
--fprod "\n/* enumerations from \"@filename@\" */" \
--vhead "GType\n@enum_name@_get_type (void)\n{\n static const G@Type@Value values[] =\n {" \
--vprod " { @VALUENAME@, @valuedesc@, \"@valuenick@\" }," \
--vtail " { 0, NULL, NULL }\n };\n\n static GType type = 0;\n\n if (! type)\n type = g_@type@_register_static (\"@EnumName@\", values);\n\n return type;\n}\n" \
--vprod " { @VALUENAME@, \"@VALUENAME@\", \"@valuenick@\" }," \
--vtail " { 0, NULL, NULL }\n };\n" \
--dhead " static const Gimp@Type@Desc descs[] =\n {" \
--dprod " { @VALUENAME@, @valuedesc@, @valuehelp@ }," \
--dtail " { 0, NULL, NULL }\n };\n\n static GType type = 0;\n\n if (! type)\n {\n type = g_@type@_register_static (\"@EnumName@\", values);\n gimp_@type@_set_value_descriptions (type, descs);\n }\n\n return type;\n}\n" \
$(srcdir)/display-enums.h > xgen-dec \
&& cp xgen-dec $(@F) \
&& rm -f xgen-dec

42
app/display/display-enums.c
View File

@ -3,6 +3,7 @@
#include "config.h"
#include <glib-object.h>
#include "libgimpbase/gimpbase.h"
#include "display-enums.h"
#include"gimp-intl.h"
@ -12,16 +13,27 @@ gimp_cursor_mode_get_type (void)
{
static const GEnumValue values[] =
{
{ GIMP_CURSOR_MODE_TOOL_ICON, N_("Tool icon"), "tool-icon" },
{ GIMP_CURSOR_MODE_TOOL_CROSSHAIR, N_("Tool icon with crosshair"), "tool-crosshair" },
{ GIMP_CURSOR_MODE_CROSSHAIR, N_("Crosshair only"), "crosshair" },
{ GIMP_CURSOR_MODE_TOOL_ICON, "GIMP_CURSOR_MODE_TOOL_ICON", "tool-icon" },
{ GIMP_CURSOR_MODE_TOOL_CROSSHAIR, "GIMP_CURSOR_MODE_TOOL_CROSSHAIR", "tool-crosshair" },
{ GIMP_CURSOR_MODE_CROSSHAIR, "GIMP_CURSOR_MODE_CROSSHAIR", "crosshair" },
{ 0, NULL, NULL }
};
static const GimpEnumDesc descs[] =
{
{ GIMP_CURSOR_MODE_TOOL_ICON, N_("Tool icon"), NULL },
{ GIMP_CURSOR_MODE_TOOL_CROSSHAIR, N_("Tool icon with crosshair"), NULL },
{ GIMP_CURSOR_MODE_CROSSHAIR, N_("Crosshair only"), NULL },
{ 0, NULL, NULL }
};
static GType type = 0;
if (! type)
type = g_enum_register_static ("GimpCursorMode", values);
{
type = g_enum_register_static ("GimpCursorMode", values);
gimp_enum_set_value_descriptions (type, descs);
}
return type;
}
@ -31,17 +43,29 @@ gimp_canvas_padding_mode_get_type (void)
{
static const GEnumValue values[] =
{
{ GIMP_CANVAS_PADDING_MODE_DEFAULT, N_("From theme"), "default" },
{ GIMP_CANVAS_PADDING_MODE_LIGHT_CHECK, N_("Light check color"), "light-check" },
{ GIMP_CANVAS_PADDING_MODE_DARK_CHECK, N_("Dark check color"), "dark-check" },
{ GIMP_CANVAS_PADDING_MODE_CUSTOM, N_("Custom color"), "custom" },
{ GIMP_CANVAS_PADDING_MODE_DEFAULT, "GIMP_CANVAS_PADDING_MODE_DEFAULT", "default" },
{ GIMP_CANVAS_PADDING_MODE_LIGHT_CHECK, "GIMP_CANVAS_PADDING_MODE_LIGHT_CHECK", "light-check" },
{ GIMP_CANVAS_PADDING_MODE_DARK_CHECK, "GIMP_CANVAS_PADDING_MODE_DARK_CHECK", "dark-check" },
{ GIMP_CANVAS_PADDING_MODE_CUSTOM, "GIMP_CANVAS_PADDING_MODE_CUSTOM", "custom" },
{ 0, NULL, NULL }
};
static const GimpEnumDesc descs[] =
{
{ GIMP_CANVAS_PADDING_MODE_DEFAULT, N_("From theme"), NULL },
{ GIMP_CANVAS_PADDING_MODE_LIGHT_CHECK, N_("Light check color"), NULL },
{ GIMP_CANVAS_PADDING_MODE_DARK_CHECK, N_("Dark check color"), NULL },
{ GIMP_CANVAS_PADDING_MODE_CUSTOM, N_("Custom color"), NULL },
{ 0, NULL, NULL }
};
static GType type = 0;
if (! type)
type = g_enum_register_static ("GimpCanvasPaddingMode", values);
{
type = g_enum_register_static ("GimpCanvasPaddingMode", values);
gimp_enum_set_value_descriptions (type, descs);
}
return type;
}

9
app/paint/Makefile.am
View File

@ -83,11 +83,14 @@ CLEANFILES = $(gen_sources)
$(srcdir)/paint-enums.c: $(srcdir)/paint-enums.h $(GIMP_MKENUMS)
$(GIMP_MKENUMS) \
--fhead "#include \"config.h\"\n#include <glib-object.h>\n#include \"paint-enums.h\"\n#include \"gimp-intl.h\"" \
--fhead "#include \"config.h\"\n#include <glib-object.h>\n#include \"libgimpbase/gimpbase.h\"\n#include \"paint-enums.h\"\n#include \"gimp-intl.h\"" \
--fprod "\n/* enumerations from \"@filename@\" */" \
--vhead "GType\n@enum_name@_get_type (void)\n{\n static const G@Type@Value values[] =\n {" \
--vprod " { @VALUENAME@, @valuedesc@, \"@valuenick@\" }," \
--vtail " { 0, NULL, NULL }\n };\n\n static GType type = 0;\n\n if (! type)\n type = g_@type@_register_static (\"@EnumName@\", values);\n\n return type;\n}\n" \
--vprod " { @VALUENAME@, \"@VALUENAME@\", \"@valuenick@\" }," \
--vtail " { 0, NULL, NULL }\n };\n" \
--dhead " static const Gimp@Type@Desc descs[] =\n {" \
--dprod " { @VALUENAME@, @valuedesc@, @valuehelp@ }," \
--dtail " { 0, NULL, NULL }\n };\n\n static GType type = 0;\n\n if (! type)\n {\n type = g_@type@_register_static (\"@EnumName@\", values);\n gimp_@type@_set_value_descriptions (type, descs);\n }\n\n return type;\n}\n" \
$(srcdir)/paint-enums.h > xgen-pec \
&& cp xgen-pec $(@F) \
&& rm -f xgen-pec

97
app/paint/paint-enums.c
View File

@ -3,6 +3,7 @@
#include "config.h"
#include <glib-object.h>
#include "libgimpbase/gimpbase.h"
#include "paint-enums.h"
#include "gimp-intl.h"
@ -12,15 +13,25 @@ gimp_clone_type_get_type (void)
{
static const GEnumValue values[] =
{
{ GIMP_IMAGE_CLONE, N_("Image source"), "image-clone" },
{ GIMP_PATTERN_CLONE, N_("Pattern source"), "pattern-clone" },
{ GIMP_IMAGE_CLONE, "GIMP_IMAGE_CLONE", "image-clone" },
{ GIMP_PATTERN_CLONE, "GIMP_PATTERN_CLONE", "pattern-clone" },
{ 0, NULL, NULL }
};
static const GimpEnumDesc descs[] =
{
{ GIMP_IMAGE_CLONE, N_("Image source"), NULL },
{ GIMP_PATTERN_CLONE, N_("Pattern source"), NULL },
{ 0, NULL, NULL }
};
static GType type = 0;
if (! type)
type = g_enum_register_static ("GimpCloneType", values);
{
type = g_enum_register_static ("GimpCloneType", values);
gimp_enum_set_value_descriptions (type, descs);
}
return type;
}
@ -30,16 +41,27 @@ gimp_clone_align_mode_get_type (void)
{
static const GEnumValue values[] =
{
{ GIMP_CLONE_ALIGN_NO, N_("Non-aligned"), "no" },
{ GIMP_CLONE_ALIGN_YES, N_("Aligned"), "yes" },
{ GIMP_CLONE_ALIGN_REGISTERED, N_("Registered"), "registered" },
{ GIMP_CLONE_ALIGN_NO, "GIMP_CLONE_ALIGN_NO", "no" },
{ GIMP_CLONE_ALIGN_YES, "GIMP_CLONE_ALIGN_YES", "yes" },
{ GIMP_CLONE_ALIGN_REGISTERED, "GIMP_CLONE_ALIGN_REGISTERED", "registered" },
{ 0, NULL, NULL }
};
static const GimpEnumDesc descs[] =
{
{ GIMP_CLONE_ALIGN_NO, N_("Non-aligned"), NULL },
{ GIMP_CLONE_ALIGN_YES, N_("Aligned"), NULL },
{ GIMP_CLONE_ALIGN_REGISTERED, N_("Registered"), NULL },
{ 0, NULL, NULL }
};
static GType type = 0;
if (! type)
type = g_enum_register_static ("GimpCloneAlignMode", values);
{
type = g_enum_register_static ("GimpCloneAlignMode", values);
gimp_enum_set_value_descriptions (type, descs);
}
return type;
}
@ -49,15 +71,25 @@ gimp_dodge_burn_type_get_type (void)
{
static const GEnumValue values[] =
{
{ GIMP_DODGE, N_("Dodge"), "dodge" },
{ GIMP_BURN, N_("Burn"), "burn" },
{ GIMP_DODGE, "GIMP_DODGE", "dodge" },
{ GIMP_BURN, "GIMP_BURN", "burn" },
{ 0, NULL, NULL }
};
static const GimpEnumDesc descs[] =
{
{ GIMP_DODGE, N_("Dodge"), NULL },
{ GIMP_BURN, N_("Burn"), NULL },
{ 0, NULL, NULL }
};
static GType type = 0;
if (! type)
type = g_enum_register_static ("GimpDodgeBurnType", values);
{
type = g_enum_register_static ("GimpDodgeBurnType", values);
gimp_enum_set_value_descriptions (type, descs);
}
return type;
}
@ -67,15 +99,25 @@ gimp_convolve_type_get_type (void)
{
static const GEnumValue values[] =
{
{ GIMP_BLUR_CONVOLVE, N_("Blur"), "blur-convolve" },
{ GIMP_SHARPEN_CONVOLVE, N_("Sharpen"), "sharpen-convolve" },
{ GIMP_BLUR_CONVOLVE, "GIMP_BLUR_CONVOLVE", "blur-convolve" },
{ GIMP_SHARPEN_CONVOLVE, "GIMP_SHARPEN_CONVOLVE", "sharpen-convolve" },
{ 0, NULL, NULL }
};
static const GimpEnumDesc descs[] =
{
{ GIMP_BLUR_CONVOLVE, N_("Blur"), NULL },
{ GIMP_SHARPEN_CONVOLVE, N_("Sharpen"), NULL },
{ 0, NULL, NULL }
};
static GType type = 0;
if (! type)
type = g_enum_register_static ("GimpConvolveType", values);
{
type = g_enum_register_static ("GimpConvolveType", values);
gimp_enum_set_value_descriptions (type, descs);
}
return type;
}
@ -91,10 +133,21 @@ gimp_ink_blob_type_get_type (void)
{ 0, NULL, NULL }
};
static const GimpEnumDesc descs[] =
{
{ GIMP_INK_BLOB_TYPE_ELLIPSE, "GIMP_INK_BLOB_TYPE_ELLIPSE", NULL },
{ GIMP_INK_BLOB_TYPE_SQUARE, "GIMP_INK_BLOB_TYPE_SQUARE", NULL },
{ GIMP_INK_BLOB_TYPE_DIAMOND, "GIMP_INK_BLOB_TYPE_DIAMOND", NULL },
{ 0, NULL, NULL }
};
static GType type = 0;
if (! type)
type = g_enum_register_static ("GimpInkBlobType", values);
{
type = g_enum_register_static ("GimpInkBlobType", values);
gimp_enum_set_value_descriptions (type, descs);
}
return type;
}
@ -104,15 +157,25 @@ gimp_paint_application_mode_get_type (void)
{
static const GEnumValue values[] =
{
{ GIMP_PAINT_CONSTANT, N_("Constant"), "constant" },
{ GIMP_PAINT_INCREMENTAL, N_("Incremental"), "incremental" },
{ GIMP_PAINT_CONSTANT, "GIMP_PAINT_CONSTANT", "constant" },
{ GIMP_PAINT_INCREMENTAL, "GIMP_PAINT_INCREMENTAL", "incremental" },
{ 0, NULL, NULL }
};
static const GimpEnumDesc descs[] =
{
{ GIMP_PAINT_CONSTANT, N_("Constant"), NULL },
{ GIMP_PAINT_INCREMENTAL, N_("Incremental"), NULL },
{ 0, NULL, NULL }
};
static GType type = 0;
if (! type)
type = g_enum_register_static ("GimpPaintApplicationMode", values);
{
type = g_enum_register_static ("GimpPaintApplicationMode", values);
gimp_enum_set_value_descriptions (type, descs);
}
return type;
}

6
app/plug-in/gimpplugin.c
View File

@ -538,7 +538,11 @@ plug_in_close (PlugIn *plug_in,
/* If necessary, kill the filter. */
#ifndef G_OS_WIN32
if (kill_it && plug_in->pid)
status = kill (plug_in->pid, SIGKILL);
{
g_warning ("Terminating %s ...",
gimp_filename_to_utf8 (plug_in->prog));
status = kill (plug_in->pid, SIGKILL);
}
/* Wait for the process to exit. This will happen
* immediately if it was just killed.

6
app/plug-in/plug-in.c
View File

@ -538,7 +538,11 @@ plug_in_close (PlugIn *plug_in,
/* If necessary, kill the filter. */
#ifndef G_OS_WIN32
if (kill_it && plug_in->pid)
status = kill (plug_in->pid, SIGKILL);
{
g_warning ("Terminating %s ...",
gimp_filename_to_utf8 (plug_in->prog));
status = kill (plug_in->pid, SIGKILL);
}
/* Wait for the process to exit. This will happen
* immediately if it was just killed.

9
app/text/Makefile.am
View File

@ -64,11 +64,14 @@ CLEANFILES = $(gen_sources)
$(srcdir)/text-enums.c: $(srcdir)/text-enums.h $(GIMP_MKENUMS)
$(GIMP_MKENUMS) \
--fhead "#include \"config.h\"\n#include <glib-object.h>\n#include \"text-enums.h\"\n#include \"gimp-intl.h\"" \
--fhead "#include \"config.h\"\n#include <glib-object.h>\n#include \"libgimpbase/gimpbase.h\"\n#include \"text-enums.h\"\n#include \"gimp-intl.h\"" \
--fprod "\n/* enumerations from \"@filename@\" */" \
--vhead "GType\n@enum_name@_get_type (void)\n{\n static const G@Type@Value values[] =\n {" \
--vprod " { @VALUENAME@, @valuedesc@, \"@valuenick@\" }," \
--vtail " { 0, NULL, NULL }\n };\n\n static GType type = 0;\n\n if (! type)\n type = g_@type@_register_static (\"@EnumName@\", values);\n\n return type;\n}\n" \
--vprod " { @VALUENAME@, \"@VALUENAME@\", \"@valuenick@\" }," \
--vtail " { 0, NULL, NULL }\n };\n" \
--dhead " static const Gimp@Type@Desc descs[] =\n {" \
--dprod " { @VALUENAME@, @valuedesc@, @valuehelp@ }," \
--dtail " { 0, NULL, NULL }\n };\n\n static GType type = 0;\n\n if (! type)\n {\n type = g_@type@_register_static (\"@EnumName@\", values);\n gimp_@type@_set_value_descriptions (type, descs);\n }\n\n return type;\n}\n" \
$(srcdir)/text-enums.h > xgen-tec \
&& cp xgen-tec $(@F) \
&& rm -f xgen-tec

64
app/text/text-enums.c
View File

@ -3,6 +3,7 @@
#include "config.h"
#include <glib-object.h>
#include "libgimpbase/gimpbase.h"
#include "text-enums.h"
#include "gimp-intl.h"
@ -17,10 +18,20 @@ gimp_text_box_mode_get_type (void)
{ 0, NULL, NULL }
};
static const GimpEnumDesc descs[] =
{
{ GIMP_TEXT_BOX_DYNAMIC, "GIMP_TEXT_BOX_DYNAMIC", NULL },
{ GIMP_TEXT_BOX_FIXED, "GIMP_TEXT_BOX_FIXED", NULL },
{ 0, NULL, NULL }
};
static GType type = 0;
if (! type)
type = g_enum_register_static ("GimpTextBoxMode", values);
{
type = g_enum_register_static ("GimpTextBoxMode", values);
gimp_enum_set_value_descriptions (type, descs);
}
return type;
}
@ -30,15 +41,25 @@ gimp_text_direction_get_type (void)
{
static const GEnumValue values[] =
{
{ GIMP_TEXT_DIRECTION_LTR, N_("From left to right"), "ltr" },
{ GIMP_TEXT_DIRECTION_RTL, N_("From right to left"), "rtl" },
{ GIMP_TEXT_DIRECTION_LTR, "GIMP_TEXT_DIRECTION_LTR", "ltr" },
{ GIMP_TEXT_DIRECTION_RTL, "GIMP_TEXT_DIRECTION_RTL", "rtl" },
{ 0, NULL, NULL }
};
static const GimpEnumDesc descs[] =
{
{ GIMP_TEXT_DIRECTION_LTR, N_("From left to right"), NULL },
{ GIMP_TEXT_DIRECTION_RTL, N_("From right to left"), NULL },
{ 0, NULL, NULL }
};
static GType type = 0;
if (! type)
type = g_enum_register_static ("GimpTextDirection", values);
{
type = g_enum_register_static ("GimpTextDirection", values);
gimp_enum_set_value_descriptions (type, descs);
}
return type;
}
@ -48,17 +69,29 @@ gimp_text_justification_get_type (void)
{
static const GEnumValue values[] =
{
{ GIMP_TEXT_JUSTIFY_LEFT, N_("Left justified"), "left" },
{ GIMP_TEXT_JUSTIFY_RIGHT, N_("Right justified"), "right" },
{ GIMP_TEXT_JUSTIFY_CENTER, N_("Centered"), "center" },
{ GIMP_TEXT_JUSTIFY_FILL, N_("Filled"), "fill" },
{ GIMP_TEXT_JUSTIFY_LEFT, "GIMP_TEXT_JUSTIFY_LEFT", "left" },
{ GIMP_TEXT_JUSTIFY_RIGHT, "GIMP_TEXT_JUSTIFY_RIGHT", "right" },
{ GIMP_TEXT_JUSTIFY_CENTER, "GIMP_TEXT_JUSTIFY_CENTER", "center" },
{ GIMP_TEXT_JUSTIFY_FILL, "GIMP_TEXT_JUSTIFY_FILL", "fill" },
{ 0, NULL, NULL }
};
static const GimpEnumDesc descs[] =
{
{ GIMP_TEXT_JUSTIFY_LEFT, N_("Left justified"), NULL },
{ GIMP_TEXT_JUSTIFY_RIGHT, N_("Right justified"), NULL },
{ GIMP_TEXT_JUSTIFY_CENTER, N_("Centered"), NULL },
{ GIMP_TEXT_JUSTIFY_FILL, N_("Filled"), NULL },
{ 0, NULL, NULL }
};
static GType type = 0;
if (! type)
type = g_enum_register_static ("GimpTextJustification", values);
{
type = g_enum_register_static ("GimpTextJustification", values);
gimp_enum_set_value_descriptions (type, descs);
}
return type;
}
@ -74,10 +107,21 @@ gimp_text_outline_get_type (void)
{ 0, NULL, NULL }
};
static const GimpEnumDesc descs[] =
{
{ GIMP_TEXT_OUTLINE_NONE, "GIMP_TEXT_OUTLINE_NONE", NULL },
{ GIMP_TEXT_OUTLINE_STROKE_ONLY, "GIMP_TEXT_OUTLINE_STROKE_ONLY", NULL },
{ GIMP_TEXT_OUTLINE_STROKE_FILL, "GIMP_TEXT_OUTLINE_STROKE_FILL", NULL },
{ 0, NULL, NULL }
};
static GType type = 0;
if (! type)
type = g_enum_register_static ("GimpTextOutline", values);
{
type = g_enum_register_static ("GimpTextOutline", values);
gimp_enum_set_value_descriptions (type, descs);
}
return type;
}

9
app/tools/Makefile.am
View File

@ -170,11 +170,14 @@ CLEANFILES = $(gen_sources)
$(srcdir)/tools-enums.c: $(srcdir)/tools-enums.h $(GIMP_MKENUMS)
$(GIMP_MKENUMS) \
--fhead "#include \"config.h\"\n#include <glib-object.h>\n#include \"core/core-enums.h\"\n#include \"tools-enums.h\"\n#include \"gimp-intl.h\"" \
--fhead "#include \"config.h\"\n#include <glib-object.h>\n#include \"libgimpbase/gimpbase.h\"\n#include \"core/core-enums.h\"\n#include \"tools-enums.h\"\n#include \"gimp-intl.h\"" \
--fprod "\n/* enumerations from \"@filename@\" */" \
--vhead "GType\n@enum_name@_get_type (void)\n{\n static const G@Type@Value values[] =\n {" \
--vprod " { @VALUENAME@, @valuedesc@, \"@valuenick@\" }," \
--vtail " { 0, NULL, NULL }\n };\n\n static GType type = 0;\n\n if (! type)\n type = g_@type@_register_static (\"@EnumName@\", values);\n\n return type;\n}\n" \
--vprod " { @VALUENAME@, \"@VALUENAME@\", \"@valuenick@\" }," \
--vtail " { 0, NULL, NULL }\n };\n" \
--dhead " static const Gimp@Type@Desc descs[] =\n {" \
--dprod " { @VALUENAME@, @valuedesc@, @valuehelp@ }," \
--dtail " { 0, NULL, NULL }\n };\n\n static GType type = 0;\n\n if (! type)\n {\n type = g_@type@_register_static (\"@EnumName@\", values);\n gimp_@type@_set_value_descriptions (type, descs);\n }\n\n return type;\n}\n" \
$(srcdir)/tools-enums.h > xgen-tec \
&& cp xgen-tec $(@F) \
&& rm -f xgen-tec

131
app/tools/tools-enums.c
View File

@ -3,6 +3,7 @@
#include "config.h"
#include <glib-object.h>
#include "libgimpbase/gimpbase.h"
#include "core/core-enums.h"
#include "tools-enums.h"
#include "gimp-intl.h"
@ -13,16 +14,27 @@ gimp_color_pick_mode_get_type (void)
{
static const GEnumValue values[] =
{
{ GIMP_COLOR_PICK_MODE_NONE, N_("Pick only"), "none" },
{ GIMP_COLOR_PICK_MODE_FOREGROUND, N_("Set foreground color"), "foreground" },
{ GIMP_COLOR_PICK_MODE_BACKGROUND, N_("Set background color"), "background" },
{ GIMP_COLOR_PICK_MODE_NONE, "GIMP_COLOR_PICK_MODE_NONE", "none" },
{ GIMP_COLOR_PICK_MODE_FOREGROUND, "GIMP_COLOR_PICK_MODE_FOREGROUND", "foreground" },
{ GIMP_COLOR_PICK_MODE_BACKGROUND, "GIMP_COLOR_PICK_MODE_BACKGROUND", "background" },
{ 0, NULL, NULL }
};
static const GimpEnumDesc descs[] =
{
{ GIMP_COLOR_PICK_MODE_NONE, N_("Pick only"), NULL },
{ GIMP_COLOR_PICK_MODE_FOREGROUND, N_("Set foreground color"), NULL },
{ GIMP_COLOR_PICK_MODE_BACKGROUND, N_("Set background color"), NULL },
{ 0, NULL, NULL }
};
static GType type = 0;
if (! type)
type = g_enum_register_static ("GimpColorPickMode", values);
{
type = g_enum_register_static ("GimpColorPickMode", values);
gimp_enum_set_value_descriptions (type, descs);
}
return type;
}
@ -32,15 +44,25 @@ gimp_crop_mode_get_type (void)
{
static const GEnumValue values[] =
{
{ GIMP_CROP_MODE_CROP, N_("Crop"), "crop" },
{ GIMP_CROP_MODE_RESIZE, N_("Resize"), "resize" },
{ GIMP_CROP_MODE_CROP, "GIMP_CROP_MODE_CROP", "crop" },
{ GIMP_CROP_MODE_RESIZE, "GIMP_CROP_MODE_RESIZE", "resize" },
{ 0, NULL, NULL }
};
static const GimpEnumDesc descs[] =
{
{ GIMP_CROP_MODE_CROP, N_("Crop"), NULL },
{ GIMP_CROP_MODE_RESIZE, N_("Resize"), NULL },
{ 0, NULL, NULL }
};
static GType type = 0;
if (! type)
type = g_enum_register_static ("GimpCropMode", values);
{
type = g_enum_register_static ("GimpCropMode", values);
gimp_enum_set_value_descriptions (type, descs);
}
return type;
}
@ -50,16 +72,27 @@ gimp_rect_select_mode_get_type (void)
{
static const GEnumValue values[] =
{
{ GIMP_RECT_SELECT_MODE_FREE, N_("Free select"), "free" },
{ GIMP_RECT_SELECT_MODE_FIXED_SIZE, N_("Fixed size"), "fixed-size" },
{ GIMP_RECT_SELECT_MODE_FIXED_RATIO, N_("Fixed aspect ratio"), "fixed-ratio" },
{ GIMP_RECT_SELECT_MODE_FREE, "GIMP_RECT_SELECT_MODE_FREE", "free" },
{ GIMP_RECT_SELECT_MODE_FIXED_SIZE, "GIMP_RECT_SELECT_MODE_FIXED_SIZE", "fixed-size" },
{ GIMP_RECT_SELECT_MODE_FIXED_RATIO, "GIMP_RECT_SELECT_MODE_FIXED_RATIO", "fixed-ratio" },
{ 0, NULL, NULL }
};
static const GimpEnumDesc descs[] =
{
{ GIMP_RECT_SELECT_MODE_FREE, N_("Free select"), NULL },
{ GIMP_RECT_SELECT_MODE_FIXED_SIZE, N_("Fixed size"), NULL },
{ GIMP_RECT_SELECT_MODE_FIXED_RATIO, N_("Fixed aspect ratio"), NULL },
{ 0, NULL, NULL }
};
static GType type = 0;
if (! type)
type = g_enum_register_static ("GimpRectSelectMode", values);
{
type = g_enum_register_static ("GimpRectSelectMode", values);
gimp_enum_set_value_descriptions (type, descs);
}
return type;
}
@ -69,16 +102,27 @@ gimp_transform_type_get_type (void)
{
static const GEnumValue values[] =
{
{ GIMP_TRANSFORM_TYPE_LAYER, N_("Transform layer"), "layer" },
{ GIMP_TRANSFORM_TYPE_SELECTION, N_("Transform selection"), "selection" },
{ GIMP_TRANSFORM_TYPE_PATH, N_("Transform path"), "path" },
{ GIMP_TRANSFORM_TYPE_LAYER, "GIMP_TRANSFORM_TYPE_LAYER", "layer" },
{ GIMP_TRANSFORM_TYPE_SELECTION, "GIMP_TRANSFORM_TYPE_SELECTION", "selection" },
{ GIMP_TRANSFORM_TYPE_PATH, "GIMP_TRANSFORM_TYPE_PATH", "path" },
{ 0, NULL, NULL }
};
static const GimpEnumDesc descs[] =
{
{ GIMP_TRANSFORM_TYPE_LAYER, N_("Transform layer"), NULL },
{ GIMP_TRANSFORM_TYPE_SELECTION, N_("Transform selection"), NULL },
{ GIMP_TRANSFORM_TYPE_PATH, N_("Transform path"), NULL },
{ 0, NULL, NULL }
};
static GType type = 0;
if (! type)
type = g_enum_register_static ("GimpTransformType", values);
{
type = g_enum_register_static ("GimpTransformType", values);
gimp_enum_set_value_descriptions (type, descs);
}
return type;
}
@ -88,16 +132,27 @@ gimp_vector_mode_get_type (void)
{
static const GEnumValue values[] =
{
{ GIMP_VECTOR_MODE_DESIGN, N_("Design"), "design" },
{ GIMP_VECTOR_MODE_EDIT, N_("Edit"), "edit" },
{ GIMP_VECTOR_MODE_MOVE, N_("Move"), "move" },
{ GIMP_VECTOR_MODE_DESIGN, "GIMP_VECTOR_MODE_DESIGN", "design" },
{ GIMP_VECTOR_MODE_EDIT, "GIMP_VECTOR_MODE_EDIT", "edit" },
{ GIMP_VECTOR_MODE_MOVE, "GIMP_VECTOR_MODE_MOVE", "move" },
{ 0, NULL, NULL }
};
static const GimpEnumDesc descs[] =
{
{ GIMP_VECTOR_MODE_DESIGN, N_("Design"), NULL },
{ GIMP_VECTOR_MODE_EDIT, N_("Edit"), NULL },
{ GIMP_VECTOR_MODE_MOVE, N_("Move"), NULL },
{ 0, NULL, NULL }
};
static GType type = 0;
if (! type)
type = g_enum_register_static ("GimpVectorMode", values);
{
type = g_enum_register_static ("GimpVectorMode", values);
gimp_enum_set_value_descriptions (type, descs);
}
return type;
}
@ -107,17 +162,29 @@ gimp_transform_preview_type_get_type (void)
{
static const GEnumValue values[] =
{
{ GIMP_TRANSFORM_PREVIEW_TYPE_OUTLINE, N_("Outline"), "outline" },
{ GIMP_TRANSFORM_PREVIEW_TYPE_GRID, N_("Grid"), "grid" },
{ GIMP_TRANSFORM_PREVIEW_TYPE_IMAGE, N_("Image"), "image" },
{ GIMP_TRANSFORM_PREVIEW_TYPE_IMAGE_GRID, N_("Image + Grid"), "image-grid" },
{ GIMP_TRANSFORM_PREVIEW_TYPE_OUTLINE, "GIMP_TRANSFORM_PREVIEW_TYPE_OUTLINE", "outline" },
{ GIMP_TRANSFORM_PREVIEW_TYPE_GRID, "GIMP_TRANSFORM_PREVIEW_TYPE_GRID", "grid" },
{ GIMP_TRANSFORM_PREVIEW_TYPE_IMAGE, "GIMP_TRANSFORM_PREVIEW_TYPE_IMAGE", "image" },
{ GIMP_TRANSFORM_PREVIEW_TYPE_IMAGE_GRID, "GIMP_TRANSFORM_PREVIEW_TYPE_IMAGE_GRID", "image-grid" },
{ 0, NULL, NULL }
};
static const GimpEnumDesc descs[] =
{
{ GIMP_TRANSFORM_PREVIEW_TYPE_OUTLINE, N_("Outline"), NULL },
{ GIMP_TRANSFORM_PREVIEW_TYPE_GRID, N_("Grid"), NULL },
{ GIMP_TRANSFORM_PREVIEW_TYPE_IMAGE, N_("Image"), NULL },
{ GIMP_TRANSFORM_PREVIEW_TYPE_IMAGE_GRID, N_("Image + Grid"), NULL },
{ 0, NULL, NULL }
};
static GType type = 0;
if (! type)
type = g_enum_register_static ("GimpTransformPreviewType", values);
{
type = g_enum_register_static ("GimpTransformPreviewType", values);
gimp_enum_set_value_descriptions (type, descs);
}
return type;
}
@ -127,15 +194,25 @@ gimp_transform_grid_type_get_type (void)
{
static const GEnumValue values[] =
{
{ GIMP_TRANSFORM_GRID_TYPE_N_LINES, N_("Number of grid lines"), "n-lines" },
{ GIMP_TRANSFORM_GRID_TYPE_SPACING, N_("Grid line spacing"), "spacing" },
{ GIMP_TRANSFORM_GRID_TYPE_N_LINES, "GIMP_TRANSFORM_GRID_TYPE_N_LINES", "n-lines" },
{ GIMP_TRANSFORM_GRID_TYPE_SPACING, "GIMP_TRANSFORM_GRID_TYPE_SPACING", "spacing" },
{ 0, NULL, NULL }
};
static const GimpEnumDesc descs[] =
{
{ GIMP_TRANSFORM_GRID_TYPE_N_LINES, N_("Number of grid lines"), NULL },
{ GIMP_TRANSFORM_GRID_TYPE_SPACING, N_("Grid line spacing"), NULL },
{ 0, NULL, NULL }
};
static GType type = 0;
if (! type)
type = g_enum_register_static ("GimpTransformGridType", values);
{
type = g_enum_register_static ("GimpTransformGridType", values);
gimp_enum_set_value_descriptions (type, descs);
}
return type;
}

9
app/widgets/Makefile.am
View File

@ -301,11 +301,14 @@ CLEANFILES = $(gen_sources)
$(srcdir)/widgets-enums.c: $(srcdir)/widgets-enums.h $(GIMP_MKENUMS)
$(GIMP_MKENUMS) \
--fhead "#include \"config.h\"\n#include <gtk/gtk.h>\n#include \"widgets-enums.h\"\n#include \"gimp-intl.h\"" \
--fhead "#include \"config.h\"\n#include <gtk/gtk.h>\n#include \"libgimpbase/gimpbase.h\"\n#include \"widgets-enums.h\"\n#include \"gimp-intl.h\"" \
--fprod "\n/* enumerations from \"@filename@\" */" \
--vhead "GType\n@enum_name@_get_type (void)\n{\n static const G@Type@Value values[] =\n {" \
--vprod " { @VALUENAME@, @valuedesc@, \"@valuenick@\" }," \
--vtail " { 0, NULL, NULL }\n };\n\n static GType type = 0;\n\n if (! type)\n type = g_@type@_register_static (\"@EnumName@\", values);\n\n return type;\n}\n" \
--vprod " { @VALUENAME@, \"@VALUENAME@\", \"@valuenick@\" }," \
--vtail " { 0, NULL, NULL }\n };\n" \
--dhead " static const Gimp@Type@Desc descs[] =\n {" \
--dprod " { @VALUENAME@, @valuedesc@, @valuehelp@ }," \
--dtail " { 0, NULL, NULL }\n };\n\n static GType type = 0;\n\n if (! type)\n {\n type = g_@type@_register_static (\"@EnumName@\", values);\n gimp_@type@_set_value_descriptions (type, descs);\n }\n\n return type;\n}\n" \
$(srcdir)/widgets-enums.h > xgen-wec \
&& cp xgen-wec $(@F) \
&& rm -f xgen-wec

6
app/widgets/gimpenumstore.c
View File

@ -96,14 +96,14 @@ gimp_enum_store_add_value (GtkListStore *store,
GEnumValue *value)
{
GtkTreeIter iter;
const gchar *name;
const gchar *desc;
name = gimp_enum_value_get_name (GIMP_ENUM_STORE (store)->enum_class, value);
desc = gimp_enum_value_get_desc (GIMP_ENUM_STORE (store)->enum_class, value);
gtk_list_store_append (store, &iter);
gtk_list_store_set (store, &iter,
GIMP_INT_STORE_VALUE, value->value,
GIMP_INT_STORE_LABEL, name,
GIMP_INT_STORE_LABEL, desc,
-1);
}

8
app/widgets/gimpenumwidgets.c
View File

@ -95,14 +95,14 @@ gimp_enum_radio_box_new_with_range (GType enum_type,
for (value = enum_class->values; value->value_name; value++)
{
const gchar *name;
const gchar *desc;
if (value->value < minimum || value->value > maximum)
continue;
name = gimp_enum_value_get_name (enum_class, value);
desc = gimp_enum_value_get_desc (enum_class, value);
button = gtk_radio_button_new_with_mnemonic (group, name);
button = gtk_radio_button_new_with_mnemonic (group, desc);
if (first_button && *first_button == NULL)
*first_button = button;
@ -303,7 +303,7 @@ gimp_enum_stock_box_new_with_range (GType enum_type,
}
gimp_help_set_help_data (button,
gimp_enum_value_get_name (enum_class, value),
gimp_enum_value_get_desc (enum_class, value),
NULL);
group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (button));

8
app/widgets/gimptemplateeditor.c
View File

@ -646,7 +646,7 @@ gimp_template_editor_template_notify (GimpTemplate *template,
GimpTemplateEditor *editor)
{
GimpAspectType aspect;
const gchar *name;
const gchar *desc;
gchar *text;
if (param_spec)
@ -685,15 +685,15 @@ gimp_template_editor_template_notify (GimpTemplate *template,
editor->block_aspect = FALSE;
gimp_enum_get_value (GIMP_TYPE_IMAGE_BASE_TYPE, template->image_type,
NULL, &name);
NULL, NULL, &desc, NULL);
if ((gint) template->xresolution != (gint) template->yresolution)
text = g_strdup_printf (_("%d x %d dpi, %s"),
(gint) template->xresolution,
(gint) template->yresolution, name);
(gint) template->yresolution, desc);
else
text = g_strdup_printf (_("%d dpi, %s"),
(gint) template->yresolution, name);
(gint) template->yresolution, desc);
gtk_label_set_text (GTK_LABEL (editor->more_label), text);
g_free (text);

214
app/widgets/widgets-enums.c
View File

@ -3,6 +3,7 @@
#include "config.h"
#include <gtk/gtk.h>
#include "libgimpbase/gimpbase.h"
#include "widgets-enums.h"
#include "gimp-intl.h"
@ -12,15 +13,25 @@ gimp_active_color_get_type (void)
{
static const GEnumValue values[] =
{
{ GIMP_ACTIVE_COLOR_FOREGROUND, N_("Foreground"), "foreground" },
{ GIMP_ACTIVE_COLOR_BACKGROUND, N_("Background"), "background" },
{ GIMP_ACTIVE_COLOR_FOREGROUND, "GIMP_ACTIVE_COLOR_FOREGROUND", "foreground" },
{ GIMP_ACTIVE_COLOR_BACKGROUND, "GIMP_ACTIVE_COLOR_BACKGROUND", "background" },
{ 0, NULL, NULL }
};
static const GimpEnumDesc descs[] =
{
{ GIMP_ACTIVE_COLOR_FOREGROUND, N_("Foreground"), NULL },
{ GIMP_ACTIVE_COLOR_BACKGROUND, N_("Background"), NULL },
{ 0, NULL, NULL }
};
static GType type = 0;
if (! type)
type = g_enum_register_static ("GimpActiveColor", values);
{
type = g_enum_register_static ("GimpActiveColor", values);
gimp_enum_set_value_descriptions (type, descs);
}
return type;
}
@ -31,15 +42,26 @@ gimp_aspect_type_get_type (void)
static const GEnumValue values[] =
{
{ GIMP_ASPECT_SQUARE, "GIMP_ASPECT_SQUARE", "square" },
{ GIMP_ASPECT_PORTRAIT, N_("Portrait"), "portrait" },
{ GIMP_ASPECT_LANDSCAPE, N_("Landscape"), "landscape" },
{ GIMP_ASPECT_PORTRAIT, "GIMP_ASPECT_PORTRAIT", "portrait" },
{ GIMP_ASPECT_LANDSCAPE, "GIMP_ASPECT_LANDSCAPE", "landscape" },
{ 0, NULL, NULL }
};
static const GimpEnumDesc descs[] =
{
{ GIMP_ASPECT_SQUARE, "GIMP_ASPECT_SQUARE", NULL },
{ GIMP_ASPECT_PORTRAIT, N_("Portrait"), NULL },
{ GIMP_ASPECT_LANDSCAPE, N_("Landscape"), NULL },
{ 0, NULL, NULL }
};
static GType type = 0;
if (! type)
type = g_enum_register_static ("GimpAspectType", values);
{
type = g_enum_register_static ("GimpAspectType", values);
gimp_enum_set_value_descriptions (type, descs);
}
return type;
}
@ -55,10 +77,21 @@ gimp_color_dialog_state_get_type (void)
{ 0, NULL, NULL }
};
static const GimpEnumDesc descs[] =
{
{ GIMP_COLOR_DIALOG_OK, "GIMP_COLOR_DIALOG_OK", NULL },
{ GIMP_COLOR_DIALOG_CANCEL, "GIMP_COLOR_DIALOG_CANCEL", NULL },
{ GIMP_COLOR_DIALOG_UPDATE, "GIMP_COLOR_DIALOG_UPDATE", NULL },
{ 0, NULL, NULL }
};
static GType type = 0;
if (! type)
type = g_enum_register_static ("GimpColorDialogState", values);
{
type = g_enum_register_static ("GimpColorDialogState", values);
gimp_enum_set_value_descriptions (type, descs);
}
return type;
}
@ -68,17 +101,29 @@ gimp_color_frame_mode_get_type (void)
{
static const GEnumValue values[] =
{
{ GIMP_COLOR_FRAME_MODE_PIXEL, N_("Pixel values"), "pixel" },
{ GIMP_COLOR_FRAME_MODE_RGB, N_("RGB"), "rgb" },
{ GIMP_COLOR_FRAME_MODE_HSV, N_("HSV"), "hsv" },
{ GIMP_COLOR_FRAME_MODE_CMYK, N_("CMYK"), "cmyk" },
{ GIMP_COLOR_FRAME_MODE_PIXEL, "GIMP_COLOR_FRAME_MODE_PIXEL", "pixel" },
{ GIMP_COLOR_FRAME_MODE_RGB, "GIMP_COLOR_FRAME_MODE_RGB", "rgb" },
{ GIMP_COLOR_FRAME_MODE_HSV, "GIMP_COLOR_FRAME_MODE_HSV", "hsv" },
{ GIMP_COLOR_FRAME_MODE_CMYK, "GIMP_COLOR_FRAME_MODE_CMYK", "cmyk" },
{ 0, NULL, NULL }
};
static const GimpEnumDesc descs[] =
{
{ GIMP_COLOR_FRAME_MODE_PIXEL, N_("Pixel values"), NULL },
{ GIMP_COLOR_FRAME_MODE_RGB, N_("RGB"), NULL },
{ GIMP_COLOR_FRAME_MODE_HSV, N_("HSV"), NULL },
{ GIMP_COLOR_FRAME_MODE_CMYK, N_("CMYK"), NULL },
{ 0, NULL, NULL }
};
static GType type = 0;
if (! type)
type = g_enum_register_static ("GimpColorFrameMode", values);
{
type = g_enum_register_static ("GimpColorFrameMode", values);
gimp_enum_set_value_descriptions (type, descs);
}
return type;
}
@ -93,10 +138,20 @@ gimp_color_pick_state_get_type (void)
{ 0, NULL, NULL }
};
static const GimpEnumDesc descs[] =
{
{ GIMP_COLOR_PICK_STATE_NEW, "GIMP_COLOR_PICK_STATE_NEW", NULL },
{ GIMP_COLOR_PICK_STATE_UPDATE, "GIMP_COLOR_PICK_STATE_UPDATE", NULL },
{ 0, NULL, NULL }
};
static GType type = 0;
if (! type)
type = g_enum_register_static ("GimpColorPickState", values);
{
type = g_enum_register_static ("GimpColorPickState", values);
gimp_enum_set_value_descriptions (type, descs);
}
return type;
}
@ -106,15 +161,25 @@ gimp_cursor_format_get_type (void)
{
static const GEnumValue values[] =
{
{ GIMP_CURSOR_FORMAT_BITMAP, N_("Black & white"), "bitmap" },
{ GIMP_CURSOR_FORMAT_PIXBUF, N_("Fancy"), "pixbuf" },
{ GIMP_CURSOR_FORMAT_BITMAP, "GIMP_CURSOR_FORMAT_BITMAP", "bitmap" },
{ GIMP_CURSOR_FORMAT_PIXBUF, "GIMP_CURSOR_FORMAT_PIXBUF", "pixbuf" },
{ 0, NULL, NULL }
};
static const GimpEnumDesc descs[] =
{
{ GIMP_CURSOR_FORMAT_BITMAP, N_("Black & white"), NULL },
{ GIMP_CURSOR_FORMAT_PIXBUF, N_("Fancy"), NULL },
{ 0, NULL, NULL }
};
static GType type = 0;
if (! type)
type = g_enum_register_static ("GimpCursorFormat", values);
{
type = g_enum_register_static ("GimpCursorFormat", values);
gimp_enum_set_value_descriptions (type, descs);
}
return type;
}
@ -124,15 +189,25 @@ gimp_help_browser_type_get_type (void)
{
static const GEnumValue values[] =
{
{ GIMP_HELP_BROWSER_GIMP, N_("GIMP help browser"), "gimp" },
{ GIMP_HELP_BROWSER_WEB_BROWSER, N_("Web browser"), "web-browser" },
{ GIMP_HELP_BROWSER_GIMP, "GIMP_HELP_BROWSER_GIMP", "gimp" },
{ GIMP_HELP_BROWSER_WEB_BROWSER, "GIMP_HELP_BROWSER_WEB_BROWSER", "web-browser" },
{ 0, NULL, NULL }
};
static const GimpEnumDesc descs[] =
{
{ GIMP_HELP_BROWSER_GIMP, N_("GIMP help browser"), NULL },
{ GIMP_HELP_BROWSER_WEB_BROWSER, N_("Web browser"), NULL },
{ 0, NULL, NULL }
};
static GType type = 0;
if (! type)
type = g_enum_register_static ("GimpHelpBrowserType", values);
{
type = g_enum_register_static ("GimpHelpBrowserType", values);
gimp_enum_set_value_descriptions (type, descs);
}
return type;
}
@ -142,15 +217,25 @@ gimp_histogram_scale_get_type (void)
{
static const GEnumValue values[] =
{
{ GIMP_HISTOGRAM_SCALE_LINEAR, N_("Linear"), "linear" },
{ GIMP_HISTOGRAM_SCALE_LOGARITHMIC, N_("Logarithmic"), "logarithmic" },
{ GIMP_HISTOGRAM_SCALE_LINEAR, "GIMP_HISTOGRAM_SCALE_LINEAR", "linear" },
{ GIMP_HISTOGRAM_SCALE_LOGARITHMIC, "GIMP_HISTOGRAM_SCALE_LOGARITHMIC", "logarithmic" },
{ 0, NULL, NULL }
};
static const GimpEnumDesc descs[] =
{
{ GIMP_HISTOGRAM_SCALE_LINEAR, N_("Linear"), NULL },
{ GIMP_HISTOGRAM_SCALE_LOGARITHMIC, N_("Logarithmic"), NULL },
{ 0, NULL, NULL }
};
static GType type = 0;
if (! type)
type = g_enum_register_static ("GimpHistogramScale", values);
{
type = g_enum_register_static ("GimpHistogramScale", values);
gimp_enum_set_value_descriptions (type, descs);
}
return type;
}
@ -160,21 +245,37 @@ gimp_tab_style_get_type (void)
{
static const GEnumValue values[] =
{
{ GIMP_TAB_STYLE_ICON, N_("Icon"), "icon" },
{ GIMP_TAB_STYLE_PREVIEW, N_("Current status"), "preview" },
{ GIMP_TAB_STYLE_NAME, N_("Text"), "name" },
{ GIMP_TAB_STYLE_BLURB, N_("Description"), "blurb" },
{ GIMP_TAB_STYLE_ICON_NAME, N_("Icon & text"), "icon-name" },
{ GIMP_TAB_STYLE_ICON_BLURB, N_("Icon & desc"), "icon-blurb" },
{ GIMP_TAB_STYLE_PREVIEW_NAME, N_("Status & text"), "preview-name" },
{ GIMP_TAB_STYLE_PREVIEW_BLURB, N_("Status & desc"), "preview-blurb" },
{ GIMP_TAB_STYLE_ICON, "GIMP_TAB_STYLE_ICON", "icon" },
{ GIMP_TAB_STYLE_PREVIEW, "GIMP_TAB_STYLE_PREVIEW", "preview" },
{ GIMP_TAB_STYLE_NAME, "GIMP_TAB_STYLE_NAME", "name" },
{ GIMP_TAB_STYLE_BLURB, "GIMP_TAB_STYLE_BLURB", "blurb" },
{ GIMP_TAB_STYLE_ICON_NAME, "GIMP_TAB_STYLE_ICON_NAME", "icon-name" },
{ GIMP_TAB_STYLE_ICON_BLURB, "GIMP_TAB_STYLE_ICON_BLURB", "icon-blurb" },
{ GIMP_TAB_STYLE_PREVIEW_NAME, "GIMP_TAB_STYLE_PREVIEW_NAME", "preview-name" },
{ GIMP_TAB_STYLE_PREVIEW_BLURB, "GIMP_TAB_STYLE_PREVIEW_BLURB", "preview-blurb" },
{ 0, NULL, NULL }
};
static const GimpEnumDesc descs[] =
{
{ GIMP_TAB_STYLE_ICON, N_("Icon"), NULL },
{ GIMP_TAB_STYLE_PREVIEW, N_("Current status"), NULL },
{ GIMP_TAB_STYLE_NAME, N_("Text"), NULL },
{ GIMP_TAB_STYLE_BLURB, N_("Description"), NULL },
{ GIMP_TAB_STYLE_ICON_NAME, N_("Icon & text"), NULL },
{ GIMP_TAB_STYLE_ICON_BLURB, N_("Icon & desc"), NULL },
{ GIMP_TAB_STYLE_PREVIEW_NAME, N_("Status & text"), NULL },
{ GIMP_TAB_STYLE_PREVIEW_BLURB, N_("Status & desc"), NULL },
{ 0, NULL, NULL }
};
static GType type = 0;
if (! type)
type = g_enum_register_static ("GimpTabStyle", values);
{
type = g_enum_register_static ("GimpTabStyle", values);
gimp_enum_set_value_descriptions (type, descs);
}
return type;
}
@ -184,15 +285,25 @@ gimp_view_type_get_type (void)
{
static const GEnumValue values[] =
{
{ GIMP_VIEW_TYPE_LIST, N_("View as list"), "list" },
{ GIMP_VIEW_TYPE_GRID, N_("View as grid"), "grid" },
{ GIMP_VIEW_TYPE_LIST, "GIMP_VIEW_TYPE_LIST", "list" },
{ GIMP_VIEW_TYPE_GRID, "GIMP_VIEW_TYPE_GRID", "grid" },
{ 0, NULL, NULL }
};
static const GimpEnumDesc descs[] =
{
{ GIMP_VIEW_TYPE_LIST, N_("View as list"), NULL },
{ GIMP_VIEW_TYPE_GRID, N_("View as grid"), NULL },
{ 0, NULL, NULL }
};
static GType type = 0;
if (! type)
type = g_enum_register_static ("GimpViewType", values);
{
type = g_enum_register_static ("GimpViewType", values);
gimp_enum_set_value_descriptions (type, descs);
}
return type;
}
@ -202,16 +313,27 @@ gimp_window_hint_get_type (void)
{
static const GEnumValue values[] =
{
{ GIMP_WINDOW_HINT_NORMAL, N_("Normal window"), "normal" },
{ GIMP_WINDOW_HINT_UTILITY, N_("Utility window"), "utility" },
{ GIMP_WINDOW_HINT_KEEP_ABOVE, N_("Keep above"), "keep-above" },
{ GIMP_WINDOW_HINT_NORMAL, "GIMP_WINDOW_HINT_NORMAL", "normal" },
{ GIMP_WINDOW_HINT_UTILITY, "GIMP_WINDOW_HINT_UTILITY", "utility" },
{ GIMP_WINDOW_HINT_KEEP_ABOVE, "GIMP_WINDOW_HINT_KEEP_ABOVE", "keep-above" },
{ 0, NULL, NULL }
};
static const GimpEnumDesc descs[] =
{
{ GIMP_WINDOW_HINT_NORMAL, N_("Normal window"), NULL },
{ GIMP_WINDOW_HINT_UTILITY, N_("Utility window"), NULL },
{ GIMP_WINDOW_HINT_KEEP_ABOVE, N_("Keep above"), NULL },
{ 0, NULL, NULL }
};
static GType type = 0;
if (! type)
type = g_enum_register_static ("GimpWindowHint", values);
{
type = g_enum_register_static ("GimpWindowHint", values);
gimp_enum_set_value_descriptions (type, descs);
}
return type;
}
@ -221,15 +343,25 @@ gimp_zoom_type_get_type (void)
{
static const GEnumValue values[] =
{
{ GIMP_ZOOM_IN, N_("Zoom in"), "in" },
{ GIMP_ZOOM_OUT, N_("Zoom out"), "out" },
{ GIMP_ZOOM_IN, "GIMP_ZOOM_IN", "in" },
{ GIMP_ZOOM_OUT, "GIMP_ZOOM_OUT", "out" },
{ 0, NULL, NULL }
};
static const GimpEnumDesc descs[] =
{
{ GIMP_ZOOM_IN, N_("Zoom in"), NULL },
{ GIMP_ZOOM_OUT, N_("Zoom out"), NULL },
{ 0, NULL, NULL }
};
static GType type = 0;
if (! type)
type = g_enum_register_static ("GimpZoomType", values);
{
type = g_enum_register_static ("GimpZoomType", values);
gimp_enum_set_value_descriptions (type, descs);
}
return type;
}

9
libgimp/Makefile.am
View File

@ -334,11 +334,14 @@ CLEANFILES = $(gen_sources)
$(srcdir)/gimpenums.c: $(srcdir)/gimpenums.h $(GIMP_MKENUMS)
$(GIMP_MKENUMS) \
--fhead "#include \"config.h\"\n#include <glib-object.h>\n#include \"gimpenums.h\"" \
--fhead "#include \"config.h\"\n#include <glib-object.h>\n#include \"libgimpbase/gimpbase.h\"\n#include \"gimpenums.h\"" \
--fprod "\n/* enumerations from \"@filename@\" */" \
--vhead "GType\n@enum_name@_get_type (void)\n{\n static const G@Type@Value values[] =\n {" \
--vprod " { @VALUENAME@, @valuedesc@, \"@valuenick@\" }," \
--vtail " { 0, NULL, NULL }\n };\n\n static GType type = 0;\n\n if (! type)\n type = g_@type@_register_static (\"@EnumName@\", values);\n\n return type;\n}\n" \
--vprod " { @VALUENAME@, \"@VALUENAME@\", \"@valuenick@\" }," \
--vtail " { 0, NULL, NULL }\n };\n" \
--dhead " static const Gimp@Type@Desc descs[] =\n {" \
--dprod " { @VALUENAME@, @valuedesc@, @valuehelp@ }," \
--dtail " { 0, NULL, NULL }\n };\n\n static GType type = 0;\n\n if (! type)\n {\n type = g_@type@_register_static (\"@EnumName@\", values);\n gimp_type_set_translation_domain (type, GETTEXT_PACKAGE \"-libgimp\");\n gimp_@type@_set_value_descriptions (type, descs);\n }\n\n return type;\n}\n" \
$(srcdir)/gimpenums.h > xgen-cec \
&& cp xgen-cec $(@F) \
&& rm -f xgen-cec

7
libgimpbase/Makefile.am
View File

@ -151,8 +151,11 @@ $(srcdir)/gimpbaseenums.c: $(srcdir)/gimpbaseenums.h $(GIMP_MKENUMS)
--fhead "#include \"config.h\"\n#include <glib-object.h>\n#include \"gimpbasetypes.h\"\n#include \"libgimp/libgimp-intl.h\"" \
--fprod "\n/* enumerations from \"@filename@\" */" \
--vhead "GType\n@enum_name@_get_type (void)\n{\n static const G@Type@Value values[] =\n {" \
--vprod " { @VALUENAME@, @valuedesc@, \"@valuenick@\" }," \
--vtail " { 0, NULL, NULL }\n };\n\n static GType type = 0;\n\n if (! type)\n {\n type = g_@type@_register_static (\"@EnumName@\", values);\n gimp_type_set_translation_domain (type, GETTEXT_PACKAGE \"-libgimp\");\n }\n\n return type;\n}\n" \
--vprod " { @VALUENAME@, \"@VALUENAME@\", \"@valuenick@\" }," \
--vtail " { 0, NULL, NULL }\n };\n" \
--dhead " static const Gimp@Type@Desc descs[] =\n {" \
--dprod " { @VALUENAME@, @valuedesc@, @valuehelp@ }," \
--dtail " { 0, NULL, NULL }\n };\n\n static GType type = 0;\n\n if (! type)\n {\n type = g_@type@_register_static (\"@EnumName@\", values);\n gimp_type_set_translation_domain (type, GETTEXT_PACKAGE \"-libgimp\");\n gimp_@type@_set_value_descriptions (type, descs);\n }\n\n return type;\n}\n" \
$(srcdir)/gimpbaseenums.h > xgen-bec \
&& cp xgen-bec $(@F) \
&& rm -f xgen-bec

110
libgimpbase/gimpbaseenums.c
View File

@ -12,19 +12,28 @@ gimp_check_size_get_type (void)
{
static const GEnumValue values[] =
{
{ GIMP_CHECK_SIZE_SMALL_CHECKS, N_("Small"), "small-checks" },
{ GIMP_CHECK_SIZE_MEDIUM_CHECKS, N_("Medium"), "medium-checks" },
{ GIMP_CHECK_SIZE_LARGE_CHECKS, N_("Large"), "large-checks" },
{ GIMP_CHECK_SIZE_SMALL_CHECKS, "GIMP_CHECK_SIZE_SMALL_CHECKS", "small-checks" },
{ GIMP_CHECK_SIZE_MEDIUM_CHECKS, "GIMP_CHECK_SIZE_MEDIUM_CHECKS", "medium-checks" },
{ GIMP_CHECK_SIZE_LARGE_CHECKS, "GIMP_CHECK_SIZE_LARGE_CHECKS", "large-checks" },
{ 0, NULL, NULL }
};
static const GimpEnumDesc descs[] =
{
{ GIMP_CHECK_SIZE_SMALL_CHECKS, N_("Small"), NULL },
{ GIMP_CHECK_SIZE_MEDIUM_CHECKS, N_("Medium"), NULL },
{ GIMP_CHECK_SIZE_LARGE_CHECKS, N_("Large"), NULL },
{ 0, NULL, NULL }
};
static GType type = 0;
if (! type)
{
type = g_enum_register_static ("GimpCheckSize", values);
gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
}
{
type = g_enum_register_static ("GimpCheckSize", values);
gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
gimp_enum_set_value_descriptions (type, descs);
}
return type;
}
@ -34,22 +43,34 @@ gimp_check_type_get_type (void)
{
static const GEnumValue values[] =
{
{ GIMP_CHECK_TYPE_LIGHT_CHECKS, N_("Light Checks"), "light-checks" },
{ GIMP_CHECK_TYPE_GRAY_CHECKS, N_("Mid-Tone Checks"), "gray-checks" },
{ GIMP_CHECK_TYPE_DARK_CHECKS, N_("Dark Checks"), "dark-checks" },
{ GIMP_CHECK_TYPE_WHITE_ONLY, N_("White Only"), "white-only" },
{ GIMP_CHECK_TYPE_GRAY_ONLY, N_("Gray Only"), "gray-only" },
{ GIMP_CHECK_TYPE_BLACK_ONLY, N_("Black Only"), "black-only" },
{ GIMP_CHECK_TYPE_LIGHT_CHECKS, "GIMP_CHECK_TYPE_LIGHT_CHECKS", "light-checks" },
{ GIMP_CHECK_TYPE_GRAY_CHECKS, "GIMP_CHECK_TYPE_GRAY_CHECKS", "gray-checks" },
{ GIMP_CHECK_TYPE_DARK_CHECKS, "GIMP_CHECK_TYPE_DARK_CHECKS", "dark-checks" },
{ GIMP_CHECK_TYPE_WHITE_ONLY, "GIMP_CHECK_TYPE_WHITE_ONLY", "white-only" },
{ GIMP_CHECK_TYPE_GRAY_ONLY, "GIMP_CHECK_TYPE_GRAY_ONLY", "gray-only" },
{ GIMP_CHECK_TYPE_BLACK_ONLY, "GIMP_CHECK_TYPE_BLACK_ONLY", "black-only" },
{ 0, NULL, NULL }
};
static const GimpEnumDesc descs[] =
{
{ GIMP_CHECK_TYPE_LIGHT_CHECKS, N_("Light Checks"), NULL },
{ GIMP_CHECK_TYPE_GRAY_CHECKS, N_("Mid-Tone Checks"), NULL },
{ GIMP_CHECK_TYPE_DARK_CHECKS, N_("Dark Checks"), NULL },
{ GIMP_CHECK_TYPE_WHITE_ONLY, N_("White Only"), NULL },
{ GIMP_CHECK_TYPE_GRAY_ONLY, N_("Gray Only"), NULL },
{ GIMP_CHECK_TYPE_BLACK_ONLY, N_("Black Only"), NULL },
{ 0, NULL, NULL }
};
static GType type = 0;
if (! type)
{
type = g_enum_register_static ("GimpCheckType", values);
gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
}
{
type = g_enum_register_static ("GimpCheckType", values);
gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
gimp_enum_set_value_descriptions (type, descs);
}
return type;
}
@ -59,19 +80,28 @@ gimp_image_base_type_get_type (void)
{
static const GEnumValue values[] =
{
{ GIMP_RGB, N_("RGB color"), "rgb" },
{ GIMP_GRAY, N_("Grayscale"), "gray" },
{ GIMP_INDEXED, N_("Indexed color"), "indexed" },
{ GIMP_RGB, "GIMP_RGB", "rgb" },
{ GIMP_GRAY, "GIMP_GRAY", "gray" },
{ GIMP_INDEXED, "GIMP_INDEXED", "indexed" },
{ 0, NULL, NULL }
};
static const GimpEnumDesc descs[] =
{
{ GIMP_RGB, N_("RGB color"), NULL },
{ GIMP_GRAY, N_("Grayscale"), NULL },
{ GIMP_INDEXED, N_("Indexed color"), NULL },
{ 0, NULL, NULL }
};
static GType type = 0;
if (! type)
{
type = g_enum_register_static ("GimpImageBaseType", values);
gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
}
{
type = g_enum_register_static ("GimpImageBaseType", values);
gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
gimp_enum_set_value_descriptions (type, descs);
}
return type;
}
@ -81,22 +111,34 @@ gimp_image_type_get_type (void)
{
static const GEnumValue values[] =
{
{ GIMP_RGB_IMAGE, N_("RGB"), "rgb-image" },
{ GIMP_RGBA_IMAGE, N_("RGB-alpha"), "rgba-image" },
{ GIMP_GRAY_IMAGE, N_("Grayscale"), "gray-image" },
{ GIMP_GRAYA_IMAGE, N_("Grayscale-alpha"), "graya-image" },
{ GIMP_INDEXED_IMAGE, N_("Indexed"), "indexed-image" },
{ GIMP_INDEXEDA_IMAGE, N_("Indexed-alpha"), "indexeda-image" },
{ GIMP_RGB_IMAGE, "GIMP_RGB_IMAGE", "rgb-image" },
{ GIMP_RGBA_IMAGE, "GIMP_RGBA_IMAGE", "rgba-image" },
{ GIMP_GRAY_IMAGE, "GIMP_GRAY_IMAGE", "gray-image" },
{ GIMP_GRAYA_IMAGE, "GIMP_GRAYA_IMAGE", "graya-image" },
{ GIMP_INDEXED_IMAGE, "GIMP_INDEXED_IMAGE", "indexed-image" },
{ GIMP_INDEXEDA_IMAGE, "GIMP_INDEXEDA_IMAGE", "indexeda-image" },
{ 0, NULL, NULL }
};
static const GimpEnumDesc descs[] =
{
{ GIMP_RGB_IMAGE, N_("RGB"), NULL },
{ GIMP_RGBA_IMAGE, N_("RGB-alpha"), NULL },
{ GIMP_GRAY_IMAGE, N_("Grayscale"), NULL },
{ GIMP_GRAYA_IMAGE, N_("Grayscale-alpha"), NULL },
{ GIMP_INDEXED_IMAGE, N_("Indexed"), NULL },
{ GIMP_INDEXEDA_IMAGE, N_("Indexed-alpha"), NULL },
{ 0, NULL, NULL }
};
static GType type = 0;
if (! type)
{
type = g_enum_register_static ("GimpImageType", values);
gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
}
{
type = g_enum_register_static ("GimpImageType", values);
gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
gimp_enum_set_value_descriptions (type, descs);
}
return type;
}

99
libgimpbase/gimpbasetypes.c
View File

@ -28,6 +28,7 @@
static GQuark gimp_translation_domain_quark (void) G_GNUC_CONST;
static GQuark gimp_value_descriptions_quark (void) G_GNUC_CONST;
/**
@ -71,6 +72,93 @@ gimp_type_get_translation_domain (GType type)
gimp_translation_domain_quark ());
}
/**
* gimp_enum_set_value_descriptions:
* @enum_type: a #GType
* @descriptions: a %NULL terminated constant static array of #GimpEnumDesc
*
* Sets the array of human readable and translatable descriptions
* and help texts for enum values.
*
* Since: GIMP 2.2
**/
void
gimp_enum_set_value_descriptions (GType enum_type,
const GimpEnumDesc *descriptions)
{
g_return_if_fail (g_type_is_a (enum_type, G_TYPE_ENUM));
g_return_if_fail (descriptions != NULL);
g_type_set_qdata (enum_type,
gimp_value_descriptions_quark (),
(gpointer) descriptions);
}
/**
* gimp_enum_get_value_descriptions:
* @enum_type: a #GType
*
* Retreives the array of human readable and translatable descriptions
* and help texts for enum values.
*
* Returns: a %NULL terminated constant array of #GimpEnumDesc
*
* Since: GIMP 2.2
**/
const GimpEnumDesc *
gimp_enum_get_value_descriptions (GType enum_type)
{
g_return_val_if_fail (g_type_is_a (enum_type, G_TYPE_ENUM), NULL);
return (const GimpEnumDesc *)
g_type_get_qdata (enum_type, gimp_value_descriptions_quark ());
}
/**
* gimp_flags_set_value_descriptions:
* @flags_type: a #GType
* @descriptions: a %NULL terminated constant static array of #GimpFlagsDesc
*
* Sets the array of human readable and translatable descriptions
* and help texts for flags values.
*
* Since: GIMP 2.2
**/
void
gimp_flags_set_value_descriptions (GType flags_type,
const GimpFlagsDesc *descriptions)
{
g_return_if_fail (g_type_is_a (flags_type, G_TYPE_FLAGS));
g_return_if_fail (descriptions != NULL);
g_type_set_qdata (flags_type,
gimp_value_descriptions_quark (),
(gpointer) descriptions);
}
/**
* gimp_flags_get_value_descriptions:
* @flags_type: a #GType
*
* Retreives the array of human readable and translatable descriptions
* and help texts for flags values.
*
* Returns: a %NULL terminated constant array of #GimpFlagsDesc
*
* Since: GIMP 2.2
**/
const GimpFlagsDesc *
gimp_flags_get_value_descriptions (GType flags_type)
{
g_return_val_if_fail (g_type_is_a (flags_type, G_TYPE_FLAGS), NULL);
return (const GimpFlagsDesc *)
g_type_get_qdata (flags_type, gimp_value_descriptions_quark ());
}
/* private functions */
static GQuark
gimp_translation_domain_quark (void)
{
@ -81,3 +169,14 @@ gimp_translation_domain_quark (void)
return quark;
}
static GQuark
gimp_value_descriptions_quark (void)
{
static GQuark quark = 0;
if (! quark)
quark = g_quark_from_static_string ("gimp-value-descriptions-quark");
return quark;
}

31
libgimpbase/gimpbasetypes.h
View File

@ -33,15 +33,40 @@ G_BEGIN_DECLS
typedef struct _GimpParasite GimpParasite;
typedef struct _GimpDatafileData GimpDatafileData;
typedef struct _GimpEnumDesc GimpEnumDesc;
typedef struct _GimpFlagsDesc GimpFlagsDesc;
typedef void (* GimpDatafileLoaderFunc) (const GimpDatafileData *file_data,
gpointer user_data);
void gimp_type_set_translation_domain (GType type,
const gchar *domain);
const gchar * gimp_type_get_translation_domain (GType type);
struct _GimpEnumDesc
{
gint value;
gchar *value_desc;
gchar *value_help;
};
struct _GimpFlagsDesc
{
guint value;
gchar *value_desc;
gchar *value_help;
};
void gimp_type_set_translation_domain (GType type,
const gchar *domain);
const gchar * gimp_type_get_translation_domain (GType type);
void gimp_enum_set_value_descriptions (GType enum_type,
const GimpEnumDesc *descriptions);
const GimpEnumDesc * gimp_enum_get_value_descriptions (GType enum_type);
void gimp_flags_set_value_descriptions (GType flags_type,
const GimpFlagsDesc *descriptions);
const GimpFlagsDesc * gimp_flags_get_value_descriptions (GType flags_type);
G_END_DECLS

252
libgimpbase/gimputils.c
View File

@ -302,17 +302,67 @@ gimp_escape_uline (const gchar *str)
return escaped;
}
GimpEnumDesc *
gimp_enum_get_desc (GEnumClass *enum_class,
gint value)
{
const GimpEnumDesc *value_desc;
g_return_val_if_fail (G_IS_ENUM_CLASS (enum_class), NULL);
value_desc = gimp_enum_get_value_descriptions (G_TYPE_FROM_CLASS (enum_class));
if (value_desc)
{
while (value_desc->value_desc)
{
if (value_desc->value == value)
return (GimpEnumDesc *) value_desc;
value_desc++;
}
}
return NULL;
}
GimpFlagsDesc *
gimp_flags_get_first_desc (GFlagsClass *flags_class,
guint value)
{
const GimpFlagsDesc *value_desc;
g_return_val_if_fail (G_IS_FLAGS_CLASS (flags_class), NULL);
value_desc = gimp_flags_get_value_descriptions (G_TYPE_FROM_CLASS (flags_class));
if (value_desc)
{
while (value_desc->value_desc)
{
if ((value_desc->value & value) == value_desc->value)
return (GimpFlagsDesc *) value_desc;
value_desc++;
}
}
return NULL;
}
/**
* gimp_enum_get_value:
* @enum_type: the #GType of a registered enum
* @value: an integer value
* @value_name: return location for the value's name (or %NULL)
* @value_nick: return location for the value's nick (or %NULL)
* @value_name: return location for the value's translated name (or %NULL)
* @value_desc: return location for the value's translated desc (or %NULL)
* @value_help: return location for the value's translated help (or %NULL)
*
* Checks if @value is valid for the enum registered as @enum_type.
* If the value exists in that enum, its nick and its translated name
* are returned (if @value_nick and @value_name are not %NULL).
* If the value exists in that enum, its name, nick and its translated
* desc and help are returned (if @value_name, @value_nick, @value_desc
* and @value_help are not %NULL).
*
* Return value: %TRUE if @value is valid for the @enum_type,
* %FALSE otherwise
@ -322,8 +372,10 @@ gimp_escape_uline (const gchar *str)
gboolean
gimp_enum_get_value (GType enum_type,
gint value,
const gchar **value_name,
const gchar **value_nick,
const gchar **value_name)
const gchar **value_desc,
const gchar **value_help)
{
GEnumClass *enum_class;
GEnumValue *enum_value;
@ -335,14 +387,30 @@ gimp_enum_get_value (GType enum_type,
if (enum_value)
{
if (value_name)
*value_name = enum_value->value_name;
if (value_nick)
*value_nick = enum_value->value_nick;
if (value_name)
*value_name = (enum_value->value_name ?
dgettext (gimp_type_get_translation_domain (enum_type),
enum_value->value_name) :
NULL);
if (value_desc || value_help)
{
GimpEnumDesc *enum_desc;
enum_desc = gimp_enum_get_desc (enum_class, value);
if (value_desc)
*value_desc = ((enum_desc && enum_desc->value_desc) ?
dgettext (gimp_type_get_translation_domain (enum_type),
enum_desc->value_desc) :
NULL);
if (value_help)
*value_help = ((enum_desc && enum_desc->value_desc) ?
dgettext (gimp_type_get_translation_domain (enum_type),
enum_desc->value_help) :
NULL);
}
return TRUE;
}
@ -351,25 +419,177 @@ gimp_enum_get_value (GType enum_type,
}
/**
* gimp_enum_value_get_name:
* gimp_flags_get_value:
* @flags_type: the #GType of registered flags
* @value: an integer value
* @value_name: return location for the value's name (or %NULL)
* @value_nick: return location for the value's nick (or %NULL)
* @value_desc: return location for the value's translated desc (or %NULL)
* @value_help: return location for the value's translated help (or %NULL)
*
* Checks if @value is valid for the flags registered as @flags_type.
* If the value exists in that flags, its name, nick and its translated
* desc and help are returned (if @value_name, @value_nick, @value_desc
* and @value_help are not %NULL).
*
* Return value: %TRUE if @value is valid for the @flags_type,
* %FALSE otherwise
*
* Since: GIMP 2.2
**/
gboolean
gimp_flags_get_value (GType flags_type,
guint value,
const gchar **value_name,
const gchar **value_nick,
const gchar **value_desc,
const gchar **value_help)
{
GFlagsClass *flags_class;
GFlagsValue *flags_value;
g_return_val_if_fail (G_TYPE_IS_FLAGS (flags_type), FALSE);
flags_class = g_type_class_peek (flags_type);
flags_value = g_flags_get_first_value (flags_class, value);
if (flags_value)
{
if (value_name)
*value_name = flags_value->value_name;
if (value_nick)
*value_nick = flags_value->value_nick;
if (value_desc || value_help)
{
GimpFlagsDesc *flags_desc;
flags_desc = gimp_flags_get_first_desc (flags_class, value);
if (value_desc)
*value_desc = ((flags_desc && flags_desc->value_desc) ?
dgettext (gimp_type_get_translation_domain (flags_type),
flags_desc->value_desc) :
NULL);
if (value_help)
*value_help = ((flags_desc && flags_desc->value_desc) ?
dgettext (gimp_type_get_translation_domain (flags_type),
flags_desc->value_help) :
NULL);
}
return TRUE;
}
return FALSE;
}
/**
* gimp_enum_value_get_desc:
* @enum_class: a #GEnumClass
* @enum_value: a #GEnumValue from @enum_class
*
* Retrieves the translated name for a given @enum_value.
* Retrieves the translated desc for a given @enum_value.
*
* Return value: the translated name of the enum value
* Return value: the translated desc of the enum value
*
* Since: GIMP 2.2
**/
const gchar *
gimp_enum_value_get_name (GEnumClass *enum_class,
gimp_enum_value_get_desc (GEnumClass *enum_class,
GEnumValue *enum_value)
{
GType type = G_TYPE_FROM_CLASS (enum_class);
GType type = G_TYPE_FROM_CLASS (enum_class);
GimpEnumDesc *enum_desc;
if (enum_value->value_name)
enum_desc = gimp_enum_get_desc (enum_class, enum_value->value);
if (enum_desc->value_desc)
return dgettext (gimp_type_get_translation_domain (type),
enum_value->value_name);
enum_desc->value_desc);
return enum_value->value_name;
}
/**
* gimp_enum_value_get_help:
* @enum_class: a #GEnumClass
* @enum_value: a #GEnumValue from @enum_class
*
* Retrieves the translated help for a given @enum_value.
*
* Return value: the translated help of the enum value
*
* Since: GIMP 2.2
**/
const gchar *
gimp_enum_value_get_help (GEnumClass *enum_class,
GEnumValue *enum_value)
{
GType type = G_TYPE_FROM_CLASS (enum_class);
GimpEnumDesc *enum_desc;
enum_desc = gimp_enum_get_desc (enum_class, enum_value->value);
if (enum_desc->value_help)
return dgettext (gimp_type_get_translation_domain (type),
enum_desc->value_help);
return NULL;
}
/**
* gimp_flags_value_get_desc:
* @flags_class: a #GFlagsClass
* @flags_value: a #GFlagsValue from @flags_class
*
* Retrieves the translated desc for a given @flags_value.
*
* Return value: the translated desc of the flags value
*
* Since: GIMP 2.2
**/
const gchar *
gimp_flags_value_get_desc (GFlagsClass *flags_class,
GFlagsValue *flags_value)
{
GType type = G_TYPE_FROM_CLASS (flags_class);
GimpFlagsDesc *flags_desc;
flags_desc = gimp_flags_get_first_desc (flags_class, flags_value->value);
if (flags_desc->value_desc)
return dgettext (gimp_type_get_translation_domain (type),
flags_desc->value_desc);
return flags_value->value_name;
}
/**
* gimp_flags_value_get_help:
* @flags_class: a #GFlagsClass
* @flags_value: a #GFlagsValue from @flags_class
*
* Retrieves the translated help for a given @flags_value.
*
* Return value: the translated help of the flags value
*
* Since: GIMP 2.2
**/
const gchar *
gimp_flags_value_get_help (GFlagsClass *flags_class,
GFlagsValue *flags_value)
{
GType type = G_TYPE_FROM_CLASS (flags_class);
GimpFlagsDesc *flags_desc;
flags_desc = gimp_flags_get_first_desc (flags_class, flags_value->value);
if (flags_desc->value_help)
return dgettext (gimp_type_get_translation_domain (type),
flags_desc->value_help);
return NULL;
}

51
libgimpbase/gimputils.h
View File

@ -21,23 +21,44 @@
#define __GIMP_UTILS_H__
gchar * gimp_utf8_strtrim (const gchar *str,
gint max_chars);
gchar * gimp_any_to_utf8 (const gchar *str,
gssize len,
const gchar *warning_format,
...) G_GNUC_PRINTF (3, 4);
const gchar * gimp_filename_to_utf8 (const gchar *filename);
gchar * gimp_utf8_strtrim (const gchar *str,
gint max_chars);
gchar * gimp_any_to_utf8 (const gchar *str,
gssize len,
const gchar *warning_format,
...) G_GNUC_PRINTF (3, 4);
const gchar * gimp_filename_to_utf8 (const gchar *filename);
gchar * gimp_strip_uline (const gchar *str);
gchar * gimp_escape_uline (const gchar *str);
gchar * gimp_strip_uline (const gchar *str);
gchar * gimp_escape_uline (const gchar *str);
gboolean gimp_enum_get_value (GType enum_type,
gint value,
const gchar **value_nick,
const gchar **value_name);
const gchar * gimp_enum_value_get_name (GEnumClass *enum_class,
GEnumValue *enum_value);
GimpEnumDesc * gimp_enum_get_desc (GEnumClass *enum_class,
gint value);
GimpFlagsDesc * gimp_flags_get_first_desc (GFlagsClass *flags_class,
guint value);
gboolean gimp_enum_get_value (GType enum_type,
gint value,
const gchar **value_name,
const gchar **value_nick,
const gchar **value_desc,
const gchar **value_help);
gboolean gimp_flags_get_value (GType flags_type,
guint value,
const gchar **value_name,
const gchar **value_nick,
const gchar **value_desc,
const gchar **value_help);
const gchar * gimp_enum_value_get_desc (GEnumClass *enum_class,
GEnumValue *enum_value);
const gchar * gimp_enum_value_get_help (GEnumClass *enum_class,
GEnumValue *enum_value);
const gchar * gimp_flags_value_get_desc (GFlagsClass *flags_class,
GFlagsValue *flags_value);
const gchar * gimp_flags_value_get_help (GFlagsClass *flags_class,
GFlagsValue *flags_value);
#endif /* __GIMP_UTILS_H__ */

6
libgimpwidgets/gimpenumstore.c
View File

@ -96,14 +96,14 @@ gimp_enum_store_add_value (GtkListStore *store,
GEnumValue *value)
{
GtkTreeIter iter;
const gchar *name;
const gchar *desc;
name = gimp_enum_value_get_name (GIMP_ENUM_STORE (store)->enum_class, value);
desc = gimp_enum_value_get_desc (GIMP_ENUM_STORE (store)->enum_class, value);
gtk_list_store_append (store, &iter);
gtk_list_store_set (store, &iter,
GIMP_INT_STORE_VALUE, value->value,
GIMP_INT_STORE_LABEL, name,
GIMP_INT_STORE_LABEL, desc,
-1);
}

8
libgimpwidgets/gimpenumwidgets.c
View File

@ -95,14 +95,14 @@ gimp_enum_radio_box_new_with_range (GType enum_type,
for (value = enum_class->values; value->value_name; value++)
{
const gchar *name;
const gchar *desc;
if (value->value < minimum || value->value > maximum)
continue;
name = gimp_enum_value_get_name (enum_class, value);
desc = gimp_enum_value_get_desc (enum_class, value);
button = gtk_radio_button_new_with_mnemonic (group, name);
button = gtk_radio_button_new_with_mnemonic (group, desc);
if (first_button && *first_button == NULL)
*first_button = button;
@ -303,7 +303,7 @@ gimp_enum_stock_box_new_with_range (GType enum_type,
}
gimp_help_set_help_data (button,
gimp_enum_value_get_name (enum_class, value),
gimp_enum_value_get_desc (enum_class, value),
NULL);
group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (button));

2
libgimpwidgets/gimppreviewarea.c
View File

@ -1741,7 +1741,7 @@ gimp_preview_area_menu_new (GimpPreviewArea *area,
for (enum_value = enum_class->values; enum_value->value_name; enum_value++)
{
const gchar *name = gimp_enum_value_get_name (enum_class, enum_value);
const gchar *name = gimp_enum_value_get_desc (enum_class, enum_value);
item = gtk_radio_menu_item_new_with_label (group, name);

77
tools/gimp-mkenums
View File

@ -109,7 +109,7 @@ sub parse_entries {
if (defined $options) {
my %options = parse_trigraph($options);
if (!defined $options{"skip"}) {
push @entries, [ $name, $options{nick}, $options{desc} ];
push @entries, [ $name, $options{nick}, $options{desc}, $options{help} ];
}
} else {
push @entries, [ $name ];
@ -141,6 +141,9 @@ sub usage {
print STDERR " --vhead <text> value header, produced before iterating over enum values\n";
print STDERR " --vprod <text> value text, produced for each enum value\n";
print STDERR " --vtail <text> value tail, produced after iterating over enum values\n";
print STDERR " --dhead <text> description header, produced before iterating over enum value descriptions\n";
print STDERR " --dprod <text> description text, produced for each enum value description\n";
print STDERR " --dtail <text> description tail, produced after iterating over enum value descriptions\n";
print STDERR " --comments <text> comment structure\n";
print STDERR " -h, --help show this help message\n";
print STDERR " -v, --version print version informations\n";
@ -152,6 +155,7 @@ sub usage {
print STDERR " \@VALUENAME\@ PREFIX_THE_XVALUE\n";
print STDERR " \@valuenick\@ the-xvalue\n";
print STDERR " \@valuedesc\@ descriptions as defined in the header\n";
print STDERR " \@valuehelp\@ help texts as defined in the header\n";
print STDERR " \@type\@ either enum or flags\n";
print STDERR " \@Type\@ either Enum or Flags\n";
print STDERR " \@TYPE\@ either ENUM or FLAGS\n";
@ -167,6 +171,9 @@ my $eprod = ""; # per enum text (produced prior to value itarations)
my $vhead = ""; # value header, produced before iterating over enum values
my $vprod = ""; # value text, produced for each enum value
my $vtail = ""; # value tail, produced after iterating over enum values
my $dhead = ""; # desc header, produced before iterating over enum values
my $dprod = ""; # desc text, produced for each enum value
my $dtail = ""; # desc tail, produced after iterating over enum values
# other options
my $comment_tmpl = "/* \@comment\@ */";
@ -183,6 +190,9 @@ while ($_ = $ARGV[0], /^-/) {
elsif (/^--vhead$/) { $vhead = $vhead . shift }
elsif (/^--vprod$/) { $vprod = $vprod . shift }
elsif (/^--vtail$/) { $vtail = $vtail . shift }
elsif (/^--dhead$/) { $dhead = $dhead . shift }
elsif (/^--dprod$/) { $dprod = $dprod . shift }
elsif (/^--dtail$/) { $dtail = $dtail . shift }
elsif (/^--comments$/) { $comment_tmpl = shift }
elsif (/^--help$/ || /^-h$/) { usage; }
elsif (/^--version$/ || /^-v$/) { version; }
@ -289,7 +299,7 @@ while (<>) {
}
for $entry (@entries) {
my ($name,$nick,$desc) = @{$entry};
my ($name,$nick,$desc,$help) = @{$entry};
if (!defined $nick) {
($nick = $name) =~ s/^$enum_prefix//;
$nick =~ tr/_/-/;
@ -300,7 +310,12 @@ while (<>) {
} else {
$desc = "N_($desc)";
}
@{$entry} = ($name, $nick, $desc);
if (!defined $help) {
$help = "NULL";
} else {
$help = "N_($help)";
}
@{$entry} = ($name, $nick, $desc, $help);
}
@ -376,12 +391,13 @@ while (<>) {
$prod =~ s/\\a/\a/g; $prod =~ s/\\b/\b/g; $prod =~ s/\\t/\t/g; $prod =~ s/\\n/\n/g;
$prod =~ s/\\f/\f/g; $prod =~ s/\\r/\r/g;
for (@entries) {
my ($name,$nick,$desc) = @{$_};
my ($name,$nick,$desc,$help) = @{$_};
my $tmp_prod = $prod;
$tmp_prod =~ s/\@VALUENAME\@/$name/g;
$tmp_prod =~ s/\@valuenick\@/$nick/g;
$tmp_prod =~ s/\@valuedesc\@/$desc/g;
$tmp_prod =~ s/\@valuehelp\@/$help/g;
if ($flags) { $tmp_prod =~ s/\@type\@/flags/g; } else { $tmp_prod =~ s/\@type\@/enum/g; }
if ($flags) { $tmp_prod =~ s/\@Type\@/Flags/g; } else { $tmp_prod =~ s/\@Type\@/Enum/g; }
if ($flags) { $tmp_prod =~ s/\@TYPE\@/FLAGS/g; } else { $tmp_prod =~ s/\@TYPE\@/ENUM/g; }
@ -405,6 +421,59 @@ while (<>) {
print "$prod\n";
}
if (length($dhead)) {
my $prod = $dhead;
$prod =~ s/\@enum_name\@/$enumsym/g;
$prod =~ s/\@EnumName\@/$enumname/g;
$prod =~ s/\@ENUMSHORT\@/$enumshort/g;
$prod =~ s/\@ENUMNAME\@/$enumlong/g;
if ($flags) { $prod =~ s/\@type\@/flags/g; } else { $prod =~ s/\@type\@/enum/g; }
if ($flags) { $prod =~ s/\@Type\@/Flags/g; } else { $prod =~ s/\@Type\@/Enum/g; }
if ($flags) { $prod =~ s/\@TYPE\@/FLAGS/g; } else { $prod =~ s/\@TYPE\@/ENUM/g; }
$prod =~ s/\\a/\a/g; $prod =~ s/\\b/\b/g; $prod =~ s/\\t/\t/g; $prod =~ s/\\n/\n/g;
$prod =~ s/\\f/\f/g; $prod =~ s/\\r/\r/g;
print "$prod\n";
}
if (length($dprod)) {
my $prod = $dprod;
$prod =~ s/\\a/\a/g; $prod =~ s/\\b/\b/g; $prod =~ s/\\t/\t/g; $prod =~ s/\\n/\n/g;
$prod =~ s/\\f/\f/g; $prod =~ s/\\r/\r/g;
for (@entries) {
my ($name,$nick,$desc,$help) = @{$_};
my $tmp_prod = $prod;
$tmp_prod =~ s/\@VALUENAME\@/$name/g;
$tmp_prod =~ s/\@valuenick\@/$nick/g;
$tmp_prod =~ s/\@valuedesc\@/$desc/g;
$tmp_prod =~ s/\@valuehelp\@/$help/g;
if ($flags) { $tmp_prod =~ s/\@type\@/flags/g; } else { $tmp_prod =~ s/\@type\@/enum/g; }
if ($flags) { $tmp_prod =~ s/\@Type\@/Flags/g; } else { $tmp_prod =~ s/\@Type\@/Enum/g; }
if ($flags) { $tmp_prod =~ s/\@TYPE\@/FLAGS/g; } else { $tmp_prod =~ s/\@TYPE\@/ENUM/g; }
print "$tmp_prod\n";
}
}
if (length($dtail)) {
my $prod = $dtail;
$prod =~ s/\@enum_name\@/$enumsym/g;
$prod =~ s/\@EnumName\@/$enumname/g;
$prod =~ s/\@ENUMSHORT\@/$enumshort/g;
$prod =~ s/\@ENUMNAME\@/$enumlong/g;
if ($flags) { $prod =~ s/\@type\@/flags/g; } else { $prod =~ s/\@type\@/enum/g; }
if ($flags) { $prod =~ s/\@Type\@/Flags/g; } else { $prod =~ s/\@Type\@/Enum/g; }
if ($flags) { $prod =~ s/\@TYPE\@/FLAGS/g; } else { $prod =~ s/\@TYPE\@/ENUM/g; }
$prod =~ s/\\a/\a/g; $prod =~ s/\\b/\b/g; $prod =~ s/\\t/\t/g; $prod =~ s/\\n/\n/g;
$prod =~ s/\\f/\f/g; $prod =~ s/\\r/\r/g;
print "$prod\n";
}
}
}