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 void
gimp_gegl_tool_config_notify (GObject *object,
GParamSpec *pspec,
GimpGeglTool *tool)
{
gimp_image_map_tool_preview (GIMP_IMAGE_MAP_TOOL (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 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_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 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_config_notify (GObject *object,
const GParamSpec *pspec,
GimpImageMapTool *im_tool)
{
gimp_image_map_tool_preview (im_tool);
}
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_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_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
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
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
gamma_hack (GtkToggleButton *button,
GimpImageMapTool *im_tool)
{
if (im_tool->image_map)
{
gimp_image_map_set_gamma_hack (im_tool->image_map,
gtk_toggle_button_get_active (button));
gimp_image_map_tool_preview (im_tool);
}
}
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_posterize_tool_config_notify (GObject *object,
GParamSpec *pspec,
GimpPosterizeTool *posterize_tool)
{
GimpPosterizeConfig *config = GIMP_POSTERIZE_CONFIG (object);
if (! posterize_tool->levels_data)
return;
gtk_adjustment_set_value (posterize_tool->levels_data, config->levels);
gimp_image_map_tool_preview (GIMP_IMAGE_MAP_TOOL (posterize_tool));
}
static void
levels_high_output_adjustment_update (GtkAdjustment *adjustment,
GimpLevelsTool *tool)
{
gint value = ROUND (adjustment->value);
if (tool->levels->high_output[tool->channel] != value)
{
tool->levels->high_output[tool->channel] = value;
levels_update (tool, OUTPUT_LEVELS | OUTPUT_SLIDERS);
gimp_image_map_tool_preview (GIMP_IMAGE_MAP_TOOL (tool));
}
}
static void
gimp_desaturate_tool_config_notify (GObject *object,
GParamSpec *pspec,
GimpDesaturateTool *desaturate_tool)
{
GimpDesaturateConfig *config = GIMP_DESATURATE_CONFIG (object);
if (! desaturate_tool->button)
return;
gimp_int_radio_group_set_active (GTK_RADIO_BUTTON (desaturate_tool->button),
config->mode);
gimp_image_map_tool_preview (GIMP_IMAGE_MAP_TOOL (desaturate_tool));
}
static void
gimp_image_map_tool_gegl_notify (GObject *config,
const GParamSpec *pspec,
GimpImageMapTool *im_tool)
{
if (im_tool->image_map)
{
gimp_tool_control_set_preserve (GIMP_TOOL (im_tool)->control, TRUE);
gimp_image_map_tool_create_map (im_tool);
gimp_tool_control_set_preserve (GIMP_TOOL (im_tool)->control, FALSE);
gimp_image_map_tool_preview (im_tool);
}
}
static void
gimp_threshold_tool_config_notify (GObject *object,
GParamSpec *pspec,
GimpThresholdTool *t_tool)
{
GimpThresholdConfig *config = GIMP_THRESHOLD_CONFIG (object);
if (! t_tool->histogram_box)
return;
gimp_histogram_view_set_range (t_tool->histogram_box->view,
config->low * 255.999,
config->high * 255.999);
gimp_image_map_tool_preview (GIMP_IMAGE_MAP_TOOL (t_tool));
}
static void
levels_high_input_adjustment_update (GtkAdjustment *adjustment,
GimpLevelsTool *tool)
{
gint value = ROUND (adjustment->value);
value = CLAMP (value, tool->levels->low_input[tool->channel], 255);
/* enforce a consistent displayed value (high_input >= low_input) */
gtk_adjustment_set_value (adjustment, value);
if (tool->levels->high_input[tool->channel] != value)
{
tool->levels->high_input[tool->channel] = value;
levels_update (tool, INPUT_LEVELS | INPUT_SLIDERS);
gimp_image_map_tool_preview (GIMP_IMAGE_MAP_TOOL (tool));
}
}
static void
gimp_brightness_contrast_tool_button_release (GimpTool *tool,
const GimpCoords *coords,
guint32 time,
GdkModifierType state,
GimpButtonReleaseType release_type,
GimpDisplay *display)
{
GimpBrightnessContrastTool *bc_tool = GIMP_BRIGHTNESS_CONTRAST_TOOL (tool);
GimpImageMapTool *im_tool = GIMP_IMAGE_MAP_TOOL (tool);
gimp_tool_control_halt (tool->control);
if (bc_tool->dx == 0 && bc_tool->dy == 0)
return;
if (release_type == GIMP_BUTTON_RELEASE_CANCEL)
gimp_config_reset (GIMP_CONFIG (bc_tool->config));
gimp_image_map_tool_preview (im_tool);
}
static void
hue_saturation_config_notify (GObject *object,
GParamSpec *pspec,
GimpHueSaturationTool *hs_tool)
{
GimpHueSaturationConfig *config = GIMP_HUE_SATURATION_CONFIG (object);
if (! hs_tool->hue_data)
return;
if (! strcmp (pspec->name, "range"))
{
gimp_int_radio_group_set_active (GTK_RADIO_BUTTON (hs_tool->range_radio),
config->range);
}
else if (! strcmp (pspec->name, "hue"))
{
gtk_adjustment_set_value (hs_tool->hue_data,
config->hue[config->range] * 180.0);
}
else if (! strcmp (pspec->name, "lightness"))
{
gtk_adjustment_set_value (hs_tool->lightness_data,
config->lightness[config->range] * 100.0);
}
else if (! strcmp (pspec->name, "saturation"))
{
gtk_adjustment_set_value (hs_tool->saturation_data,
config->saturation[config->range] * 100.0);
}
else if (! strcmp (pspec->name, "overlap"))
{
gtk_adjustment_set_value (hs_tool->overlap_data,
config->overlap * 100.0);
}
hue_saturation_update_color_areas (hs_tool);
gimp_image_map_tool_preview (GIMP_IMAGE_MAP_TOOL (hs_tool));
}
static void
color_balance_config_notify (GObject *object,
GParamSpec *pspec,
GimpColorBalanceTool *cb_tool)
{
GimpColorBalanceConfig *config = GIMP_COLOR_BALANCE_CONFIG (object);
if (! cb_tool->cyan_red_adj)
return;
if (! strcmp (pspec->name, "range"))
{
gimp_int_radio_group_set_active (GTK_RADIO_BUTTON (cb_tool->range_radio),
config->range);
}
else if (! strcmp (pspec->name, "cyan-red"))
{
gtk_adjustment_set_value (cb_tool->cyan_red_adj,
config->cyan_red[config->range] * 100.0);
}
else if (! strcmp (pspec->name, "magenta-green"))
{
gtk_adjustment_set_value (cb_tool->magenta_green_adj,
config->magenta_green[config->range] * 100.0);
}
else if (! strcmp (pspec->name, "yellow-blue"))
{
gtk_adjustment_set_value (cb_tool->yellow_blue_adj,
config->yellow_blue[config->range] * 100.0);
}
else if (! strcmp (pspec->name, "preserve-luminosity"))
{
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (cb_tool->preserve_toggle),
config->preserve_luminosity);
}
gimp_image_map_tool_preview (GIMP_IMAGE_MAP_TOOL (cb_tool));
}
static void
gimp_image_map_tool_response (GimpToolGui *gui,
gint response_id,
GimpImageMapTool *im_tool)
{
GimpTool *tool = GIMP_TOOL (im_tool);
switch (response_id)
{
case RESPONSE_RESET:
gimp_image_map_tool_reset (im_tool);
gimp_image_map_tool_preview (im_tool);
break;
case GTK_RESPONSE_OK:
gimp_tool_control (tool, GIMP_TOOL_ACTION_COMMIT, tool->display);
break;
default:
gimp_tool_control (tool, GIMP_TOOL_ACTION_HALT, tool->display);
break;
}
}
static void
gimp_gegl_tool_operation_changed (GtkWidget *widget,
GimpGeglTool *tool)
{
GtkTreeModel *model;
GtkTreeIter iter;
if (! gtk_combo_box_get_active_iter (GTK_COMBO_BOX (widget), &iter))
return;
model = gtk_combo_box_get_model (GTK_COMBO_BOX (widget));
if (tool->operation)
{
g_free (tool->operation);
tool->operation = NULL;
}
if (tool->config)
{
g_object_unref (tool->config);
tool->config = NULL;
}
gtk_tree_model_get (model, &iter,
COLUMN_NAME, &tool->operation,
-1);
if (! tool->operation)
return;
if (GIMP_IMAGE_MAP_TOOL (tool)->image_map)
{
gimp_image_map_clear (GIMP_IMAGE_MAP_TOOL (tool)->image_map);
g_object_unref (GIMP_IMAGE_MAP_TOOL (tool)->image_map);
GIMP_IMAGE_MAP_TOOL (tool)->image_map = NULL;
}
gegl_node_set (GIMP_IMAGE_MAP_TOOL (tool)->operation,
"operation", tool->operation,
NULL);
gimp_image_map_tool_create_map (GIMP_IMAGE_MAP_TOOL (tool));
tool->config = gimp_gegl_tool_get_config (tool);
if (tool->options_table)
{
gtk_container_remove (GTK_CONTAINER (tool->options_frame),
tool->options_table);
tool->options_table = NULL;
}
if (tool->config)
{
g_signal_connect_object (tool->config, "notify",
G_CALLBACK (gimp_gegl_tool_config_notify),
G_OBJECT (tool), 0);
tool->options_table =
gimp_prop_table_new (G_OBJECT (tool->config),
G_TYPE_FROM_INSTANCE (tool->config),
GIMP_CONTEXT (GIMP_TOOL_GET_OPTIONS (tool)));
gtk_container_add (GTK_CONTAINER (tool->options_frame),
tool->options_table);
gtk_widget_show (tool->options_table);
}
gimp_image_map_tool_preview (GIMP_IMAGE_MAP_TOOL (tool));
}
static void
gimp_image_map_tool_response (GtkWidget *widget,
gint response_id,
GimpImageMapTool *image_map_tool)
{
GimpTool *tool = GIMP_TOOL (image_map_tool);
switch (response_id)
{
case RESPONSE_RESET:
gimp_image_map_tool_reset (image_map_tool);
gimp_image_map_tool_preview (image_map_tool);
break;
case GTK_RESPONSE_OK:
gimp_dialog_factory_hide_dialog (image_map_tool->shell);
if (image_map_tool->image_map)
{
GimpImageMapOptions *options = GIMP_IMAGE_MAP_TOOL_GET_OPTIONS (tool);
gimp_tool_control_set_preserve (tool->control, TRUE);
if (! options->preview)
gimp_image_map_tool_map (image_map_tool);
gimp_image_map_commit (image_map_tool->image_map);
g_object_unref (image_map_tool->image_map);
image_map_tool->image_map = NULL;
gimp_tool_control_set_preserve (tool->control, FALSE);
gimp_image_flush (tool->display->image);
if (image_map_tool->config)
gimp_settings_box_add_current (GIMP_SETTINGS_BOX (image_map_tool->settings_box));
}
tool->display = NULL;
tool->drawable = NULL;
break;
default:
gimp_dialog_factory_hide_dialog (image_map_tool->shell);
if (image_map_tool->image_map)
{
gimp_tool_control_set_preserve (tool->control, TRUE);
gimp_image_map_abort (image_map_tool->image_map);
g_object_unref (image_map_tool->image_map);
image_map_tool->image_map = NULL;
gimp_tool_control_set_preserve (tool->control, FALSE);
gimp_image_flush (tool->display->image);
}
tool->display = NULL;
tool->drawable = NULL;
break;
}
}
void
gimp_operation_tool_set_operation (GimpOperationTool *tool,
const gchar *operation,
const gchar *undo_desc,
const gchar *icon_name)
{
GimpImageMapTool *im_tool;
GtkSizeGroup *size_group = NULL;
gint aux;
g_return_if_fail (GIMP_IS_OPERATION_TOOL (tool));
g_return_if_fail (operation != NULL);
im_tool = GIMP_IMAGE_MAP_TOOL (tool);
if (tool->operation)
g_free (tool->operation);
if (tool->undo_desc)
g_free (tool->undo_desc);
if (tool->icon_name)
g_free (tool->icon_name);
tool->operation = g_strdup (operation);
tool->undo_desc = g_strdup (undo_desc);
tool->icon_name = g_strdup (icon_name);
g_list_free_full (tool->aux_inputs,
(GDestroyNotify) gimp_operation_tool_aux_input_free);
tool->aux_inputs = NULL;
gimp_image_map_tool_get_operation (im_tool);
if (undo_desc)
GIMP_IMAGE_MAP_TOOL_GET_CLASS (tool)->settings_name = "yes"; /* XXX hack */
else
GIMP_IMAGE_MAP_TOOL_GET_CLASS (tool)->settings_name = NULL; /* XXX hack */
if (tool->options_gui)
{
gtk_widget_destroy (tool->options_gui);
tool->options_gui = NULL;
if (im_tool->active_picker)
{
im_tool->active_picker = NULL;
gimp_color_tool_disable (GIMP_COLOR_TOOL (tool));
}
}
for (aux = 1; ; aux++)
{
gchar pad[32];
gchar label[32];
if (aux == 1)
{
g_snprintf (pad, sizeof (pad), "aux");
g_snprintf (label, sizeof (label), _("Aux Input"));
}
else
{
g_snprintf (pad, sizeof (pad), "aux%d", aux);
g_snprintf (label, sizeof (label), _("Aux%d Input"), aux);
}
if (gegl_node_has_pad (im_tool->operation, pad))
{
AuxInput *input;
GtkWidget *toggle;
if (! size_group)
size_group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
input = gimp_operation_tool_aux_input_new (tool,
im_tool->operation, pad,
label);
tool->aux_inputs = g_list_append (tool->aux_inputs, input);
toggle = gimp_buffer_source_box_get_toggle (GIMP_BUFFER_SOURCE_BOX (input->box));
gtk_size_group_add_widget (size_group, toggle);
if (tool->options_box)
{
gtk_box_pack_start (GTK_BOX (tool->options_box), input->box,
FALSE, FALSE, 0);
gtk_widget_show (input->box);
}
}
else
{
break;
}
}
if (size_group)
g_object_unref (size_group);
if (im_tool->config)
{
tool->options_gui =
gimp_prop_gui_new (G_OBJECT (im_tool->config),
G_TYPE_FROM_INSTANCE (im_tool->config),
GIMP_CONTEXT (GIMP_TOOL_GET_OPTIONS (tool)),
(GimpCreatePickerFunc) gimp_image_map_tool_add_color_picker,
tool);
if (tool->options_box)
{
gtk_box_pack_start (GTK_BOX (tool->options_box), tool->options_gui,
FALSE, FALSE, 0);
gtk_widget_show (tool->options_gui);
}
}
if (im_tool->gui)
{
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 (GIMP_TOOL (tool)->drawable)
{
gimp_operation_tool_sync_op (tool, GIMP_TOOL (tool)->drawable);
gimp_image_map_tool_preview (im_tool);
}
}
void
gimp_operation_tool_set_operation (GimpOperationTool *tool,
const gchar *operation,
const gchar *undo_desc)
{
g_return_if_fail (GIMP_IS_OPERATION_TOOL (tool));
g_return_if_fail (operation != NULL);
if (tool->operation)
g_free (tool->operation);
if (tool->undo_desc)
g_free (tool->undo_desc);
tool->operation = g_strdup (operation);
tool->undo_desc = g_strdup (undo_desc);
if (tool->config)
g_object_unref (tool->config);
tool->config = gimp_gegl_get_config_proxy (tool->operation,
GIMP_TYPE_IMAGE_MAP_CONFIG);
gimp_image_map_tool_get_operation (GIMP_IMAGE_MAP_TOOL (tool));
if (undo_desc)
GIMP_IMAGE_MAP_TOOL_GET_CLASS (tool)->settings_name = "yes"; /* XXX hack */
else
GIMP_IMAGE_MAP_TOOL_GET_CLASS (tool)->settings_name = NULL; /* XXX hack */
if (tool->options_table)
{
gtk_widget_destroy (tool->options_table);
tool->options_table = NULL;
}
if (tool->config)
{
tool->options_table =
gimp_prop_table_new (G_OBJECT (tool->config),
G_TYPE_FROM_INSTANCE (tool->config),
GIMP_CONTEXT (GIMP_TOOL_GET_OPTIONS (tool)),
(GimpCreatePickerFunc) gimp_image_map_tool_add_color_picker,
tool);
if (tool->options_box)
{
gtk_container_add (GTK_CONTAINER (tool->options_box),
tool->options_table);
gtk_widget_show (tool->options_table);
}
}
if (undo_desc && GIMP_IMAGE_MAP_TOOL (tool)->dialog)
g_object_set (GIMP_IMAGE_MAP_TOOL (tool)->dialog,
"description", undo_desc,
NULL);
if (GIMP_TOOL (tool)->drawable)
gimp_image_map_tool_preview (GIMP_IMAGE_MAP_TOOL (tool));
}
static gboolean
levels_output_area_event (GtkWidget *widget,
GdkEvent *event,
GimpLevelsTool *tool)
{
GdkEventButton *bevent;
GdkEventMotion *mevent;
gint x, distance;
gint i;
gboolean update = FALSE;
switch (event->type)
{
case GDK_BUTTON_PRESS:
bevent = (GdkEventButton *) event;
distance = G_MAXINT;
for (i = 3; i < 5; i++)
if (fabs (bevent->x - tool->slider_pos[i]) < distance)
{
tool->active_slider = i;
distance = fabs (bevent->x - tool->slider_pos[i]);
}
x = bevent->x;
update = TRUE;
break;
case GDK_BUTTON_RELEASE:
switch (tool->active_slider)
{
case 3: /* low output */
levels_update (tool, LOW_OUTPUT);
break;
case 4: /* high output */
levels_update (tool, HIGH_OUTPUT);
break;
}
gimp_image_map_tool_preview (GIMP_IMAGE_MAP_TOOL (tool));
break;
case GDK_MOTION_NOTIFY:
mevent = (GdkEventMotion *) event;
gdk_window_get_pointer (widget->window, &x, NULL, NULL);
update = TRUE;
break;
default:
break;
}
if (update)
{
gint width;
gint border;
g_object_get (tool->hist_view, "border-width", &border, NULL);
width = widget->allocation.width - 2 * border;
if (width < 1)
return FALSE;
switch (tool->active_slider)
{
case 3: /* low output */
tool->levels->low_output[tool->channel] =
((gdouble) (x - border) / (gdouble) width) * 255.0;
tool->levels->low_output[tool->channel] =
CLAMP (tool->levels->low_output[tool->channel], 0, 255);
break;
case 4: /* high output */
tool->levels->high_output[tool->channel] =
((gdouble) (x - border) / (gdouble) width) * 255.0;
tool->levels->high_output[tool->channel] =
CLAMP (tool->levels->high_output[tool->channel], 0, 255);
break;
}
levels_update (tool, OUTPUT_SLIDERS);
}
return FALSE;
}
