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

app: move stuff from GimpOperationTool to GimpImageMapTool 

Add new string members to GimpImageMapTool and use them instead of the
resp. fields of GimpToolInfo. Change ::get_operation() to return the
operation name and a lot of strings for the UI, and create both the
GeglNode and the config object in GimpOperationTool. Lots of various
cleanups in GimpImageMapTool subclasses. This is an intermediate state
on the way of making the whole filter applying mechanism more generic
and less depending on subclasses.
This commit is contained in:
Michael Natterer 2016-01-22 21:22:36 +01:00
parent b72d73377a
commit 8c09210d7d
19 changed files with 690 additions and 536 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
app/actions/gimpgeglprocedure.c
View File

@ -323,6 +323,7 @@ gimp_gegl_procedure_execute_async (GimpProcedure *procedure,
procedure->original_name,
gimp_procedure_get_label (procedure),
gimp_procedure_get_label (procedure),
gimp_procedure_get_label (procedure),
gimp_viewable_get_icon_name (GIMP_VIEWABLE (procedure)),
gimp_procedure_get_help_id (procedure));

49
app/tools/gimpbrightnesscontrasttool.c
View File

@ -71,10 +71,13 @@ static void gimp_brightness_contrast_tool_motion (GimpTool
GdkModifierType state,
GimpDisplay *display);
static GeglNode *
static gchar *
gimp_brightness_contrast_tool_get_operation (GimpImageMapTool *image_map_tool,
GObject **config,
gchar **undo_desc);
gchar **title,
gchar **description,
gchar **undo_desc,
gchar **icon_name,
gchar **help_id);
static void gimp_brightness_contrast_tool_dialog (GimpImageMapTool *image_map_tool);
static void brightness_contrast_to_levels_callback (GtkWidget *widget,
@ -114,7 +117,6 @@ gimp_brightness_contrast_tool_class_init (GimpBrightnessContrastToolClass *klass
tool_class->button_release = gimp_brightness_contrast_tool_button_release;
tool_class->motion = gimp_brightness_contrast_tool_motion;
im_tool_class->dialog_desc = _("Adjust Brightness and Contrast");
im_tool_class->settings_name = "brightness-contrast";
im_tool_class->import_dialog_title = _("Import Brightness-Contrast settings");
im_tool_class->export_dialog_title = _("Export Brightness-Contrast settings");
@ -160,21 +162,17 @@ gimp_brightness_contrast_tool_initialize (GimpTool *tool,
return TRUE;
}
static GeglNode *
static gchar *
gimp_brightness_contrast_tool_get_operation (GimpImageMapTool *im_tool,
GObject **config,
gchar **undo_desc)
gchar **title,
gchar **description,
gchar **undo_desc,
gchar **icon_name,
gchar **help_id)
{
GimpBrightnessContrastTool *bc_tool = GIMP_BRIGHTNESS_CONTRAST_TOOL (im_tool);
*description = g_strdup (_("Adjust Brightness and Contrast"));
bc_tool->config = g_object_new (GIMP_TYPE_BRIGHTNESS_CONTRAST_CONFIG, NULL);
*config = G_OBJECT (bc_tool->config);
return gegl_node_new_child (NULL,
"operation", "gimp:brightness-contrast",
"config", bc_tool->config,
NULL);
return g_strdup ("gimp:brightness-contrast");
}
static void
@ -186,11 +184,18 @@ gimp_brightness_contrast_tool_button_press (GimpTool *tool,
GimpDisplay *display)
{
GimpBrightnessContrastTool *bc_tool = GIMP_BRIGHTNESS_CONTRAST_TOOL (tool);
gdouble brightness;
gdouble contrast;
bc_tool->x = coords->x - bc_tool->config->contrast * 127.0;
bc_tool->y = coords->y + bc_tool->config->brightness * 127.0;
bc_tool->dx = bc_tool->config->contrast * 127.0;
bc_tool->dy = - bc_tool->config->brightness * 127.0;
g_object_get (GIMP_IMAGE_MAP_TOOL (tool)->config,
"brightness", &brightness,
"contrast", &contrast,
NULL);
bc_tool->x = coords->x - contrast * 127.0;
bc_tool->y = coords->y + brightness * 127.0;
bc_tool->dx = contrast * 127.0;
bc_tool->dy = - brightness * 127.0;
gimp_tool_control_activate (tool->control);
tool->display = display;
@ -212,7 +217,7 @@ gimp_brightness_contrast_tool_button_release (GimpTool *tool,
return;
if (release_type == GIMP_BUTTON_RELEASE_CANCEL)
gimp_config_reset (GIMP_CONFIG (bc_tool->config));
gimp_config_reset (GIMP_CONFIG (GIMP_IMAGE_MAP_TOOL (tool)->config));
}
static void
@ -227,7 +232,7 @@ gimp_brightness_contrast_tool_motion (GimpTool *tool,
bc_tool->dx = (coords->x - bc_tool->x);
bc_tool->dy = - (coords->y - bc_tool->y);
g_object_set (bc_tool->config,
g_object_set (GIMP_IMAGE_MAP_TOOL (tool)->config,
"brightness", CLAMP (bc_tool->dy, -127.0, 127.0) / 127.0,
"contrast", CLAMP (bc_tool->dx, -127.0, 127.0) / 127.0,
NULL);

12
app/tools/gimpbrightnesscontrasttool.h
View File

@ -35,16 +35,14 @@ typedef struct _GimpBrightnessContrastToolClass GimpBrightnessContrastToolClass;
struct _GimpBrightnessContrastTool
{
GimpImageMapTool parent_instance;
GimpImageMapTool parent_instance;
GimpBrightnessContrastConfig *config;
gdouble x, y;
gdouble dx, dy;
gdouble x, y;
gdouble dx, dy;
/* dialog */
GtkWidget *brightness_scale;
GtkWidget *contrast_scale;
GtkWidget *brightness_scale;
GtkWidget *contrast_scale;
};
struct _GimpBrightnessContrastToolClass

49
app/tools/gimpcolorbalancetool.c
View File

@ -51,14 +51,17 @@ static gboolean gimp_color_balance_tool_initialize (GimpTool *tool,
GimpDisplay *display,
GError **error);
static GeglNode * gimp_color_balance_tool_get_operation (GimpImageMapTool *im_tool,
GObject **config,
gchar **undo_desc);
static gchar * gimp_color_balance_tool_get_operation (GimpImageMapTool *im_tool,
gchar **title,
gchar **description,
gchar **undo_desc,
gchar **icon_name,
gchar **help_id);
static void gimp_color_balance_tool_dialog (GimpImageMapTool *im_tool);
static void gimp_color_balance_tool_reset (GimpImageMapTool *im_tool);
static void color_balance_range_reset_callback (GtkWidget *widget,
GimpColorBalanceTool *cb_tool);
static void color_balance_range_reset_callback (GtkWidget *widget,
GimpImageMapTool *im_tool);
G_DEFINE_TYPE (GimpColorBalanceTool, gimp_color_balance_tool,
@ -91,7 +94,6 @@ gimp_color_balance_tool_class_init (GimpColorBalanceToolClass *klass)
tool_class->initialize = gimp_color_balance_tool_initialize;
im_tool_class->dialog_desc = _("Adjust Color Balance");
im_tool_class->settings_name = "color-balance";
im_tool_class->import_dialog_title = _("Import Color Balance Settings");
im_tool_class->export_dialog_title = _("Export Color Balance Settings");
@ -127,21 +129,17 @@ gimp_color_balance_tool_initialize (GimpTool *tool,
return GIMP_TOOL_CLASS (parent_class)->initialize (tool, display, error);
}
static GeglNode *
static gchar *
gimp_color_balance_tool_get_operation (GimpImageMapTool *im_tool,
GObject **config,
gchar **undo_desc)
gchar **title,
gchar **description,
gchar **undo_desc,
gchar **icon_name,
gchar **help_id)
{
GimpColorBalanceTool *cb_tool = GIMP_COLOR_BALANCE_TOOL (im_tool);
*description = g_strdup (_("Adjust Color Balance"));
cb_tool->config = g_object_new (GIMP_TYPE_COLOR_BALANCE_CONFIG, NULL);
*config = G_OBJECT (cb_tool->config);
return gegl_node_new_child (NULL,
"operation", "gimp:color-balance",
"config", cb_tool->config,
NULL);
return g_strdup ("gimp:color-balance");
}
@ -248,19 +246,22 @@ gimp_color_balance_tool_dialog (GimpImageMapTool *image_map_tool)
static void
gimp_color_balance_tool_reset (GimpImageMapTool *im_tool)
{
GimpColorBalanceTool *cb_tool = GIMP_COLOR_BALANCE_TOOL (im_tool);
GimpTransferMode range = cb_tool->config->range;
GimpTransferMode range;
g_object_get (im_tool->config,
"range", &range,
NULL);
GIMP_IMAGE_MAP_TOOL_CLASS (parent_class)->reset (im_tool);
g_object_set (cb_tool->config,
g_object_set (im_tool->config,
"range", range,
NULL);
}
static void
color_balance_range_reset_callback (GtkWidget *widget,
GimpColorBalanceTool *cb_tool)
color_balance_range_reset_callback (GtkWidget *widget,
GimpImageMapTool *im_tool)
{
gimp_color_balance_config_reset_range (cb_tool->config);
gimp_color_balance_config_reset_range (GIMP_COLOR_BALANCE_CONFIG (im_tool->config));
}

4
app/tools/gimpcolorbalancetool.h
View File

@ -36,9 +36,7 @@ typedef struct _GimpColorBalanceToolClass GimpColorBalanceToolClass;
struct _GimpColorBalanceTool
{
GimpImageMapTool parent_instance;
GimpColorBalanceConfig *config;
GimpImageMapTool parent_instance;
};
struct _GimpColorBalanceToolClass

44
app/tools/gimpcolorizetool.c
View File

@ -27,8 +27,6 @@
#include "tools-types.h"
#include "operations/gimpcolorizeconfig.h"
#include "core/gimpdrawable.h"
#include "core/gimperror.h"
#include "core/gimpimage.h"
@ -52,9 +50,12 @@ static gboolean gimp_colorize_tool_initialize (GimpTool *tool,
GimpDisplay *display,
GError **error);
static GeglNode * gimp_colorize_tool_get_operation (GimpImageMapTool *im_tool,
GObject **config,
gchar **undo_desc);
static gchar * gimp_colorize_tool_get_operation (GimpImageMapTool *im_tool,
gchar **title,
gchar **description,
gchar **undo_desc,
gchar **icon_name,
gchar **help_id);
static void gimp_colorize_tool_dialog (GimpImageMapTool *im_tool);
static void gimp_colorize_tool_color_picked (GimpImageMapTool *im_tool,
gpointer identifier,
@ -94,7 +95,6 @@ gimp_colorize_tool_class_init (GimpColorizeToolClass *klass)
tool_class->initialize = gimp_colorize_tool_initialize;
im_tool_class->dialog_desc = _("Colorize the Image");
im_tool_class->settings_name = "colorize";
im_tool_class->import_dialog_title = _("Import Colorize Settings");
im_tool_class->export_dialog_title = _("Export Colorize Settings");
@ -130,17 +130,17 @@ gimp_colorize_tool_initialize (GimpTool *tool,
return GIMP_TOOL_CLASS (parent_class)->initialize (tool, display, error);
}
static GeglNode *
static gchar *
gimp_colorize_tool_get_operation (GimpImageMapTool *im_tool,
GObject **config,
gchar **undo_desc)
gchar **title,
gchar **description,
gchar **undo_desc,
gchar **icon_name,
gchar **help_id)
{
*config = g_object_new (GIMP_TYPE_COLORIZE_CONFIG, NULL);
*description = g_strdup (_("Colorize the Image"));
return gegl_node_new_child (NULL,
"operation", "gimp:colorize",
"config", *config,
NULL);
return g_strdup ("gimp:colorize");
}
@ -149,9 +149,9 @@ gimp_colorize_tool_get_operation (GimpImageMapTool *im_tool,
/***************************/
static void
gimp_colorize_tool_dialog (GimpImageMapTool *image_map_tool)
gimp_colorize_tool_dialog (GimpImageMapTool *im_tool)
{
GimpColorizeTool *col_tool = GIMP_COLORIZE_TOOL (image_map_tool);
GimpColorizeTool *col_tool = GIMP_COLORIZE_TOOL (im_tool);
GtkWidget *main_vbox;
GtkWidget *frame;
GtkWidget *vbox;
@ -159,7 +159,7 @@ gimp_colorize_tool_dialog (GimpImageMapTool *image_map_tool)
GtkWidget *hbox;
GtkWidget *button;
main_vbox = gimp_image_map_tool_dialog_get_vbox (image_map_tool);
main_vbox = gimp_image_map_tool_dialog_get_vbox (im_tool);
frame = gimp_frame_new (_("Select Color"));
gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0);
@ -170,21 +170,21 @@ gimp_colorize_tool_dialog (GimpImageMapTool *image_map_tool)
gtk_widget_show (vbox);
/* Create the hue scale widget */
scale = gimp_prop_spin_scale_new (image_map_tool->config, "hue",
scale = gimp_prop_spin_scale_new (im_tool->config, "hue",
_("_Hue"), 1.0 / 360.0, 15.0 / 360.0, 0);
gimp_prop_widget_set_factor (scale, 360.0, 0.0, 0.0, 1);
gtk_box_pack_start (GTK_BOX (vbox), scale, FALSE, FALSE, 0);
gtk_widget_show (scale);
/* Create the saturation scale widget */
scale = gimp_prop_spin_scale_new (image_map_tool->config, "saturation",
scale = gimp_prop_spin_scale_new (im_tool->config, "saturation",
_("_Saturation"), 0.01, 0.1, 0);
gimp_prop_widget_set_factor (scale, 100.0, 0.0, 0.0, 1);
gtk_box_pack_start (GTK_BOX (vbox), scale, FALSE, FALSE, 0);
gtk_widget_show (scale);
/* Create the lightness scale widget */
scale = gimp_prop_spin_scale_new (image_map_tool->config, "lightness",
scale = gimp_prop_spin_scale_new (im_tool->config, "lightness",
_("_Lightness"), 0.01, 0.1, 0);
gimp_prop_widget_set_factor (scale, 100.0, 0.0, 0.0, 1);
gtk_box_pack_start (GTK_BOX (vbox), scale, FALSE, FALSE, 0);
@ -195,7 +195,7 @@ gimp_colorize_tool_dialog (GimpImageMapTool *image_map_tool)
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
gtk_widget_show (hbox);
button = gimp_prop_color_button_new (image_map_tool->config, "color",
button = gimp_prop_color_button_new (im_tool->config, "color",
_("Colorize Color"),
128, 24,
GIMP_COLOR_AREA_FLAT);
@ -205,7 +205,7 @@ gimp_colorize_tool_dialog (GimpImageMapTool *image_map_tool)
gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
gtk_widget_show (button);
button = gimp_image_map_tool_add_color_picker (image_map_tool,
button = gimp_image_map_tool_add_color_picker (im_tool,
"colorize",
GIMP_STOCK_COLOR_PICKER_GRAY,
_("Pick color from image"));

133
app/tools/gimpcurvestool.c
View File

@ -89,15 +89,19 @@ static void gimp_curves_tool_color_picked (GimpColorTool *color_t
const Babl *sample_format,
gpointer pixel,
const GimpRGB *color);
static GeglNode * gimp_curves_tool_get_operation (GimpImageMapTool *image_map_tool,
GObject **config,
gchar **undo_desc);
static void gimp_curves_tool_dialog (GimpImageMapTool *image_map_tool);
static void gimp_curves_tool_reset (GimpImageMapTool *image_map_tool);
static gboolean gimp_curves_tool_settings_import(GimpImageMapTool *image_map_tool,
static gchar * gimp_curves_tool_get_operation (GimpImageMapTool *im_tool,
gchar **title,
gchar **description,
gchar **undo_desc,
gchar **icon_name,
gchar **help_id);
static void gimp_curves_tool_dialog (GimpImageMapTool *im_tool);
static void gimp_curves_tool_reset (GimpImageMapTool *im_tool);
static gboolean gimp_curves_tool_settings_import(GimpImageMapTool *im_tool,
GInputStream *input,
GError **error);
static gboolean gimp_curves_tool_settings_export(GimpImageMapTool *image_map_tool,
static gboolean gimp_curves_tool_settings_export(GimpImageMapTool *im_tool,
GOutputStream *output,
GError **error);
@ -168,7 +172,6 @@ gimp_curves_tool_class_init (GimpCurvesToolClass *klass)
color_tool_class->picked = gimp_curves_tool_color_picked;
im_tool_class->dialog_desc = _("Adjust Color Curves");
im_tool_class->settings_name = "curves";
im_tool_class->import_dialog_title = _("Import Curves");
im_tool_class->export_dialog_title = _("Export Curves");
@ -194,6 +197,10 @@ gimp_curves_tool_constructed (GObject *object)
{
G_OBJECT_CLASS (parent_class)->constructed (object);
g_signal_connect_object (GIMP_IMAGE_MAP_TOOL (object)->config, "notify",
G_CALLBACK (gimp_curves_tool_config_notify),
object, 0);
/* always pick colors */
gimp_color_tool_enable (GIMP_COLOR_TOOL (object),
GIMP_COLOR_TOOL_GET_OPTIONS (object));
@ -246,8 +253,9 @@ gimp_curves_tool_button_release (GimpTool *tool,
GimpButtonReleaseType release_type,
GimpDisplay *display)
{
GimpCurvesTool *c_tool = GIMP_CURVES_TOOL (tool);
GimpCurvesConfig *config = c_tool->config;
GimpCurvesTool *c_tool = GIMP_CURVES_TOOL (tool);
GimpImageMapTool *im_tool = GIMP_IMAGE_MAP_TOOL (tool);
GimpCurvesConfig *config = GIMP_CURVES_CONFIG (im_tool->config);
if (state & gimp_get_extend_selection_mask ())
{
@ -363,8 +371,10 @@ gimp_curves_tool_color_picked (GimpColorTool *color_tool,
gpointer pixel,
const GimpRGB *color)
{
GimpCurvesTool *tool = GIMP_CURVES_TOOL (color_tool);
GimpDrawable *drawable;
GimpCurvesTool *tool = GIMP_CURVES_TOOL (color_tool);
GimpImageMapTool *im_tool = GIMP_IMAGE_MAP_TOOL (color_tool);
GimpCurvesConfig *config = GIMP_CURVES_CONFIG (im_tool->config);
GimpDrawable *drawable;
drawable = GIMP_IMAGE_MAP_TOOL (tool)->drawable;
@ -381,28 +391,20 @@ gimp_curves_tool_color_picked (GimpColorTool *color_tool,
color->b);
gimp_curve_view_set_xpos (GIMP_CURVE_VIEW (tool->graph),
tool->picked_color[tool->config->channel]);
tool->picked_color[config->channel]);
}
static GeglNode *
gimp_curves_tool_get_operation (GimpImageMapTool *image_map_tool,
GObject **config,
gchar **undo_desc)
static gchar *
gimp_curves_tool_get_operation (GimpImageMapTool *im_tool,
gchar **title,
gchar **description,
gchar **undo_desc,
gchar **icon_name,
gchar **help_id)
{
GimpCurvesTool *tool = GIMP_CURVES_TOOL (image_map_tool);
*description = g_strdup (_("Adjust Color Curves"));
tool->config = g_object_new (GIMP_TYPE_CURVES_CONFIG, NULL);
g_signal_connect_object (tool->config, "notify",
G_CALLBACK (gimp_curves_tool_config_notify),
tool, 0);
*config = G_OBJECT (tool->config);
return gegl_node_new_child (NULL,
"operation", "gimp:curves",
"config", tool->config,
NULL);
return g_strdup ("gimp:curves");
}
@ -411,11 +413,11 @@ gimp_curves_tool_get_operation (GimpImageMapTool *image_map_tool,
/*******************/
static void
gimp_curves_tool_dialog (GimpImageMapTool *image_map_tool)
gimp_curves_tool_dialog (GimpImageMapTool *im_tool)
{
GimpCurvesTool *tool = GIMP_CURVES_TOOL (image_map_tool);
GimpToolOptions *tool_options = GIMP_TOOL_GET_OPTIONS (image_map_tool);
GimpCurvesConfig *config = tool->config;
GimpCurvesTool *tool = GIMP_CURVES_TOOL (im_tool);
GimpToolOptions *tool_options = GIMP_TOOL_GET_OPTIONS (im_tool);
GimpCurvesConfig *config = GIMP_CURVES_CONFIG (im_tool->config);
GtkListStore *store;
GtkSizeGroup *label_group;
GtkWidget *main_vbox;
@ -429,12 +431,12 @@ gimp_curves_tool_dialog (GimpImageMapTool *image_map_tool)
GtkWidget *bar;
GtkWidget *combo;
g_signal_connect (image_map_tool->settings_box, "file-dialog-setup",
g_signal_connect (im_tool->settings_box, "file-dialog-setup",
G_CALLBACK (gimp_curves_tool_export_setup),
image_map_tool);
im_tool);
main_vbox = gimp_image_map_tool_dialog_get_vbox (image_map_tool);
label_group = gimp_image_map_tool_dialog_get_label_group (image_map_tool);
main_vbox = gimp_image_map_tool_dialog_get_vbox (im_tool);
label_group = gimp_image_map_tool_dialog_get_label_group (im_tool);
/* The combo box for selecting channels */
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
@ -577,13 +579,13 @@ gimp_curves_tool_dialog (GimpImageMapTool *image_map_tool)
}
static void
gimp_curves_tool_reset (GimpImageMapTool *image_map_tool)
gimp_curves_tool_reset (GimpImageMapTool *im_tool)
{
GimpCurvesTool *tool = GIMP_CURVES_TOOL (image_map_tool);
GimpCurvesConfig *config = GIMP_CURVES_CONFIG (im_tool->config);
GimpCurvesConfig *default_config;
GimpHistogramChannel channel;
default_config = GIMP_CURVES_CONFIG (image_map_tool->default_config);
default_config = GIMP_CURVES_CONFIG (im_tool->default_config);
for (channel = GIMP_HISTOGRAM_VALUE;
channel <= GIMP_HISTOGRAM_ALPHA;
@ -591,35 +593,35 @@ gimp_curves_tool_reset (GimpImageMapTool *image_map_tool)
{
if (default_config)
{
GimpCurveType curve_type = tool->config->curve[channel]->curve_type;
GimpCurveType curve_type = config->curve[channel]->curve_type;
g_object_freeze_notify (G_OBJECT (tool->config->curve[channel]));
g_object_freeze_notify (G_OBJECT (config->curve[channel]));
gimp_config_copy (GIMP_CONFIG (default_config->curve[channel]),
GIMP_CONFIG (tool->config->curve[channel]),
GIMP_CONFIG (config->curve[channel]),
0);
g_object_set (tool->config->curve[channel],
g_object_set (config->curve[channel],
"curve-type", curve_type,
NULL);
g_object_thaw_notify (G_OBJECT (tool->config->curve[channel]));
g_object_thaw_notify (G_OBJECT (config->curve[channel]));
}
else
{
gimp_curve_reset (tool->config->curve[channel], FALSE);
gimp_curve_reset (config->curve[channel], FALSE);
}
}
}
static gboolean
gimp_curves_tool_settings_import (GimpImageMapTool *image_map_tool,
gimp_curves_tool_settings_import (GimpImageMapTool *im_tool,
GInputStream *input,
GError **error)
{
GimpCurvesTool *tool = GIMP_CURVES_TOOL (image_map_tool);
gchar header[64];
gsize bytes_read;
GimpCurvesConfig *config = GIMP_CURVES_CONFIG (im_tool->config);
gchar header[64];
gsize bytes_read;
if (! g_input_stream_read_all (input, header, sizeof (header),
&bytes_read, NULL, error) ||
@ -632,24 +634,25 @@ gimp_curves_tool_settings_import (GimpImageMapTool *image_map_tool,
g_seekable_seek (G_SEEKABLE (input), 0, G_SEEK_SET, NULL, NULL);
if (g_str_has_prefix (header, "# GIMP Curves File\n"))
return gimp_curves_config_load_cruft (tool->config, input, error);
return gimp_curves_config_load_cruft (config, input, error);
return GIMP_IMAGE_MAP_TOOL_CLASS (parent_class)->settings_import (image_map_tool,
return GIMP_IMAGE_MAP_TOOL_CLASS (parent_class)->settings_import (im_tool,
input,
error);
}
static gboolean
gimp_curves_tool_settings_export (GimpImageMapTool *image_map_tool,
gimp_curves_tool_settings_export (GimpImageMapTool *im_tool,
GOutputStream *output,
GError **error)
{
GimpCurvesTool *tool = GIMP_CURVES_TOOL (image_map_tool);
GimpCurvesTool *tool = GIMP_CURVES_TOOL (im_tool);
GimpCurvesConfig *config = GIMP_CURVES_CONFIG (im_tool->config);
if (tool->export_old_format)
return gimp_curves_config_save_cruft (tool->config, output, error);
return gimp_curves_config_save_cruft (config, output, error);
return GIMP_IMAGE_MAP_TOOL_CLASS (parent_class)->settings_export (image_map_tool,
return GIMP_IMAGE_MAP_TOOL_CLASS (parent_class)->settings_export (im_tool,
output,
error);
}
@ -679,8 +682,9 @@ gimp_curves_tool_export_setup (GimpSettingsBox *settings_box,
static void
gimp_curves_tool_update_channel (GimpCurvesTool *tool)
{
GimpCurvesConfig *config = GIMP_CURVES_TOOL (tool)->config;
GimpCurve *curve = config->curve[config->channel];
GimpImageMapTool *im_tool = GIMP_IMAGE_MAP_TOOL (tool);
GimpCurvesConfig *config = GIMP_CURVES_CONFIG (im_tool->config);
GimpCurve *curve = config->curve[config->channel];
GimpHistogramChannel channel;
gimp_int_combo_box_set_active (GIMP_INT_COMBO_BOX (tool->channel_menu),
@ -773,7 +777,8 @@ static void
curves_channel_callback (GtkWidget *widget,
GimpCurvesTool *tool)
{
GimpCurvesConfig *config = tool->config;
GimpImageMapTool *im_tool = GIMP_IMAGE_MAP_TOOL (tool);
GimpCurvesConfig *config = GIMP_CURVES_CONFIG (im_tool->config);
gint value;
if (gimp_int_combo_box_get_active (GIMP_INT_COMBO_BOX (widget), &value) &&
@ -789,7 +794,10 @@ static void
curves_channel_reset_callback (GtkWidget *widget,
GimpCurvesTool *tool)
{
gimp_curve_reset (tool->config->curve[tool->config->channel], FALSE);
GimpImageMapTool *im_tool = GIMP_IMAGE_MAP_TOOL (tool);
GimpCurvesConfig *config = GIMP_CURVES_CONFIG (im_tool->config);
gimp_curve_reset (config->curve[config->channel], FALSE);
}
static gboolean
@ -827,7 +835,8 @@ curves_curve_type_callback (GtkWidget *widget,
if (gimp_int_combo_box_get_active (GIMP_INT_COMBO_BOX (widget), &value))
{
GimpCurvesConfig *config = tool->config;
GimpImageMapTool *im_tool = GIMP_IMAGE_MAP_TOOL (tool);
GimpCurvesConfig *config = GIMP_CURVES_CONFIG (im_tool->config);
GimpCurveType curve_type = value;
if (config->curve[config->channel]->curve_type != curve_type)

18
app/tools/gimpcurvestool.h
View File

@ -34,21 +34,19 @@ typedef struct _GimpCurvesToolClass GimpCurvesToolClass;
struct _GimpCurvesTool
{
GimpImageMapTool parent_instance;
GimpCurvesConfig *config;
GimpImageMapTool parent_instance;
/* dialog */
gdouble picked_color[5];
gdouble picked_color[5];
GtkWidget *channel_menu;
GtkWidget *xrange;
GtkWidget *yrange;
GtkWidget *graph;
GtkWidget *curve_type;
GtkWidget *channel_menu;
GtkWidget *xrange;
GtkWidget *yrange;
GtkWidget *graph;
GtkWidget *curve_type;
/* export dialog */
gboolean export_old_format;
gboolean export_old_format;
};
struct _GimpCurvesToolClass

43
app/tools/gimpgegltool.c
View File

@ -49,10 +49,16 @@ enum
/* local function prototypes */
static void gimp_gegl_tool_dialog (GimpImageMapTool *im_tool);
static gchar * gimp_gegl_tool_get_operation (GimpImageMapTool *im_tool,
gchar **title,
gchar **description,
gchar **undo_desc,
gchar **icon_name,
gchar **help_id);
static void gimp_gegl_tool_dialog (GimpImageMapTool *im_tool);
static void gimp_gegl_tool_operation_changed (GtkWidget *widget,
GimpGeglTool *tool);
static void gimp_gegl_tool_operation_changed (GtkWidget *widget,
GimpGeglTool *tool);
G_DEFINE_TYPE (GimpGeglTool, gimp_gegl_tool, GIMP_TYPE_OPERATION_TOOL)
@ -82,9 +88,8 @@ gimp_gegl_tool_class_init (GimpGeglToolClass *klass)
{
GimpImageMapToolClass *im_tool_class = GIMP_IMAGE_MAP_TOOL_CLASS (klass);
im_tool_class->dialog_desc = _("GEGL Operation");
im_tool_class->dialog = gimp_gegl_tool_dialog;
im_tool_class->get_operation = gimp_gegl_tool_get_operation;
im_tool_class->dialog = gimp_gegl_tool_dialog;
}
static void
@ -324,6 +329,31 @@ gimp_get_geglopclasses (void)
/* Gegl dialog */
/*****************/
static gchar *
gimp_gegl_tool_get_operation (GimpImageMapTool *im_tool,
gchar **title,
gchar **description,
gchar **undo_desc,
gchar **icon_name,
gchar **help_id)
{
gchar *operation;
operation = GIMP_IMAGE_MAP_TOOL_GET_CLASS (im_tool)->get_operation (im_tool,
title,
description,
undo_desc,
icon_name,
help_id);
if (*description)
g_free (*description);
*description = g_strdup (_("GEGL Operation"));
return operation;
}
static void
gimp_gegl_tool_dialog (GimpImageMapTool *image_map_tool)
{
@ -463,6 +493,7 @@ gimp_gegl_tool_operation_changed (GtkWidget *widget,
gimp_operation_tool_set_operation (GIMP_OPERATION_TOOL (tool),
operation,
_("GEGL Operation"),
_("GEGL Operation"),
NULL,
GIMP_STOCK_GEGL,
GIMP_HELP_TOOL_GEGL);

110
app/tools/gimphuesaturationtool.c
View File

@ -52,13 +52,18 @@
/* local function prototypes */
static void gimp_hue_saturation_tool_constructed (GObject *object);
static gboolean gimp_hue_saturation_tool_initialize (GimpTool *tool,
GimpDisplay *display,
GError **error);
static GeglNode * gimp_hue_saturation_tool_get_operation (GimpImageMapTool *im_tool,
GObject **config,
gchar **undo_desc);
static gchar * gimp_hue_saturation_tool_get_operation (GimpImageMapTool *im_tool,
gchar **title,
gchar **description,
gchar **undo_desc,
gchar **icon_name,
gchar **help_id);
static void gimp_hue_saturation_tool_dialog (GimpImageMapTool *im_tool);
static void gimp_hue_saturation_tool_reset (GimpImageMapTool *im_tool);
@ -69,9 +74,9 @@ static void hue_saturation_config_notify (GObject
static void hue_saturation_update_color_areas (GimpHueSaturationTool *hs_tool);
static void hue_saturation_range_callback (GtkWidget *widget,
GimpHueSaturationTool *hs_tool);
GimpImageMapTool *im_tool);
static void hue_saturation_range_reset_callback (GtkWidget *widget,
GimpHueSaturationTool *hs_tool);
GimpImageMapTool *hs_tool);
G_DEFINE_TYPE (GimpHueSaturationTool, gimp_hue_saturation_tool,
@ -99,12 +104,14 @@ gimp_hue_saturation_tool_register (GimpToolRegisterCallback callback,
static void
gimp_hue_saturation_tool_class_init (GimpHueSaturationToolClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
GimpToolClass *tool_class = GIMP_TOOL_CLASS (klass);
GimpImageMapToolClass *im_tool_class = GIMP_IMAGE_MAP_TOOL_CLASS (klass);
object_class->constructed = gimp_hue_saturation_tool_constructed;
tool_class->initialize = gimp_hue_saturation_tool_initialize;
im_tool_class->dialog_desc = _("Adjust Hue / Lightness / Saturation");
im_tool_class->settings_name = "hue-saturation";
im_tool_class->import_dialog_title = _("Import Hue-Saturation Settings");
im_tool_class->export_dialog_title = _("Export Hue-Saturation Settings");
@ -119,6 +126,16 @@ gimp_hue_saturation_tool_init (GimpHueSaturationTool *hs_tool)
{
}
static void
gimp_hue_saturation_tool_constructed (GObject *object)
{
G_OBJECT_CLASS (parent_class)->constructed (object);
g_signal_connect_object (GIMP_IMAGE_MAP_TOOL (object)->config, "notify",
G_CALLBACK (hue_saturation_config_notify),
object, 0);
}
static gboolean
gimp_hue_saturation_tool_initialize (GimpTool *tool,
GimpDisplay *display,
@ -140,25 +157,17 @@ gimp_hue_saturation_tool_initialize (GimpTool *tool,
return GIMP_TOOL_CLASS (parent_class)->initialize (tool, display, error);
}
static GeglNode *
static gchar *
gimp_hue_saturation_tool_get_operation (GimpImageMapTool *im_tool,
GObject **config,
gchar **undo_desc)
gchar **title,
gchar **description,
gchar **undo_desc,
gchar **icon_name,
gchar **help_id)
{
GimpHueSaturationTool *hs_tool = GIMP_HUE_SATURATION_TOOL (im_tool);
*description = g_strdup (_("Adjust Hue / Lightness / Saturation"));
hs_tool->config = g_object_new (GIMP_TYPE_HUE_SATURATION_CONFIG, NULL);
g_signal_connect_object (hs_tool->config, "notify",
G_CALLBACK (hue_saturation_config_notify),
G_OBJECT (hs_tool), 0);
*config = G_OBJECT (hs_tool->config);
return gegl_node_new_child (NULL,
"operation", "gimp:hue-saturation",
"config", hs_tool->config,
NULL);
return g_strdup ("gimp:hue-saturation");
}
@ -167,10 +176,10 @@ gimp_hue_saturation_tool_get_operation (GimpImageMapTool *im_tool,
/***************************/
static void
gimp_hue_saturation_tool_dialog (GimpImageMapTool *image_map_tool)
gimp_hue_saturation_tool_dialog (GimpImageMapTool *im_tool)
{
GimpHueSaturationTool *hs_tool = GIMP_HUE_SATURATION_TOOL (image_map_tool);
GimpHueSaturationConfig *config = hs_tool->config;
GimpHueSaturationTool *hs_tool = GIMP_HUE_SATURATION_TOOL (im_tool);
GimpHueSaturationConfig *config = GIMP_HUE_SATURATION_CONFIG (im_tool->config);
GtkWidget *main_vbox;
GtkWidget *frame;
GtkWidget *vbox;
@ -202,7 +211,7 @@ gimp_hue_saturation_tool_dialog (GimpImageMapTool *image_map_tool)
{ N_("_M"), N_("Magenta"), 3, 2, 4, 2 }
};
main_vbox = gimp_image_map_tool_dialog_get_vbox (image_map_tool);
main_vbox = gimp_image_map_tool_dialog_get_vbox (im_tool);
frame = gimp_frame_new (_("Select Primary Color to Adjust"));
gtk_box_pack_start (GTK_BOX (main_vbox), frame, TRUE, TRUE, 0);
@ -284,7 +293,7 @@ gimp_hue_saturation_tool_dialog (GimpImageMapTool *image_map_tool)
gtk_widget_show (table);
/* Create the 'Overlap' option slider */
scale = gimp_prop_spin_scale_new (image_map_tool->config, "overlap",
scale = gimp_prop_spin_scale_new (im_tool->config, "overlap",
_("_Overlap"), 0.01, 0.1, 0);
gimp_prop_widget_set_factor (scale, 100.0, 0.0, 0.0, 1);
gtk_box_pack_start (GTK_BOX (vbox), scale, FALSE, FALSE, 0);
@ -299,21 +308,21 @@ gimp_hue_saturation_tool_dialog (GimpImageMapTool *image_map_tool)
gtk_widget_show (vbox);
/* Create the hue scale widget */
scale = gimp_prop_spin_scale_new (image_map_tool->config, "hue",
scale = gimp_prop_spin_scale_new (im_tool->config, "hue",
_("_Hue"), 1.0 / 180.0, 15.0 / 180.0, 0);
gimp_prop_widget_set_factor (scale, 180.0, 0.0, 0.0, 1);
gtk_box_pack_start (GTK_BOX (vbox), scale, FALSE, FALSE, 0);
gtk_widget_show (scale);
/* Create the lightness scale widget */
scale = gimp_prop_spin_scale_new (image_map_tool->config, "lightness",
scale = gimp_prop_spin_scale_new (im_tool->config, "lightness",
_("_Lightness"), 0.01, 0.1, 0);
gimp_prop_widget_set_factor (scale, 100.0, 0.0, 0.0, 1);
gtk_box_pack_start (GTK_BOX (vbox), scale, FALSE, FALSE, 0);
gtk_widget_show (scale);
/* Create the saturation scale widget */
scale = gimp_prop_spin_scale_new (image_map_tool->config, "saturation",
scale = gimp_prop_spin_scale_new (im_tool->config, "saturation",
_("_Saturation"), 0.01, 0.1, 0);
gimp_prop_widget_set_factor (scale, 100.0, 0.0, 0.0, 1);
gtk_box_pack_start (GTK_BOX (vbox), scale, FALSE, FALSE, 0);
@ -338,29 +347,32 @@ gimp_hue_saturation_tool_dialog (GimpImageMapTool *image_map_tool)
}
static void
gimp_hue_saturation_tool_reset (GimpImageMapTool *image_map_tool)
gimp_hue_saturation_tool_reset (GimpImageMapTool *im_tool)
{
GimpHueSaturationTool *hs_tool = GIMP_HUE_SATURATION_TOOL (image_map_tool);
GimpHueRange range = hs_tool->config->range;
GimpHueRange range;
g_object_freeze_notify (image_map_tool->config);
g_object_freeze_notify (im_tool->config);
if (image_map_tool->default_config)
g_object_get (im_tool->config,
"range", &range,
NULL);
if (im_tool->default_config)
{
gimp_config_copy (GIMP_CONFIG (image_map_tool->default_config),
GIMP_CONFIG (image_map_tool->config),
gimp_config_copy (GIMP_CONFIG (im_tool->default_config),
GIMP_CONFIG (im_tool->config),
0);
}
else
{
gimp_config_reset (GIMP_CONFIG (image_map_tool->config));
gimp_config_reset (GIMP_CONFIG (im_tool->config));
}
g_object_set (hs_tool->config,
g_object_set (im_tool->config,
"range", range,
NULL);
g_object_thaw_notify (image_map_tool->config);
g_object_thaw_notify (im_tool->config);
}
static void
@ -395,13 +407,15 @@ hue_saturation_update_color_areas (GimpHueSaturationTool *hs_tool)
{ 1.0, 0, 1.0, }
};
gint i;
GimpImageMapTool *im_tool = GIMP_IMAGE_MAP_TOOL (hs_tool);
GimpHueSaturationConfig *config = GIMP_HUE_SATURATION_CONFIG (im_tool->config);
gint i;
for (i = 0; i < 6; i++)
{
GimpRGB color = default_colors[i];
gimp_operation_hue_saturation_map (hs_tool->config, &color, i + 1,
gimp_operation_hue_saturation_map (config, &color, i + 1,
&color);
gimp_color_area_set_color (GIMP_COLOR_AREA (hs_tool->hue_range_color_area[i]),
@ -410,23 +424,23 @@ hue_saturation_update_color_areas (GimpHueSaturationTool *hs_tool)
}
static void
hue_saturation_range_callback (GtkWidget *widget,
GimpHueSaturationTool *hs_tool)
hue_saturation_range_callback (GtkWidget *widget,
GimpImageMapTool *im_tool)
{
if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget)))
{
GimpHueRange range;
gimp_radio_button_update (widget, &range);
g_object_set (hs_tool->config,
g_object_set (im_tool->config,
"range", range,
NULL);
}
}
static void
hue_saturation_range_reset_callback (GtkWidget *widget,
GimpHueSaturationTool *hs_tool)
hue_saturation_range_reset_callback (GtkWidget *widget,
GimpImageMapTool *im_tool)
{
gimp_hue_saturation_config_reset_range (hs_tool->config);
gimp_hue_saturation_config_reset_range (GIMP_HUE_SATURATION_CONFIG (im_tool->config));
}

8
app/tools/gimphuesaturationtool.h
View File

@ -35,13 +35,11 @@ typedef struct _GimpHueSaturationToolClass GimpHueSaturationToolClass;
struct _GimpHueSaturationTool
{
GimpImageMapTool parent_instance;
GimpHueSaturationConfig *config;
GimpImageMapTool parent_instance;
/* dialog */
GtkWidget *range_radio;
GtkWidget *hue_range_color_area[6];
GtkWidget *range_radio;
GtkWidget *hue_range_color_area[6];
};
struct _GimpHueSaturationToolClass

343
app/tools/gimpimagemaptool.c
View File

@ -38,6 +38,8 @@
#include "config/gimpguiconfig.h"
#include "gegl/gimp-gegl-config.h"
#include "core/gimp.h"
#include "core/gimpdrawable.h"
#include "core/gimperror.h"
@ -179,13 +181,11 @@ gimp_image_map_tool_class_init (GimpImageMapToolClass *klass)
color_tool_class->pick = gimp_image_map_tool_pick_color;
color_tool_class->picked = gimp_image_map_tool_color_picked;
klass->dialog_desc = NULL;
klass->settings_name = NULL;
klass->import_dialog_title = NULL;
klass->export_dialog_title = NULL;
klass->get_operation = NULL;
klass->map = NULL;
klass->dialog = NULL;
klass->reset = gimp_image_map_tool_real_reset;
klass->get_settings_ui = gimp_image_map_tool_real_get_settings_ui;
@ -249,12 +249,36 @@ gimp_image_map_tool_finalize (GObject *object)
image_map_tool->default_config = NULL;
}
if (image_map_tool->title)
{
g_free (image_map_tool->title);
image_map_tool->title = NULL;
}
if (image_map_tool->description)
{
g_free (image_map_tool->description);
image_map_tool->description = NULL;
}
if (image_map_tool->undo_desc)
{
g_free (image_map_tool->undo_desc);
image_map_tool->undo_desc = NULL;
}
if (image_map_tool->icon_name)
{
g_free (image_map_tool->icon_name);
image_map_tool->icon_name = NULL;
}
if (image_map_tool->help_id)
{
g_free (image_map_tool->help_id);
image_map_tool->help_id = NULL;
}
if (image_map_tool->label_group)
{
g_object_unref (image_map_tool->label_group);
@ -290,11 +314,11 @@ gimp_image_map_tool_initialize (GimpTool *tool,
GimpDisplay *display,
GError **error)
{
GimpImageMapTool *image_map_tool = GIMP_IMAGE_MAP_TOOL (tool);
GimpToolInfo *tool_info = tool->tool_info;
GimpImage *image = gimp_display_get_image (display);
GimpDrawable *drawable = gimp_image_get_active_drawable (image);
GimpDisplayShell *shell = gimp_display_get_shell (display);
GimpImageMapTool *im_tool = GIMP_IMAGE_MAP_TOOL (tool);
GimpToolInfo *tool_info = tool->tool_info;
GimpImage *image = gimp_display_get_image (display);
GimpDrawable *drawable = gimp_image_get_active_drawable (image);
GimpDisplayShell *shell = gimp_display_get_shell (display);
if (! drawable)
return FALSE;
@ -320,34 +344,32 @@ gimp_image_map_tool_initialize (GimpTool *tool,
return FALSE;
}
if (image_map_tool->active_picker)
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (image_map_tool->active_picker),
if (im_tool->active_picker)
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (im_tool->active_picker),
FALSE);
/* set display so the dialog can be hidden on display destruction */
tool->display = display;
if (image_map_tool->config)
gimp_config_reset (GIMP_CONFIG (image_map_tool->config));
if (im_tool->config)
gimp_config_reset (GIMP_CONFIG (im_tool->config));
if (! image_map_tool->gui)
if (! im_tool->gui)
{
GimpImageMapToolClass *klass;
GimpImageMapToolClass *klass = GIMP_IMAGE_MAP_TOOL_GET_CLASS (im_tool);
GtkWidget *vbox;
GtkWidget *toggle;
gchar *operation_name;
klass = GIMP_IMAGE_MAP_TOOL_GET_CLASS (image_map_tool);
/* disabled for at least GIMP 2.8 */
image_map_tool->overlay = FALSE;
im_tool->overlay = FALSE;
image_map_tool->gui =
im_tool->gui =
gimp_tool_gui_new (tool_info,
klass->dialog_desc,
im_tool->description,
gtk_widget_get_screen (GTK_WIDGET (shell)),
gimp_widget_get_monitor (GTK_WIDGET (shell)),
image_map_tool->overlay,
im_tool->overlay,
GIMP_STOCK_RESET, RESPONSE_RESET,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
@ -355,21 +377,21 @@ gimp_image_map_tool_initialize (GimpTool *tool,
NULL);
gimp_tool_gui_set_default_response (image_map_tool->gui, GTK_RESPONSE_OK);
gimp_tool_gui_set_default_response (im_tool->gui, GTK_RESPONSE_OK);
gimp_tool_gui_set_alternative_button_order (image_map_tool->gui,
gimp_tool_gui_set_alternative_button_order (im_tool->gui,
RESPONSE_RESET,
GTK_RESPONSE_OK,
GTK_RESPONSE_CANCEL,
-1);
vbox = gimp_tool_gui_get_vbox (image_map_tool->gui);
vbox = gimp_tool_gui_get_vbox (im_tool->gui);
g_signal_connect_object (image_map_tool->gui, "response",
g_signal_connect_object (im_tool->gui, "response",
G_CALLBACK (gimp_image_map_tool_response),
G_OBJECT (image_map_tool), 0);
G_OBJECT (im_tool), 0);
if (image_map_tool->config && klass->settings_name)
if (im_tool->config && klass->settings_name)
{
GtkWidget *settings_ui;
GFile *default_folder;
@ -379,14 +401,14 @@ gimp_image_map_tool_initialize (GimpTool *tool,
".settings");
default_folder = gimp_directory_file (klass->settings_name, NULL);
settings_ui = klass->get_settings_ui (image_map_tool,
settings_ui = klass->get_settings_ui (im_tool,
klass->recent_settings,
settings_file,
klass->import_dialog_title,
klass->export_dialog_title,
tool_info->help_id,
im_tool->help_id,
default_folder,
&image_map_tool->settings_box);
&im_tool->settings_box);
g_object_unref (default_folder);
g_object_unref (settings_file);
@ -402,7 +424,7 @@ gimp_image_map_tool_initialize (GimpTool *tool,
g_signal_connect (toggle, "toggled",
G_CALLBACK (gamma_hack),
image_map_tool);
im_tool);
/* The preview toggle */
toggle = gimp_prop_check_button_new (G_OBJECT (tool_info->tool_options),
@ -412,38 +434,49 @@ gimp_image_map_tool_initialize (GimpTool *tool,
gtk_widget_show (toggle);
/* The area combo */
gegl_node_get (image_map_tool->operation,
gegl_node_get (im_tool->operation,
"operation", &operation_name,
NULL);
image_map_tool->region_combo =
im_tool->region_combo =
gimp_prop_enum_combo_box_new (G_OBJECT (tool_info->tool_options),
"region",
0, 0);
gtk_box_pack_end (GTK_BOX (vbox), image_map_tool->region_combo,
gtk_box_pack_end (GTK_BOX (vbox), im_tool->region_combo,
FALSE, FALSE, 0);
if (operation_name &&
gegl_operation_get_key (operation_name, "position-dependent"))
{
gtk_widget_show (image_map_tool->region_combo);
gtk_widget_show (im_tool->region_combo);
}
g_free (operation_name);
/* Fill in subclass widgets */
gimp_image_map_tool_dialog (image_map_tool);
gimp_image_map_tool_dialog (im_tool);
}
else
{
gimp_tool_gui_set_description (im_tool->gui, im_tool->description);
}
gimp_tool_gui_set_shell (image_map_tool->gui, shell);
gimp_tool_gui_set_viewable (image_map_tool->gui, GIMP_VIEWABLE (drawable));
/* FIXME move these into the block above once gimp_tool_gui_new()
* got more arguments
*/
gimp_tool_gui_set_title (im_tool->gui, im_tool->title);
gimp_tool_gui_set_icon_name (im_tool->gui, im_tool->icon_name);
gimp_tool_gui_set_help_id (im_tool->gui, im_tool->help_id);
gimp_tool_gui_show (image_map_tool->gui);
gimp_tool_gui_set_shell (im_tool->gui, shell);
gimp_tool_gui_set_viewable (im_tool->gui, GIMP_VIEWABLE (drawable));
image_map_tool->drawable = drawable;
gimp_tool_gui_show (im_tool->gui);
gimp_image_map_tool_create_map (image_map_tool);
gimp_image_map_tool_preview (image_map_tool);
im_tool->drawable = drawable;
gimp_image_map_tool_create_map (im_tool);
gimp_image_map_tool_preview (im_tool);
return TRUE;
}
@ -453,7 +486,7 @@ gimp_image_map_tool_control (GimpTool *tool,
GimpToolAction action,
GimpDisplay *display)
{
GimpImageMapTool *image_map_tool = GIMP_IMAGE_MAP_TOOL (tool);
GimpImageMapTool *im_tool = GIMP_IMAGE_MAP_TOOL (tool);
switch (action)
{
@ -462,11 +495,11 @@ gimp_image_map_tool_control (GimpTool *tool,
break;
case GIMP_TOOL_ACTION_HALT:
gimp_image_map_tool_halt (image_map_tool);
gimp_image_map_tool_halt (im_tool);
break;
case GIMP_TOOL_ACTION_COMMIT:
gimp_image_map_tool_commit (image_map_tool);
gimp_image_map_tool_commit (im_tool);
break;
}
@ -478,30 +511,30 @@ gimp_image_map_tool_key_press (GimpTool *tool,
GdkEventKey *kevent,
GimpDisplay *display)
{
GimpImageMapTool *image_map_tool = GIMP_IMAGE_MAP_TOOL (tool);
GimpImageMapTool *im_tool = GIMP_IMAGE_MAP_TOOL (tool);
if (image_map_tool->gui && display == tool->display)
if (im_tool->gui && display == tool->display)
{
switch (kevent->keyval)
{
case GDK_KEY_Return:
case GDK_KEY_KP_Enter:
case GDK_KEY_ISO_Enter:
gimp_image_map_tool_response (image_map_tool->gui,
gimp_image_map_tool_response (im_tool->gui,
GTK_RESPONSE_OK,
image_map_tool);
im_tool);
return TRUE;
case GDK_KEY_BackSpace:
gimp_image_map_tool_response (image_map_tool->gui,
gimp_image_map_tool_response (im_tool->gui,
RESPONSE_RESET,
image_map_tool);
im_tool);
return TRUE;
case GDK_KEY_Escape:
gimp_image_map_tool_response (image_map_tool->gui,
gimp_image_map_tool_response (im_tool->gui,
GTK_RESPONSE_CANCEL,
image_map_tool);
im_tool);
return TRUE;
}
}
@ -514,17 +547,17 @@ gimp_image_map_tool_options_notify (GimpTool *tool,
GimpToolOptions *options,
const GParamSpec *pspec)
{
GimpImageMapTool *image_map_tool = GIMP_IMAGE_MAP_TOOL (tool);
GimpImageMapOptions *im_options = GIMP_IMAGE_MAP_OPTIONS (options);
GimpImageMapTool *im_tool = GIMP_IMAGE_MAP_TOOL (tool);
GimpImageMapOptions *im_options = GIMP_IMAGE_MAP_OPTIONS (options);
if (! strcmp (pspec->name, "preview") &&
image_map_tool->image_map)
im_tool->image_map)
{
if (im_options->preview)
{
gimp_tool_control_push_preserve (tool->control, TRUE);
gimp_image_map_tool_map (image_map_tool);
gimp_image_map_tool_map (im_tool);
gimp_tool_control_pop_preserve (tool->control);
}
@ -532,16 +565,16 @@ gimp_image_map_tool_options_notify (GimpTool *tool,
{
gimp_tool_control_push_preserve (tool->control, TRUE);
gimp_image_map_abort (image_map_tool->image_map);
gimp_image_map_abort (im_tool->image_map);
gimp_tool_control_pop_preserve (tool->control);
}
}
else if (! strcmp (pspec->name, "region") &&
image_map_tool->image_map)
im_tool->image_map)
{
gimp_image_map_set_region (image_map_tool->image_map, im_options->region);
gimp_image_map_tool_preview (image_map_tool);
gimp_image_map_set_region (im_tool->image_map, im_options->region);
gimp_image_map_tool_preview (im_tool);
}
}
@ -553,14 +586,14 @@ gimp_image_map_tool_pick_color (GimpColorTool *color_tool,
gpointer pixel,
GimpRGB *color)
{
GimpImageMapTool *tool = GIMP_IMAGE_MAP_TOOL (color_tool);
GimpImageMapTool *im_tool = GIMP_IMAGE_MAP_TOOL (color_tool);
gint off_x, off_y;
gimp_item_get_offset (GIMP_ITEM (tool->drawable), &off_x, &off_y);
gimp_item_get_offset (GIMP_ITEM (im_tool->drawable), &off_x, &off_y);
*sample_format = gimp_drawable_get_format (tool->drawable);
*sample_format = gimp_drawable_get_format (im_tool->drawable);
return gimp_pickable_pick_color (GIMP_PICKABLE (tool->drawable),
return gimp_pickable_pick_color (GIMP_PICKABLE (im_tool->drawable),
x - off_x,
y - off_y,
color_tool->options->sample_average,
@ -577,19 +610,19 @@ gimp_image_map_tool_color_picked (GimpColorTool *color_tool,
gpointer pixel,
const GimpRGB *color)
{
GimpImageMapTool *tool = GIMP_IMAGE_MAP_TOOL (color_tool);
GimpImageMapTool *im_tool = GIMP_IMAGE_MAP_TOOL (color_tool);
gpointer identifier;
g_return_if_fail (GTK_IS_WIDGET (tool->active_picker));
g_return_if_fail (GTK_IS_WIDGET (im_tool->active_picker));
identifier = g_object_get_data (G_OBJECT (tool->active_picker),
identifier = g_object_get_data (G_OBJECT (im_tool->active_picker),
"picker-identifier");
GIMP_IMAGE_MAP_TOOL_GET_CLASS (tool)->color_picked (tool,
identifier,
x, y,
sample_format,
color);
GIMP_IMAGE_MAP_TOOL_GET_CLASS (im_tool)->color_picked (im_tool,
identifier,
x, y,
sample_format,
color);
}
static void
@ -673,8 +706,8 @@ gimp_image_map_tool_commit (GimpImageMapTool *im_tool)
static void
gimp_image_map_tool_map (GimpImageMapTool *tool)
{
if (GIMP_IMAGE_MAP_TOOL_GET_CLASS (tool)->map)
GIMP_IMAGE_MAP_TOOL_GET_CLASS (tool)->map (tool);
gimp_gegl_config_sync_node (GIMP_OBJECT (tool->config),
tool->operation);
gimp_image_map_apply (tool->image_map, NULL);
}
@ -713,8 +746,7 @@ gimp_image_map_tool_reset (GimpImageMapTool *tool)
static void
gimp_image_map_tool_create_map (GimpImageMapTool *tool)
{
GimpImageMapOptions *options = GIMP_IMAGE_MAP_TOOL_GET_OPTIONS (tool);
GimpToolInfo *tool_info = GIMP_TOOL (tool)->tool_info;
GimpImageMapOptions *options = GIMP_IMAGE_MAP_TOOL_GET_OPTIONS (tool);
if (tool->image_map)
{
@ -727,7 +759,7 @@ gimp_image_map_tool_create_map (GimpImageMapTool *tool)
tool->image_map = gimp_image_map_new (tool->drawable,
tool->undo_desc,
tool->operation,
gimp_viewable_get_icon_name (GIMP_VIEWABLE (tool_info)));
tool->icon_name);
gimp_image_map_set_region (tool->image_map, options->region);
@ -738,9 +770,9 @@ gimp_image_map_tool_create_map (GimpImageMapTool *tool)
static void
gimp_image_map_tool_flush (GimpImageMap *image_map,
GimpImageMapTool *image_map_tool)
GimpImageMapTool *im_tool)
{
GimpTool *tool = GIMP_TOOL (image_map_tool);
GimpTool *tool = GIMP_TOOL (im_tool);
GimpImage *image = gimp_display_get_image (tool->display);
gimp_projection_flush (gimp_image_get_projection (image));
@ -749,23 +781,23 @@ gimp_image_map_tool_flush (GimpImageMap *image_map,
static void
gimp_image_map_tool_config_notify (GObject *object,
const GParamSpec *pspec,
GimpImageMapTool *image_map_tool)
GimpImageMapTool *im_tool)
{
gimp_image_map_tool_preview (image_map_tool);
gimp_image_map_tool_preview (im_tool);
}
static void
gimp_image_map_tool_response (GimpToolGui *gui,
gint response_id,
GimpImageMapTool *image_map_tool)
GimpImageMapTool *im_tool)
{
GimpTool *tool = GIMP_TOOL (image_map_tool);
GimpTool *tool = GIMP_TOOL (im_tool);
switch (response_id)
{
case RESPONSE_RESET:
gimp_image_map_tool_reset (image_map_tool);
gimp_image_map_tool_preview (image_map_tool);
gimp_image_map_tool_reset (im_tool);
gimp_image_map_tool_preview (im_tool);
break;
case GTK_RESPONSE_OK:
@ -779,99 +811,158 @@ gimp_image_map_tool_response (GimpToolGui *gui,
}
void
gimp_image_map_tool_get_operation (GimpImageMapTool *image_map_tool)
gimp_image_map_tool_get_operation (GimpImageMapTool *im_tool)
{
GimpImageMapToolClass *klass;
GimpToolInfo *tool_info;
gchar *operation_name;
g_return_if_fail (GIMP_IS_IMAGE_MAP_TOOL (image_map_tool));
g_return_if_fail (GIMP_IS_IMAGE_MAP_TOOL (im_tool));
klass = GIMP_IMAGE_MAP_TOOL_GET_CLASS (image_map_tool);
klass = GIMP_IMAGE_MAP_TOOL_GET_CLASS (im_tool);
if (image_map_tool->image_map)
tool_info = GIMP_TOOL (im_tool)->tool_info;
if (im_tool->image_map)
{
gimp_image_map_abort (image_map_tool->image_map);
g_object_unref (image_map_tool->image_map);
image_map_tool->image_map = NULL;
gimp_image_map_abort (im_tool->image_map);
g_object_unref (im_tool->image_map);
im_tool->image_map = NULL;
}
if (image_map_tool->operation)
if (im_tool->operation)
{
g_object_unref (image_map_tool->operation);
image_map_tool->operation = NULL;
g_object_unref (im_tool->operation);
im_tool->operation = NULL;
}
if (image_map_tool->config)
if (im_tool->config)
{
g_signal_handlers_disconnect_by_func (image_map_tool->config,
g_signal_handlers_disconnect_by_func (im_tool->config,
gimp_image_map_tool_config_notify,
image_map_tool);
im_tool);
g_object_unref (image_map_tool->config);
image_map_tool->config = NULL;
g_object_unref (im_tool->config);
im_tool->config = NULL;
}
if (image_map_tool->undo_desc)
if (im_tool->title)
{
g_free (image_map_tool->undo_desc);
image_map_tool->undo_desc = NULL;
g_free (im_tool->title);
im_tool->title = NULL;
}
image_map_tool->operation = klass->get_operation (image_map_tool,
&image_map_tool->config,
&image_map_tool->undo_desc);
if (im_tool->description)
{
g_free (im_tool->description);
im_tool->description = NULL;
}
if (! image_map_tool->undo_desc)
image_map_tool->undo_desc =
g_strdup (GIMP_TOOL (image_map_tool)->tool_info->blurb);
if (im_tool->undo_desc)
{
g_free (im_tool->undo_desc);
im_tool->undo_desc = NULL;
}
gegl_node_get (image_map_tool->operation,
"operation", &operation_name,
NULL);
if (im_tool->icon_name)
{
g_free (im_tool->icon_name);
im_tool->icon_name = NULL;
}
if (im_tool->help_id)
{
g_free (im_tool->help_id);
im_tool->help_id = NULL;
}
operation_name = klass->get_operation (im_tool,
&im_tool->title,
&im_tool->description,
&im_tool->undo_desc,
&im_tool->icon_name,
&im_tool->help_id);
if (! operation_name)
operation_name = g_strdup ("gegl:nop");
if (! im_tool->title)
im_tool->title = g_strdup (tool_info->blurb);
if (! im_tool->description)
im_tool->description = g_strdup (im_tool->title);
if (! im_tool->undo_desc)
im_tool->undo_desc = g_strdup (tool_info->blurb);
if (! im_tool->icon_name)
im_tool->icon_name =
g_strdup (gimp_viewable_get_icon_name (GIMP_VIEWABLE (tool_info)));
if (! im_tool->help_id)
im_tool->help_id = g_strdup (tool_info->help_id);
im_tool->operation = gegl_node_new_child (NULL,
"operation", operation_name,
NULL);
im_tool->config = G_OBJECT (gimp_gegl_config_new (operation_name,
im_tool->icon_name,
GIMP_TYPE_SETTINGS));
gimp_gegl_config_sync_node (GIMP_OBJECT (im_tool->config),
im_tool->operation);
if (im_tool->gui)
{
gimp_tool_gui_set_title (im_tool->gui, im_tool->title);
gimp_tool_gui_set_description (im_tool->gui, im_tool->description);
gimp_tool_gui_set_icon_name (im_tool->gui, im_tool->icon_name);
gimp_tool_gui_set_help_id (im_tool->gui, im_tool->help_id);
}
if (operation_name &&
gegl_operation_get_key (operation_name, "position-dependent"))
{
if (image_map_tool->region_combo)
gtk_widget_show (image_map_tool->region_combo);
if (im_tool->gui)
gtk_widget_show (im_tool->region_combo);
}
else
{
if (image_map_tool->region_combo)
gtk_widget_hide (image_map_tool->region_combo);
if (im_tool->gui)
gtk_widget_hide (im_tool->region_combo);
g_object_set (GIMP_IMAGE_MAP_TOOL_GET_OPTIONS (image_map_tool),
g_object_set (GIMP_IMAGE_MAP_TOOL_GET_OPTIONS (im_tool),
"region", GIMP_IMAGE_MAP_REGION_SELECTION,
NULL);
}
g_free (operation_name);
if (image_map_tool->config)
g_signal_connect_object (image_map_tool->config, "notify",
if (im_tool->config)
g_signal_connect_object (im_tool->config, "notify",
G_CALLBACK (gimp_image_map_tool_config_notify),
G_OBJECT (image_map_tool), 0);
G_OBJECT (im_tool), 0);
if (GIMP_TOOL (image_map_tool)->drawable)
gimp_image_map_tool_create_map (image_map_tool);
if (GIMP_TOOL (im_tool)->drawable)
gimp_image_map_tool_create_map (im_tool);
}
void
gimp_image_map_tool_preview (GimpImageMapTool *image_map_tool)
gimp_image_map_tool_preview (GimpImageMapTool *im_tool)
{
GimpTool *tool;
GimpImageMapOptions *options;
g_return_if_fail (GIMP_IS_IMAGE_MAP_TOOL (image_map_tool));
g_return_if_fail (GIMP_IS_IMAGE_MAP_TOOL (im_tool));
tool = GIMP_TOOL (image_map_tool);
tool = GIMP_TOOL (im_tool);
options = GIMP_IMAGE_MAP_TOOL_GET_OPTIONS (tool);
if (image_map_tool->image_map && options->preview)
if (im_tool->image_map && options->preview)
{
gimp_tool_control_push_preserve (tool->control, TRUE);
gimp_image_map_tool_map (image_map_tool);
gimp_image_map_tool_map (im_tool);
gimp_tool_control_pop_preserve (tool->control);
}

16
app/tools/gimpimagemaptool.h
View File

@ -43,7 +43,12 @@ struct _GimpImageMapTool
GeglNode *operation;
GObject *config;
GObject *default_config;
gchar *title;
gchar *description;
gchar *undo_desc;
gchar *icon_name;
gchar *help_id;
GimpImageMap *image_map;
@ -60,7 +65,6 @@ struct _GimpImageMapToolClass
{
GimpColorToolClass parent_class;
const gchar *dialog_desc;
const gchar *settings_name;
const gchar *import_dialog_title;
const gchar *export_dialog_title;
@ -68,10 +72,12 @@ struct _GimpImageMapToolClass
GimpContainer *recent_settings;
/* virtual functions */
GeglNode * (* get_operation) (GimpImageMapTool *image_map_tool,
GObject **config,
gchar **undo_desc);
void (* map) (GimpImageMapTool *image_map_tool);
gchar * (* get_operation) (GimpImageMapTool *image_map_tool,
gchar **title,
gchar **description,
gchar **undo_desc,
gchar **icon_name,
gchar **help_id);
void (* dialog) (GimpImageMapTool *image_map_tool);
void (* reset) (GimpImageMapTool *image_map_tool);

165
app/tools/gimplevelstool.c
View File

@ -65,15 +65,19 @@
/* local function prototypes */
static void gimp_levels_tool_constructed (GObject *object);
static void gimp_levels_tool_finalize (GObject *object);
static gboolean gimp_levels_tool_initialize (GimpTool *tool,
GimpDisplay *display,
GError **error);
static GeglNode * gimp_levels_tool_get_operation (GimpImageMapTool *im_tool,
GObject **config,
gchar **undo_desc);
static gchar * gimp_levels_tool_get_operation (GimpImageMapTool *im_tool,
gchar **title,
gchar **description,
gchar **undo_desc,
gchar **icon_name,
gchar **help_id);
static void gimp_levels_tool_dialog (GimpImageMapTool *im_tool);
static void gimp_levels_tool_reset (GimpImageMapTool *im_tool);
static gboolean gimp_levels_tool_settings_import(GimpImageMapTool *im_tool,
@ -100,9 +104,9 @@ static void gimp_levels_tool_config_notify (GObject *object,
static void levels_update_input_bar (GimpLevelsTool *tool);
static void levels_channel_callback (GtkWidget *widget,
GimpLevelsTool *tool);
GimpImageMapTool *im_tool);
static void levels_channel_reset_callback (GtkWidget *widget,
GimpLevelsTool *tool);
GimpImageMapTool *im_tool);
static gboolean levels_menu_sensitivity (gint value,
gpointer data);
@ -113,7 +117,7 @@ static void levels_linear_gamma_changed (GtkAdjustment *adjustment
GimpLevelsTool *tool);
static void levels_to_curves_callback (GtkWidget *widget,
GimpLevelsTool *tool);
GimpImageMapTool *im_tool);
G_DEFINE_TYPE (GimpLevelsTool, gimp_levels_tool, GIMP_TYPE_IMAGE_MAP_TOOL)
@ -145,11 +149,11 @@ gimp_levels_tool_class_init (GimpLevelsToolClass *klass)
GimpToolClass *tool_class = GIMP_TOOL_CLASS (klass);
GimpImageMapToolClass *im_tool_class = GIMP_IMAGE_MAP_TOOL_CLASS (klass);
object_class->constructed = gimp_levels_tool_constructed;
object_class->finalize = gimp_levels_tool_finalize;
tool_class->initialize = gimp_levels_tool_initialize;
im_tool_class->dialog_desc = _("Adjust Color Levels");
im_tool_class->settings_name = "levels";
im_tool_class->import_dialog_title = _("Import Levels");
im_tool_class->export_dialog_title = _("Export Levels");
@ -168,6 +172,16 @@ gimp_levels_tool_init (GimpLevelsTool *tool)
tool->histogram = gimp_histogram_new (TRUE);
}
static void
gimp_levels_tool_constructed (GObject *object)
{
G_OBJECT_CLASS (parent_class)->constructed (object);
g_signal_connect_object (GIMP_IMAGE_MAP_TOOL (object)->config, "notify",
G_CALLBACK (gimp_levels_tool_config_notify),
object, 0);
}
static void
gimp_levels_tool_finalize (GObject *object)
{
@ -242,25 +256,17 @@ gimp_levels_tool_initialize (GimpTool *tool,
return TRUE;
}
static GeglNode *
static gchar *
gimp_levels_tool_get_operation (GimpImageMapTool *im_tool,
GObject **config,
gchar **undo_desc)
gchar **title,
gchar **description,
gchar **undo_desc,
gchar **icon_name,
gchar **help_id)
{
GimpLevelsTool *tool = GIMP_LEVELS_TOOL (im_tool);
*description = g_strdup (_("Adjust Color Levels"));
tool->config = g_object_new (GIMP_TYPE_LEVELS_CONFIG, NULL);
g_signal_connect_object (tool->config, "notify",
G_CALLBACK (gimp_levels_tool_config_notify),
G_OBJECT (tool), 0);
*config = G_OBJECT (tool->config);
return gegl_node_new_child (NULL,
"operation", "gimp:levels",
"config", tool->config,
NULL);
return g_strdup ("gimp:levels");
}
@ -316,11 +322,11 @@ gimp_levels_tool_color_picker_new (GimpLevelsTool *tool,
}
static void
gimp_levels_tool_dialog (GimpImageMapTool *image_map_tool)
gimp_levels_tool_dialog (GimpImageMapTool *im_tool)
{
GimpLevelsTool *tool = GIMP_LEVELS_TOOL (image_map_tool);
GimpToolOptions *tool_options = GIMP_TOOL_GET_OPTIONS (image_map_tool);
GimpLevelsConfig *config = tool->config;
GimpLevelsTool *tool = GIMP_LEVELS_TOOL (im_tool);
GimpToolOptions *tool_options = GIMP_TOOL_GET_OPTIONS (im_tool);
GimpLevelsConfig *config = GIMP_LEVELS_CONFIG (im_tool->config);
GtkListStore *store;
GtkWidget *main_vbox;
GtkWidget *frame_vbox;
@ -341,11 +347,11 @@ gimp_levels_tool_dialog (GimpImageMapTool *image_map_tool)
GtkWidget *handle_bar;
gint border;
g_signal_connect (image_map_tool->settings_box, "file-dialog-setup",
g_signal_connect (im_tool->settings_box, "file-dialog-setup",
G_CALLBACK (gimp_levels_tool_export_setup),
image_map_tool);
im_tool);
main_vbox = gimp_image_map_tool_dialog_get_vbox (image_map_tool);
main_vbox = gimp_image_map_tool_dialog_get_vbox (im_tool);
/* The option menu for selecting channels */
main_frame = gimp_frame_new (NULL);
@ -466,7 +472,7 @@ gimp_levels_tool_dialog (GimpImageMapTool *image_map_tool)
gtk_widget_show (button);
tool->low_input_spinbutton = spinbutton =
gimp_prop_spin_button_new (image_map_tool->config, "low-input",
gimp_prop_spin_button_new (im_tool->config, "low-input",
0.01, 0.1, 1);
gtk_box_pack_start (GTK_BOX (hbox2), spinbutton, FALSE, FALSE, 0);
gtk_widget_show (spinbutton);
@ -476,7 +482,7 @@ gimp_levels_tool_dialog (GimpImageMapTool *image_map_tool)
tool->low_input);
/* input gamma spin */
spinbutton = gimp_prop_spin_button_new (image_map_tool->config, "gamma",
spinbutton = gimp_prop_spin_button_new (im_tool->config, "gamma",
0.01, 0.1, 2);
gtk_box_pack_start (GTK_BOX (hbox), spinbutton, TRUE, FALSE, 0);
gimp_help_set_help_data (spinbutton, _("Gamma"), NULL);
@ -503,7 +509,7 @@ gimp_levels_tool_dialog (GimpImageMapTool *image_map_tool)
gtk_box_pack_start (GTK_BOX (hbox2), button, FALSE, FALSE, 0);
gtk_widget_show (button);
spinbutton = gimp_prop_spin_button_new (image_map_tool->config, "high-input",
spinbutton = gimp_prop_spin_button_new (im_tool->config, "high-input",
0.01, 0.1, 1);
gtk_box_pack_start (GTK_BOX (hbox2), spinbutton, FALSE, FALSE, 0);
gtk_widget_show (spinbutton);
@ -552,7 +558,7 @@ gimp_levels_tool_dialog (GimpImageMapTool *image_map_tool)
/* low output spin */
tool->low_output_spinbutton = spinbutton =
gimp_prop_spin_button_new (image_map_tool->config, "low-output",
gimp_prop_spin_button_new (im_tool->config, "low-output",
0.01, 0.1, 1);
gtk_box_pack_start (GTK_BOX (hbox), spinbutton, FALSE, FALSE, 0);
gtk_widget_show (spinbutton);
@ -562,7 +568,7 @@ gimp_levels_tool_dialog (GimpImageMapTool *image_map_tool)
/* high output spin */
tool->high_output_spinbutton = spinbutton =
gimp_prop_spin_button_new (image_map_tool->config, "high-output",
gimp_prop_spin_button_new (im_tool->config, "high-output",
0.01, 0.1, 1);
gtk_box_pack_end (GTK_BOX (hbox), spinbutton, FALSE, FALSE, 0);
gtk_widget_show (spinbutton);
@ -624,26 +630,29 @@ gimp_levels_tool_dialog (GimpImageMapTool *image_map_tool)
}
static void
gimp_levels_tool_reset (GimpImageMapTool *image_map_tool)
gimp_levels_tool_reset (GimpImageMapTool *im_tool)
{
GimpLevelsTool *tool = GIMP_LEVELS_TOOL (image_map_tool);
GimpHistogramChannel channel = tool->config->channel;
GimpHistogramChannel channel;
GIMP_IMAGE_MAP_TOOL_CLASS (parent_class)->reset (image_map_tool);
g_object_get (im_tool->config,
"channel", &channel,
NULL);
g_object_set (tool->config,
GIMP_IMAGE_MAP_TOOL_CLASS (parent_class)->reset (im_tool);
g_object_set (im_tool->config,
"channel", channel,
NULL);
}
static gboolean
gimp_levels_tool_settings_import (GimpImageMapTool *image_map_tool,
gimp_levels_tool_settings_import (GimpImageMapTool *im_tool,
GInputStream *input,
GError **error)
{
GimpLevelsTool *tool = GIMP_LEVELS_TOOL (image_map_tool);
gchar header[64];
gsize bytes_read;
GimpLevelsConfig *config = GIMP_LEVELS_CONFIG (im_tool->config);
gchar header[64];
gsize bytes_read;
if (! g_input_stream_read_all (input, header, sizeof (header),
&bytes_read, NULL, error) ||
@ -656,24 +665,25 @@ gimp_levels_tool_settings_import (GimpImageMapTool *image_map_tool,
g_seekable_seek (G_SEEKABLE (input), 0, G_SEEK_SET, NULL, NULL);
if (g_str_has_prefix (header, "# GIMP Levels File\n"))
return gimp_levels_config_load_cruft (tool->config, input, error);
return gimp_levels_config_load_cruft (config, input, error);
return GIMP_IMAGE_MAP_TOOL_CLASS (parent_class)->settings_import (image_map_tool,
return GIMP_IMAGE_MAP_TOOL_CLASS (parent_class)->settings_import (im_tool,
input,
error);
}
static gboolean
gimp_levels_tool_settings_export (GimpImageMapTool *image_map_tool,
gimp_levels_tool_settings_export (GimpImageMapTool *im_tool,
GOutputStream *output,
GError **error)
{
GimpLevelsTool *tool = GIMP_LEVELS_TOOL (image_map_tool);
GimpLevelsTool *tool = GIMP_LEVELS_TOOL (im_tool);
GimpLevelsConfig *config = GIMP_LEVELS_CONFIG (im_tool->config);
if (tool->export_old_format)
return gimp_levels_config_save_cruft (tool->config, output, error);
return gimp_levels_config_save_cruft (config, output, error);
return GIMP_IMAGE_MAP_TOOL_CLASS (parent_class)->settings_export (image_map_tool,
return GIMP_IMAGE_MAP_TOOL_CLASS (parent_class)->settings_export (im_tool,
output,
error);
}
@ -708,8 +718,9 @@ gimp_levels_tool_color_picked (GimpImageMapTool *color_tool,
const Babl *sample_format,
const GimpRGB *color)
{
GimpLevelsTool *tool = GIMP_LEVELS_TOOL (color_tool);
guint value = GPOINTER_TO_UINT (identifier);
GimpImageMapTool *im_tool = GIMP_IMAGE_MAP_TOOL (color_tool);
GimpLevelsConfig *config = GIMP_LEVELS_CONFIG (im_tool->config);
guint value = GPOINTER_TO_UINT (identifier);
if (value & PICK_ALL_CHANNELS &&
gimp_babl_format_get_base_type (sample_format) == GIMP_RGB)
@ -720,13 +731,13 @@ gimp_levels_tool_color_picked (GimpImageMapTool *color_tool,
switch (value & 0xF)
{
case PICK_LOW_INPUT:
tool->config->low_input[GIMP_HISTOGRAM_VALUE] = 0.0;
config->low_input[GIMP_HISTOGRAM_VALUE] = 0.0;
break;
case PICK_GAMMA:
tool->config->gamma[GIMP_HISTOGRAM_VALUE] = 1.0;
config->gamma[GIMP_HISTOGRAM_VALUE] = 1.0;
break;
case PICK_HIGH_INPUT:
tool->config->high_input[GIMP_HISTOGRAM_VALUE] = 1.0;
config->high_input[GIMP_HISTOGRAM_VALUE] = 1.0;
break;
default:
break;
@ -737,14 +748,12 @@ gimp_levels_tool_color_picked (GimpImageMapTool *color_tool,
channel <= GIMP_HISTOGRAM_BLUE;
channel++)
{
levels_input_adjust_by_color (tool->config,
value, channel, color);
levels_input_adjust_by_color (config, value, channel, color);
}
}
else
{
levels_input_adjust_by_color (tool->config,
value, tool->config->channel, color);
levels_input_adjust_by_color (config, value, config->channel, color);
}
}
@ -807,7 +816,7 @@ gimp_levels_tool_config_notify (GObject *object,
delta = (high - low) / 2.0;
mid = low + delta;
tmp = log10 (1.0 / tool->config->gamma[tool->config->channel]);
tmp = log10 (1.0 / config->gamma[config->channel]);
value = mid + delta * tmp;
gtk_adjustment_set_value (tool->gamma_linear, value);
@ -817,7 +826,8 @@ gimp_levels_tool_config_notify (GObject *object,
static void
levels_update_input_bar (GimpLevelsTool *tool)
{
GimpLevelsConfig *config = tool->config;
GimpImageMapTool *im_tool = GIMP_IMAGE_MAP_TOOL (tool);
GimpLevelsConfig *config = GIMP_LEVELS_CONFIG (im_tool->config);
switch (config->channel)
{
@ -878,25 +888,26 @@ levels_update_input_bar (GimpLevelsTool *tool)
}
static void
levels_channel_callback (GtkWidget *widget,
GimpLevelsTool *tool)
levels_channel_callback (GtkWidget *widget,
GimpImageMapTool *im_tool)
{
gint value;
GimpLevelsConfig *config = GIMP_LEVELS_CONFIG (im_tool->config);
gint value;
if (gimp_int_combo_box_get_active (GIMP_INT_COMBO_BOX (widget), &value) &&
tool->config->channel != value)
config->channel != value)
{
g_object_set (tool->config,
g_object_set (config,
"channel", value,
NULL);
}
}
static void
levels_channel_reset_callback (GtkWidget *widget,
GimpLevelsTool *tool)
levels_channel_reset_callback (GtkWidget *widget,
GimpImageMapTool *im_tool)
{
gimp_levels_config_reset_channel (tool->config);
gimp_levels_config_reset_channel (GIMP_LEVELS_CONFIG (im_tool->config));
}
static gboolean
@ -930,10 +941,11 @@ static void
levels_stretch_callback (GtkWidget *widget,
GimpLevelsTool *tool)
{
GimpDrawable *drawable = GIMP_IMAGE_MAP_TOOL (tool)->drawable;
GimpImageMapTool *im_tool = GIMP_IMAGE_MAP_TOOL (tool);
gimp_levels_config_stretch (tool->config, tool->histogram,
gimp_drawable_is_rgb (drawable));
gimp_levels_config_stretch (GIMP_LEVELS_CONFIG (im_tool->config),
tool->histogram,
gimp_drawable_is_rgb (im_tool->drawable));
}
static void
@ -960,14 +972,15 @@ levels_linear_gamma_changed (GtkAdjustment *adjustment,
}
static void
levels_to_curves_callback (GtkWidget *widget,
GimpLevelsTool *tool)
levels_to_curves_callback (GtkWidget *widget,
GimpImageMapTool *im_tool)
{
GimpLevelsConfig *config = GIMP_LEVELS_CONFIG (im_tool->config);
GimpCurvesConfig *curves;
curves = gimp_levels_config_to_curves_config (tool->config);
curves = gimp_levels_config_to_curves_config (config);
gimp_image_map_tool_edit_as (GIMP_IMAGE_MAP_TOOL (tool),
gimp_image_map_tool_edit_as (im_tool,
"gimp-curves-tool",
GIMP_CONFIG (curves));

2
app/tools/gimplevelstool.h
View File

@ -37,8 +37,6 @@ struct _GimpLevelsTool
{
GimpImageMapTool parent_instance;
GimpLevelsConfig *config;
/* dialog */
GimpHistogram *histogram;

103
app/tools/gimpoperationtool.c
View File

@ -78,10 +78,12 @@ static void gimp_operation_tool_control (GimpTool *tool,
GimpToolAction action,
GimpDisplay *display);
static GeglNode * gimp_operation_tool_get_operation (GimpImageMapTool *im_tool,
GObject **config,
gchar **undo_desc);
static void gimp_operation_tool_map (GimpImageMapTool *im_tool);
static gchar * gimp_operation_tool_get_operation (GimpImageMapTool *im_tool,
gchar **title,
gchar **description,
gchar **undo_desc,
gchar **icon_name,
gchar **help_id);
static void gimp_operation_tool_dialog (GimpImageMapTool *im_tool);
static void gimp_operation_tool_reset (GimpImageMapTool *im_tool);
static GtkWidget * gimp_operation_tool_get_settings_ui (GimpImageMapTool *im_tool,
@ -146,10 +148,7 @@ gimp_operation_tool_class_init (GimpOperationToolClass *klass)
tool_class->initialize = gimp_operation_tool_initialize;
tool_class->control = gimp_operation_tool_control;
im_tool_class->dialog_desc = _("GEGL Operation");
im_tool_class->get_operation = gimp_operation_tool_get_operation;
im_tool_class->map = gimp_operation_tool_map;
im_tool_class->dialog = gimp_operation_tool_dialog;
im_tool_class->reset = gimp_operation_tool_reset;
im_tool_class->get_settings_ui = gimp_operation_tool_get_settings_ui;
@ -179,6 +178,12 @@ gimp_operation_tool_finalize (GObject *object)
tool->title = NULL;
}
if (tool->description)
{
g_free (tool->description);
tool->description = NULL;
}
if (tool->undo_desc)
{
g_free (tool->undo_desc);
@ -250,37 +255,23 @@ gimp_operation_tool_control (GimpTool *tool,
GIMP_TOOL_CLASS (parent_class)->control (tool, action, display);
}
static GeglNode *
static gchar *
gimp_operation_tool_get_operation (GimpImageMapTool *im_tool,
GObject **config,
gchar **undo_desc)
gchar **title,
gchar **description,
gchar **undo_desc,
gchar **icon_name,
gchar **help_id)
{
GimpOperationTool *tool = GIMP_OPERATION_TOOL (im_tool);
if (tool->operation)
*config = G_OBJECT (gimp_gegl_config_new (tool->operation,
tool->icon_name,
GIMP_TYPE_SETTINGS));
*title = g_strdup (tool->title);
*description = g_strdup (tool->description);
*undo_desc = g_strdup (tool->undo_desc);
*icon_name = g_strdup (tool->icon_name);
*help_id = g_strdup (tool->help_id);
if (tool->undo_desc)
*undo_desc = g_strdup (tool->undo_desc);
if (tool->operation)
return gegl_node_new_child (NULL,
"operation", tool->operation,
NULL);
return gegl_node_new_child (NULL,
"operation", "gegl:nop",
NULL);
}
static void
gimp_operation_tool_map (GimpImageMapTool *im_tool)
{
if (im_tool->config)
gimp_gegl_config_sync_node (GIMP_OBJECT (im_tool->config),
im_tool->operation);
return g_strdup (tool->operation);
}
static void
@ -313,18 +304,6 @@ gimp_operation_tool_dialog (GimpImageMapTool *im_tool)
FALSE, FALSE, 0);
gtk_widget_show (tool->options_gui);
}
if (tool->title)
gimp_tool_gui_set_title (im_tool->gui, tool->title);
if (tool->undo_desc)
gimp_tool_gui_set_description (im_tool->gui, tool->undo_desc);
if (tool->icon_name)
gimp_tool_gui_set_icon_name (im_tool->gui, tool->icon_name);
if (tool->help_id)
gimp_tool_gui_set_help_id (im_tool->gui, tool->help_id);
}
static void
@ -366,8 +345,8 @@ gimp_operation_tool_get_settings_ui (GimpImageMapTool *im_tool,
file = gimp_directory_file ("filters", basename, NULL);
g_free (basename);
import_title = g_strdup_printf (_("Import '%s' Settings"), tool->undo_desc);
export_title = g_strdup_printf (_("Export '%s' Settings"), tool->undo_desc);
import_title = g_strdup_printf (_("Import '%s' Settings"), tool->title);
export_title = g_strdup_printf (_("Export '%s' Settings"), tool->title);
widget =
GIMP_IMAGE_MAP_TOOL_CLASS (parent_class)->get_settings_ui (im_tool,
@ -638,6 +617,7 @@ void
gimp_operation_tool_set_operation (GimpOperationTool *tool,
const gchar *operation,
const gchar *title,
const gchar *description,
const gchar *undo_desc,
const gchar *icon_name,
const gchar *help_id)
@ -657,6 +637,9 @@ gimp_operation_tool_set_operation (GimpOperationTool *tool,
if (tool->title)
g_free (tool->title);
if (tool->description)
g_free (tool->description);
if (tool->undo_desc)
g_free (tool->undo_desc);
@ -666,11 +649,12 @@ gimp_operation_tool_set_operation (GimpOperationTool *tool,
if (tool->help_id)
g_free (tool->help_id);
tool->operation = g_strdup (operation);
tool->title = g_strdup (title);
tool->undo_desc = g_strdup (undo_desc);
tool->icon_name = g_strdup (icon_name);
tool->help_id = g_strdup (help_id);
tool->operation = g_strdup (operation);
tool->title = g_strdup (title);
tool->description = g_strdup (description);
tool->undo_desc = g_strdup (undo_desc);
tool->icon_name = g_strdup (icon_name);
tool->help_id = g_strdup (help_id);
g_list_free_full (tool->aux_inputs,
(GDestroyNotify) gimp_operation_tool_aux_input_free);
@ -761,21 +745,6 @@ gimp_operation_tool_set_operation (GimpOperationTool *tool,
}
}
if (im_tool->gui)
{
if (title)
gimp_tool_gui_set_title (im_tool->gui, title);
if (undo_desc)
gimp_tool_gui_set_description (im_tool->gui, undo_desc);
if (icon_name)
gimp_tool_gui_set_icon_name (im_tool->gui, icon_name);
if (help_id)
gimp_tool_gui_set_help_id (im_tool->gui, help_id);
}
if (GIMP_TOOL (tool)->drawable)
{
gimp_operation_tool_sync_op (tool, GIMP_TOOL (tool)->drawable);

2
app/tools/gimpoperationtool.h
View File

@ -39,6 +39,7 @@ struct _GimpOperationTool
gchar *operation;
gchar *title;
gchar *description;
gchar *undo_desc;
gchar *icon_name;
gchar *help_id;
@ -64,6 +65,7 @@ GType gimp_operation_tool_get_type (void) G_GNUC_CONST;
void gimp_operation_tool_set_operation (GimpOperationTool *tool,
const gchar *operation,
const gchar *title,
const gchar *description,
const gchar *undo_desc,
const gchar *icon_name,
const gchar *help_id);

116
app/tools/gimpthresholdtool.c
View File

@ -25,8 +25,6 @@
#include "tools-types.h"
#include "operations/gimpthresholdconfig.h"
#include "core/gimpdrawable.h"
#include "core/gimpdrawable-histogram.h"
#include "core/gimperror.h"
@ -47,15 +45,19 @@
/* local function prototypes */
static void gimp_threshold_tool_constructed (GObject *object);
static void gimp_threshold_tool_finalize (GObject *object);
static gboolean gimp_threshold_tool_initialize (GimpTool *tool,
GimpDisplay *display,
GError **error);
static GeglNode * gimp_threshold_tool_get_operation (GimpImageMapTool *im_tool,
GObject **config,
gchar **undo_desc);
static gchar * gimp_threshold_tool_get_operation (GimpImageMapTool *im_tool,
gchar **title,
gchar **description,
gchar **undo_desc,
gchar **icon_name,
gchar **help_id);
static void gimp_threshold_tool_dialog (GimpImageMapTool *im_tool);
static void gimp_threshold_tool_config_notify (GObject *object,
@ -100,11 +102,11 @@ gimp_threshold_tool_class_init (GimpThresholdToolClass *klass)
GimpToolClass *tool_class = GIMP_TOOL_CLASS (klass);
GimpImageMapToolClass *im_tool_class = GIMP_IMAGE_MAP_TOOL_CLASS (klass);
object_class->constructed = gimp_threshold_tool_constructed;
object_class->finalize = gimp_threshold_tool_finalize;
tool_class->initialize = gimp_threshold_tool_initialize;
im_tool_class->dialog_desc = _("Apply Threshold");
im_tool_class->settings_name = "threshold";
im_tool_class->import_dialog_title = _("Import Threshold Settings");
im_tool_class->export_dialog_title = _("Export Threshold Settings");
@ -119,6 +121,16 @@ gimp_threshold_tool_init (GimpThresholdTool *t_tool)
t_tool->histogram = gimp_histogram_new (TRUE);
}
static void
gimp_threshold_tool_constructed (GObject *object)
{
G_OBJECT_CLASS (parent_class)->constructed (object);
g_signal_connect_object (GIMP_IMAGE_MAP_TOOL (object)->config, "notify",
G_CALLBACK (gimp_threshold_tool_config_notify),
object, 0);
}
static void
gimp_threshold_tool_finalize (GObject *object)
{
@ -154,25 +166,17 @@ gimp_threshold_tool_initialize (GimpTool *tool,
return TRUE;
}
static GeglNode *
gimp_threshold_tool_get_operation (GimpImageMapTool *image_map_tool,
GObject **config,
gchar **undo_desc)
static gchar *
gimp_threshold_tool_get_operation (GimpImageMapTool *im_tool,
gchar **title,
gchar **description,
gchar **undo_desc,
gchar **icon_name,
gchar **help_id)
{
GimpThresholdTool *t_tool = GIMP_THRESHOLD_TOOL (image_map_tool);
*description = g_strdup (_("Apply Threshold"));
t_tool->config = g_object_new (GIMP_TYPE_THRESHOLD_CONFIG, NULL);
g_signal_connect_object (t_tool->config, "notify",
G_CALLBACK (gimp_threshold_tool_config_notify),
G_OBJECT (t_tool), 0);
*config = G_OBJECT (t_tool->config);
return gegl_node_new_child (NULL,
"operation", "gimp:threshold",
"config", t_tool->config,
NULL);
return g_strdup ("gimp:threshold");
}
@ -181,19 +185,20 @@ gimp_threshold_tool_get_operation (GimpImageMapTool *image_map_tool,
/**********************/
static void
gimp_threshold_tool_dialog (GimpImageMapTool *image_map_tool)
gimp_threshold_tool_dialog (GimpImageMapTool *im_tool)
{
GimpThresholdTool *t_tool = GIMP_THRESHOLD_TOOL (image_map_tool);
GimpToolOptions *tool_options = GIMP_TOOL_GET_OPTIONS (image_map_tool);
GimpThresholdConfig *config = t_tool->config;
GtkWidget *main_vbox;
GtkWidget *hbox;
GtkWidget *menu;
GtkWidget *box;
GtkWidget *button;
gint n_bins;
GimpThresholdTool *t_tool = GIMP_THRESHOLD_TOOL (im_tool);
GimpToolOptions *tool_options = GIMP_TOOL_GET_OPTIONS (im_tool);
GtkWidget *main_vbox;
GtkWidget *hbox;
GtkWidget *menu;
GtkWidget *box;
GtkWidget *button;
gdouble low;
gdouble high;
gint n_bins;
main_vbox = gimp_image_map_tool_dialog_get_vbox (image_map_tool);
main_vbox = gimp_image_map_tool_dialog_get_vbox (im_tool);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, FALSE, 0);
@ -211,11 +216,16 @@ gimp_threshold_tool_dialog (GimpImageMapTool *image_map_tool)
t_tool->histogram_box = GIMP_HISTOGRAM_BOX (box);
g_object_get (im_tool->config,
"low", &low,
"high", &high,
NULL);
n_bins = gimp_histogram_n_bins (t_tool->histogram);
gimp_histogram_view_set_range (t_tool->histogram_box->view,
config->low * (n_bins - 0.0001),
config->high * (n_bins - 0.0001));
low * (n_bins - 0.0001),
high * (n_bins - 0.0001));
g_signal_connect (t_tool->histogram_box->view, "range-changed",
G_CALLBACK (gimp_threshold_tool_histogram_range),
@ -244,17 +254,23 @@ gimp_threshold_tool_config_notify (GObject *object,
GParamSpec *pspec,
GimpThresholdTool *t_tool)
{
GimpThresholdConfig *config = GIMP_THRESHOLD_CONFIG (object);
gint n_bins;
gdouble low;
gdouble high;
gint n_bins;
if (! t_tool->histogram_box)
return;
g_object_get (object,
"low", &low,
"high", &high,
NULL);
n_bins = gimp_histogram_n_bins (t_tool->histogram);
gimp_histogram_view_set_range (t_tool->histogram_box->view,
config->low * (n_bins - 0.0001),
config->high * (n_bins - 0.0001));
low * (n_bins - 0.0001),
high * (n_bins - 0.0001));
}
static void
@ -263,14 +279,22 @@ gimp_threshold_tool_histogram_range (GimpHistogramView *widget,
gint end,
GimpThresholdTool *t_tool)
{
gint n_bins = gimp_histogram_n_bins (t_tool->histogram);
gdouble low = (gdouble) start / (n_bins - 1);
gdouble high = (gdouble) end / (n_bins - 1);
GimpImageMapTool *im_tool = GIMP_IMAGE_MAP_TOOL (t_tool);
gint n_bins = gimp_histogram_n_bins (t_tool->histogram);
gdouble low = (gdouble) start / (n_bins - 1);
gdouble high = (gdouble) end / (n_bins - 1);
gdouble config_low;
gdouble config_high;
if (low != t_tool->config->low ||
high != t_tool->config->high)
g_object_get (im_tool->config,
"low", &config_low,
"high", &config_high,
NULL);
if (low != config_low ||
high != config_high)
{
g_object_set (t_tool->config,
g_object_set (im_tool->config,
"low", low,
"high", high,
NULL);

8
app/tools/gimpthresholdtool.h
View File

@ -35,13 +35,11 @@ typedef struct _GimpThresholdToolClass GimpThresholdToolClass;
struct _GimpThresholdTool
{
GimpImageMapTool parent_instance;
GimpThresholdConfig *config;
GimpImageMapTool parent_instance;
/* dialog */
GimpHistogram *histogram;
GimpHistogramBox *histogram_box;
GimpHistogram *histogram;
GimpHistogramBox *histogram_box;
};
struct _GimpThresholdToolClass