static void
gimp_curves_tool_color_picked (GimpColorTool *color_tool,
GimpColorPickState pick_state,
gdouble x,
gdouble y,
const Babl *sample_format,
gpointer pixel,
const GimpRGB *color)
{
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;
tool->picked_color[GIMP_HISTOGRAM_RED] = color->r;
tool->picked_color[GIMP_HISTOGRAM_GREEN] = color->g;
tool->picked_color[GIMP_HISTOGRAM_BLUE] = color->b;
if (gimp_drawable_has_alpha (drawable))
tool->picked_color[GIMP_HISTOGRAM_ALPHA] = color->a;
else
tool->picked_color[GIMP_HISTOGRAM_ALPHA] = -1;
tool->picked_color[GIMP_HISTOGRAM_VALUE] = MAX (MAX (color->r, color->g),
color->b);
gimp_curve_view_set_xpos (GIMP_CURVE_VIEW (tool->graph),
tool->picked_color[config->channel]);
}
void
gimp_image_map_tool_edit_as (GimpImageMapTool *im_tool,
const gchar *new_tool_id,
GimpConfig *config)
{
GimpDisplay *display;
GimpContext *user_context;
GimpToolInfo *tool_info;
GimpTool *new_tool;
g_return_if_fail (GIMP_IS_IMAGE_MAP_TOOL (im_tool));
g_return_if_fail (new_tool_id);
g_return_if_fail (GIMP_IS_CONFIG (config));
display = GIMP_TOOL (im_tool)->display;
user_context = gimp_get_user_context (display->gimp);
tool_info = (GimpToolInfo *)
gimp_container_get_child_by_name (display->gimp->tool_info_list,
new_tool_id);
gimp_context_set_tool (user_context, tool_info);
tool_manager_initialize_active (display->gimp, display);
new_tool = tool_manager_get_active (display->gimp);
GIMP_IMAGE_MAP_TOOL (new_tool)->default_config = g_object_ref (config);
gimp_image_map_tool_reset (GIMP_IMAGE_MAP_TOOL (new_tool));
}
static void
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);
if (! strcmp (pspec->name, "preview") &&
image_map_tool->image_map)
{
if (im_options->preview)
{
gimp_tool_control_push_preserve (tool->control, TRUE);
gimp_image_map_tool_map (image_map_tool);
gimp_tool_control_pop_preserve (tool->control);
}
else
{
gimp_tool_control_push_preserve (tool->control, TRUE);
gimp_image_map_abort (image_map_tool->image_map);
gimp_tool_control_pop_preserve (tool->control);
}
}
else if (! strcmp (pspec->name, "region") &&
image_map_tool->image_map)
{
gimp_image_map_set_region (image_map_tool->image_map, im_options->region);
gimp_image_map_tool_preview (image_map_tool);
}
}
static void
gimp_colorize_tool_config_notify (GObject *object,
GParamSpec *pspec,
GimpColorizeTool *col_tool)
{
GimpColorizeConfig *config = GIMP_COLORIZE_CONFIG (object);
if (! col_tool->hue_data)
return;
if (! strcmp (pspec->name, "hue"))
{
gtk_adjustment_set_value (col_tool->hue_data,
config->hue * 360.0);
}
else if (! strcmp (pspec->name, "saturation"))
{
gtk_adjustment_set_value (col_tool->saturation_data,
config->saturation * 100.0);
}
else if (! strcmp (pspec->name, "lightness"))
{
gtk_adjustment_set_value (col_tool->lightness_data,
config->lightness * 100.0);
}
gimp_image_map_tool_preview (GIMP_IMAGE_MAP_TOOL (col_tool));
}
static gboolean
gimp_colorize_tool_initialize (GimpTool *tool,
GimpDisplay *display,
GError **error)
{
GimpColorizeTool *col_tool = GIMP_COLORIZE_TOOL (tool);
GimpDrawable *drawable = gimp_image_get_active_drawable (display->image);
if (! drawable)
return FALSE;
if (! gimp_drawable_is_rgb (drawable))
{
g_set_error (error, 0, 0,
_("Colorize operates only on RGB color layers."));
return FALSE;
}
gimp_config_reset (GIMP_CONFIG (col_tool->config));
GIMP_TOOL_CLASS (parent_class)->initialize (tool, display, error);
gimp_image_map_tool_preview (GIMP_IMAGE_MAP_TOOL (tool));
return TRUE;
}
static gboolean
gimp_desaturate_tool_initialize (GimpTool *tool,
GimpDisplay *display,
GError **error)
{
GimpDesaturateTool *desaturate_tool = GIMP_DESATURATE_TOOL (tool);
GimpDrawable *drawable;
drawable = gimp_image_get_active_drawable (display->image);
if (! drawable)
return FALSE;
if (! gimp_drawable_is_rgb (drawable))
{
g_set_error (error, 0, 0,
_("Desaturate does only operate on RGB layers."));
return FALSE;
}
gimp_config_reset (GIMP_CONFIG (desaturate_tool->config));
GIMP_TOOL_CLASS (parent_class)->initialize (tool, display, error);
gimp_int_radio_group_set_active (GTK_RADIO_BUTTON (desaturate_tool->button),
desaturate_tool->config->mode);
gimp_image_map_tool_preview (GIMP_IMAGE_MAP_TOOL (desaturate_tool));
return TRUE;
}
static void
gimp_operation_tool_dialog (GimpImageMapTool *image_map_tool)
{
GimpOperationTool *tool = GIMP_OPERATION_TOOL (image_map_tool);
GtkWidget *main_vbox;
main_vbox = gimp_image_map_tool_dialog_get_vbox (image_map_tool);
/* The options vbox */
tool->options_box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_box_pack_start (GTK_BOX (main_vbox), tool->options_box,
FALSE, FALSE, 0);
gtk_widget_show (tool->options_box);
if (tool->options_table)
{
gtk_container_add (GTK_CONTAINER (tool->options_box),
tool->options_table);
gtk_widget_show (tool->options_table);
}
if (tool->undo_desc)
g_object_set (GIMP_IMAGE_MAP_TOOL (tool)->dialog,
"description", tool->undo_desc,
NULL);
}
static void
gimp_curves_tool_color_picked (GimpColorTool *color_tool,
GimpColorPickState pick_state,
GimpImageType sample_type,
GimpRGB *color,
gint color_index)
{
GimpCurvesTool *tool = GIMP_CURVES_TOOL (color_tool);
GimpDrawable *drawable;
drawable = GIMP_IMAGE_MAP_TOOL (tool)->drawable;
tool->picked_color[GIMP_HISTOGRAM_RED] = color->r;
tool->picked_color[GIMP_HISTOGRAM_GREEN] = color->g;
tool->picked_color[GIMP_HISTOGRAM_BLUE] = color->b;
if (gimp_drawable_has_alpha (drawable))
tool->picked_color[GIMP_HISTOGRAM_ALPHA] = color->a;
tool->picked_color[GIMP_HISTOGRAM_VALUE] = MAX (MAX (color->r, color->g),
color->b);
gimp_curve_view_set_xpos (GIMP_CURVE_VIEW (tool->graph),
tool->picked_color[tool->config->channel]);
}
static gboolean
gimp_posterize_tool_initialize (GimpTool *tool,
GimpDisplay *display,
GError **error)
{
GimpPosterizeTool *posterize_tool = GIMP_POSTERIZE_TOOL (tool);
GimpImage *image = gimp_display_get_image (display);
GimpDrawable *drawable;
drawable = gimp_image_get_active_drawable (image);
if (! drawable)
return FALSE;
if (gimp_drawable_is_indexed (drawable))
{
g_set_error_literal (error, GIMP_ERROR, GIMP_FAILED,
_("Posterize does not operate on indexed layers."));
return FALSE;
}
gimp_config_reset (GIMP_CONFIG (posterize_tool->config));
if (! GIMP_TOOL_CLASS (parent_class)->initialize (tool, display, error))
{
return FALSE;
}
gtk_adjustment_set_value (posterize_tool->levels_data,
posterize_tool->config->levels);
gimp_image_map_tool_preview (GIMP_IMAGE_MAP_TOOL (posterize_tool));
return TRUE;
}
static void
brightness_contrast_config_notify (GObject *object,
GParamSpec *pspec,
GimpBrightnessContrastTool *bc_tool)
{
GimpBrightnessContrastConfig *config;
config = GIMP_BRIGHTNESS_CONTRAST_CONFIG (object);
if (! bc_tool->brightness_data)
return;
if (! strcmp (pspec->name, "brightness"))
{
gtk_adjustment_set_value (bc_tool->brightness_data,
config->brightness * 127.0);
}
else if (! strcmp (pspec->name, "contrast"))
{
gtk_adjustment_set_value (bc_tool->contrast_data,
config->contrast * 127.0);
}
gimp_image_map_tool_preview (GIMP_IMAGE_MAP_TOOL (bc_tool));
}
static gboolean
gimp_threshold_tool_initialize (GimpTool *tool,
GimpDisplay *display,
GError **error)
{
GimpThresholdTool *t_tool = GIMP_THRESHOLD_TOOL (tool);
GimpImage *image = gimp_display_get_image (display);
GimpDrawable *drawable = gimp_image_get_active_drawable (image);
if (! drawable)
return FALSE;
gimp_config_reset (GIMP_CONFIG (t_tool->config));
if (! GIMP_TOOL_CLASS (parent_class)->initialize (tool, display, error))
{
return FALSE;
}
gimp_drawable_calculate_histogram (drawable, t_tool->histogram);
gimp_histogram_view_set_histogram (t_tool->histogram_box->view,
t_tool->histogram);
gimp_image_map_tool_preview (GIMP_IMAGE_MAP_TOOL (t_tool));
return TRUE;
}
static GtkWidget *
gimp_levels_tool_color_picker_new (GimpLevelsTool *tool,
guint value)
{
const gchar *stock_id;
const gchar *help;
switch (value & 0xF)
{
case PICK_LOW_INPUT:
stock_id = GIMP_STOCK_COLOR_PICKER_BLACK;
help = _("Pick black point");
break;
case PICK_GAMMA:
stock_id = GIMP_STOCK_COLOR_PICKER_GRAY;
help = _("Pick gray point");
break;
case PICK_HIGH_INPUT:
stock_id = GIMP_STOCK_COLOR_PICKER_WHITE;
help = _("Pick white point");
break;
default:
return NULL;
}
return gimp_image_map_tool_add_color_picker (GIMP_IMAGE_MAP_TOOL (tool),
GUINT_TO_POINTER (value),
stock_id,
help);
}
static gboolean
gimp_image_map_tool_key_press (GimpTool *tool,
GdkEventKey *kevent,
GimpDisplay *display)
{
GimpImageMapTool *image_map_tool = GIMP_IMAGE_MAP_TOOL (tool);
if (display == tool->display)
{
switch (kevent->keyval)
{
case GDK_Return:
case GDK_KP_Enter:
case GDK_ISO_Enter:
gimp_image_map_tool_response (NULL, GTK_RESPONSE_OK, image_map_tool);
return TRUE;
case GDK_BackSpace:
gimp_image_map_tool_response (NULL, RESPONSE_RESET, image_map_tool);
return TRUE;
case GDK_Escape:
gimp_image_map_tool_response (NULL, GTK_RESPONSE_CANCEL, image_map_tool);
return TRUE;
}
}
return FALSE;
}
static void
gimp_gegl_tool_config_notify (GObject *object,
GParamSpec *pspec,
GimpGeglTool *tool)
{
gimp_image_map_tool_preview (GIMP_IMAGE_MAP_TOOL (tool));
}
static void
gimp_operation_tool_aux_input_notify (GimpBufferSourceBox *box,
const GParamSpec *pspec,
GimpOperationTool *tool)
{
gimp_image_map_tool_preview (GIMP_IMAGE_MAP_TOOL (tool));
}
static void
gimp_image_map_tool_finalize (GObject *object)
{
GimpImageMapTool *image_map_tool = GIMP_IMAGE_MAP_TOOL (object);
if (image_map_tool->operation)
{
g_object_unref (image_map_tool->operation);
image_map_tool->operation = NULL;
}
if (image_map_tool->config)
{
g_object_unref (image_map_tool->config);
image_map_tool->config = NULL;
}
if (image_map_tool->default_config)
{
g_object_unref (image_map_tool->default_config);
image_map_tool->default_config = NULL;
}
if (image_map_tool->shell)
{
gtk_widget_destroy (image_map_tool->shell);
image_map_tool->shell = NULL;
image_map_tool->main_vbox = NULL;
image_map_tool->settings_box = NULL;
image_map_tool->label_group = NULL;
}
G_OBJECT_CLASS (parent_class)->finalize (object);
}
static void
gimp_levels_tool_color_picked (GimpColorTool *color_tool,
GimpColorPickState pick_state,
GimpImageType sample_type,
GimpRGB *color,
gint color_index)
{
GimpLevelsTool *tool = GIMP_LEVELS_TOOL (color_tool);
guchar col[5];
guint value;
gimp_rgba_get_uchar (color,
col + RED_PIX,
col + GREEN_PIX,
col + BLUE_PIX,
col + ALPHA_PIX);
value = GPOINTER_TO_UINT (g_object_get_data (G_OBJECT (tool->active_picker),
"pick_value"));
if (value & ALL_CHANNELS && GIMP_IMAGE_TYPE_IS_RGB (sample_type))
{
GimpHistogramChannel channel;
/* first reset the value channel */
switch (value & 0xF)
{
case LOW_INPUT:
tool->levels->low_input[GIMP_HISTOGRAM_VALUE] = 0;
break;
case GAMMA:
tool->levels->gamma[GIMP_HISTOGRAM_VALUE] = 1.0;
break;
case HIGH_INPUT:
tool->levels->high_input[GIMP_HISTOGRAM_VALUE] = 255;
break;
default:
break;
}
/* then adjust all color channels */
for (channel = GIMP_HISTOGRAM_RED;
channel <= GIMP_HISTOGRAM_BLUE;
channel++)
{
levels_input_adjust_by_color (tool->levels,
value, channel, col);
}
}
else
{
levels_input_adjust_by_color (tool->levels,
value, tool->channel, col);
}
levels_update (tool, ALL);
gimp_image_map_tool_preview (GIMP_IMAGE_MAP_TOOL (tool));
}
static void
gimp_desaturate_tool_init (GimpDesaturateTool *desaturate_tool)
{
GimpImageMapTool *im_tool = GIMP_IMAGE_MAP_TOOL (desaturate_tool);
im_tool->apply_func = (GimpImageMapApplyFunc) desaturate_region;
im_tool->apply_data = &desaturate_tool->mode;
}
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_image_map_tool_constructed (GObject *object)
{
GimpImageMapTool *im_tool = GIMP_IMAGE_MAP_TOOL (object);
G_OBJECT_CLASS (parent_class)->constructed (object);
gimp_image_map_tool_get_operation (im_tool);
}
static void
levels_stretch_callback (GtkWidget *widget,
GimpLevelsTool *tool)
{
levels_stretch (tool->levels, tool->hist, tool->color);
levels_update (tool, ALL);
gimp_image_map_tool_preview (GIMP_IMAGE_MAP_TOOL (tool));
}
static void
levels_channel_reset_callback (GtkWidget *widget,
GimpLevelsTool *tool)
{
levels_channel_reset (tool->levels, tool->channel);
levels_update (tool, ALL);
gimp_image_map_tool_preview (GIMP_IMAGE_MAP_TOOL (tool));
}
static void
gimp_posterize_tool_init (GimpPosterizeTool *posterize_tool)
{
GimpImageMapTool *im_tool = GIMP_IMAGE_MAP_TOOL (posterize_tool);
posterize_tool->lut = gimp_lut_new ();
im_tool->apply_func = (GimpImageMapApplyFunc) gimp_lut_process;
im_tool->apply_data = posterize_tool->lut;
}
static void
gimp_brightness_contrast_tool_init (GimpBrightnessContrastTool *bc_tool)
{
GimpImageMapTool *im_tool = GIMP_IMAGE_MAP_TOOL (bc_tool);
bc_tool->lut = gimp_lut_new ();
im_tool->apply_func = (GimpImageMapApplyFunc) gimp_lut_process;
im_tool->apply_data = bc_tool->lut;
}
static void
gimp_operation_tool_dialog (GimpImageMapTool *im_tool)
{
GimpOperationTool *tool = GIMP_OPERATION_TOOL (im_tool);
GtkWidget *main_vbox;
main_vbox = gimp_image_map_tool_dialog_get_vbox (im_tool);
/* The options vbox */
tool->options_box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2);
gtk_box_pack_start (GTK_BOX (main_vbox), tool->options_box,
FALSE, FALSE, 0);
gtk_widget_show (tool->options_box);
if (tool->aux_input_box)
{
gtk_box_pack_start (GTK_BOX (tool->options_box), tool->aux_input_box,
FALSE, FALSE, 0);
gtk_widget_show (tool->aux_input_box);
}
if (tool->aux2_input_box)
{
gtk_box_pack_start (GTK_BOX (tool->options_box), tool->aux2_input_box,
FALSE, FALSE, 0);
gtk_widget_show (tool->aux2_input_box);
}
if (tool->options_gui)
{
gtk_box_pack_start (GTK_BOX (tool->options_box), tool->options_gui,
FALSE, FALSE, 0);
gtk_widget_show (tool->options_gui);
}
if (tool->undo_desc)
gimp_tool_gui_set_description (GIMP_IMAGE_MAP_TOOL (tool)->gui,
tool->undo_desc);
if (tool->icon_name)
gimp_tool_gui_set_icon_name (GIMP_IMAGE_MAP_TOOL (tool)->gui,
tool->icon_name);
}
static void
gimp_curves_tool_button_release (GimpTool *tool,
const GimpCoords *coords,
guint32 time,
GdkModifierType state,
GimpButtonReleaseType release_type,
GimpDisplay *display)
{
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 ())
{
GimpCurve *curve = config->curve[config->channel];
gdouble value = c_tool->picked_color[config->channel];
gint closest;
closest = gimp_curve_get_closest_point (curve, value);
gimp_curve_view_set_selected (GIMP_CURVE_VIEW (c_tool->graph),
closest);
gimp_curve_set_point (curve, closest,
value, gimp_curve_map_value (curve, value));
}
else if (state & gimp_get_toggle_behavior_mask ())
{
GimpHistogramChannel channel;
for (channel = GIMP_HISTOGRAM_VALUE;
channel <= GIMP_HISTOGRAM_ALPHA;
channel++)
{
GimpCurve *curve = config->curve[channel];
gdouble value = c_tool->picked_color[channel];
gint closest;
if (value != -1)
{
closest = gimp_curve_get_closest_point (curve, value);
gimp_curve_view_set_selected (GIMP_CURVE_VIEW (c_tool->graph),
closest);
gimp_curve_set_point (curve, closest,
value, gimp_curve_map_value (curve, value));
}
}
}
/* chain up to halt the tool */
GIMP_TOOL_CLASS (parent_class)->button_release (tool, coords, time, state,
release_type, display);
}
static void
gimp_hue_saturation_tool_init (GimpHueSaturationTool *hs_tool)
{
GimpImageMapTool *im_tool = GIMP_IMAGE_MAP_TOOL (hs_tool);
hs_tool->hue_saturation = g_slice_new0 (HueSaturation);
hue_saturation_init (hs_tool->hue_saturation);
im_tool->apply_func = (GimpImageMapApplyFunc) hue_saturation;
im_tool->apply_data = hs_tool->hue_saturation;
}
static void
gimp_color_balance_tool_init (GimpColorBalanceTool *cb_tool)
{
GimpImageMapTool *im_tool = GIMP_IMAGE_MAP_TOOL (cb_tool);
cb_tool->color_balance = g_slice_new0 (ColorBalance);
color_balance_init (cb_tool->color_balance);
im_tool->apply_func = (GimpImageMapApplyFunc) color_balance;
im_tool->apply_data = cb_tool->color_balance;
}
static void
levels_gamma_adjustment_update (GtkAdjustment *adjustment,
GimpLevelsTool *tool)
{
if (tool->levels->gamma[tool->channel] != adjustment->value)
{
tool->levels->gamma[tool->channel] = adjustment->value;
levels_update (tool, INPUT_LEVELS | INPUT_SLIDERS);
gimp_image_map_tool_preview (GIMP_IMAGE_MAP_TOOL (tool));
}
}
static void
gimp_levels_tool_init (GimpLevelsTool *tool)
{
GimpImageMapTool *im_tool = GIMP_IMAGE_MAP_TOOL (tool);
tool->lut = gimp_lut_new ();
tool->histogram = gimp_histogram_new ();
tool->active_picker = NULL;
im_tool->apply_func = (GimpImageMapApplyFunc) gimp_lut_process;
im_tool->apply_data = tool->lut;
}