static void
gimp_rectangle_select_tool_control (GimpTool *tool,
GimpToolAction action,
GimpDisplay *display)
{
gimp_rectangle_tool_control (tool, action, display);
GIMP_TOOL_CLASS (parent_class)->control (tool, action, display);
}
static void
gimp_dodge_burn_tool_class_init (GimpDodgeBurnToolClass *klass)
{
GimpToolClass *tool_class = GIMP_TOOL_CLASS (klass);
tool_class->modifier_key = gimp_dodge_burn_tool_modifier_key;
tool_class->cursor_update = gimp_dodge_burn_tool_cursor_update;
tool_class->oper_update = gimp_dodge_burn_tool_oper_update;
}
static gboolean
gimp_threshold_tool_initialize (GimpTool *tool,
GimpDisplay *display,
GError **error)
{
GimpThresholdTool *t_tool = GIMP_THRESHOLD_TOOL (tool);
GimpFilterTool *filter_tool = GIMP_FILTER_TOOL (tool);
GimpImage *image = gimp_display_get_image (display);
GimpDrawable *drawable = gimp_image_get_active_drawable (image);
gdouble low;
gdouble high;
gint n_bins;
if (! GIMP_TOOL_CLASS (parent_class)->initialize (tool, display, error))
{
return FALSE;
}
g_clear_object (&t_tool->histogram_async);
g_object_get (filter_tool->config,
"low", &low,
"high", &high,
NULL);
/* this is a hack to make sure that
* 'gimp_histogram_n_bins (t_tool->histogram)' returns the correct value for
* 'drawable' before the asynchronous calculation of its histogram is
* finished.
*/
{
GeglBuffer *temp;
temp = gegl_buffer_new (GEGL_RECTANGLE (0, 0, 1, 1),
gimp_drawable_get_format (drawable));
gimp_histogram_calculate (t_tool->histogram,
temp, GEGL_RECTANGLE (0, 0, 1, 1),
NULL, NULL);
g_object_unref (temp);
}
n_bins = gimp_histogram_n_bins (t_tool->histogram);
t_tool->histogram_async = gimp_drawable_calculate_histogram_async (
drawable, t_tool->histogram, FALSE);
gimp_histogram_view_set_histogram (t_tool->histogram_box->view,
t_tool->histogram);
gimp_histogram_view_set_range (t_tool->histogram_box->view,
low * (n_bins - 0.0001),
high * (n_bins - 0.0001));
return TRUE;
}
static void
gimp_bucket_fill_tool_class_init (GimpBucketFillToolClass *klass)
{
GimpToolClass *tool_class = GIMP_TOOL_CLASS (klass);
tool_class->initialize = gimp_bucket_fill_tool_initialize;
tool_class->button_release = gimp_bucket_fill_tool_button_release;
tool_class->modifier_key = gimp_bucket_fill_tool_modifier_key;
tool_class->cursor_update = gimp_bucket_fill_tool_cursor_update;
}
static void
gimp_crop_tool_cursor_update (GimpTool *tool,
const GimpCoords *coords,
GdkModifierType state,
GimpDisplay *display)
{
gimp_rectangle_tool_cursor_update (tool, coords, state, display);
GIMP_TOOL_CLASS (parent_class)->cursor_update (tool, coords, state, display);
}
static void
gimp_mybrush_tool_class_init (GimpMybrushToolClass *klass)
{
GimpToolClass *tool_class = GIMP_TOOL_CLASS (klass);
GimpPaintToolClass *paint_tool_class = GIMP_PAINT_TOOL_CLASS (klass);
tool_class->options_notify = gimp_mybrush_tool_options_notify;
paint_tool_class->get_outline = gimp_mybrush_tool_get_outline;
}
static void
gimp_selection_tool_class_init (GimpSelectionToolClass *klass)
{
GimpToolClass *tool_class = GIMP_TOOL_CLASS (klass);
tool_class->modifier_key = gimp_selection_tool_modifier_key;
tool_class->key_press = gimp_edit_selection_tool_key_press;
tool_class->oper_update = gimp_selection_tool_oper_update;
tool_class->cursor_update = gimp_selection_tool_cursor_update;
}
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_flip_tool_class_init (GimpFlipToolClass *klass)
{
GimpToolClass *tool_class = GIMP_TOOL_CLASS (klass);
GimpTransformToolClass *trans_class = GIMP_TRANSFORM_TOOL_CLASS (klass);
tool_class->modifier_key = gimp_flip_tool_modifier_key;
tool_class->cursor_update = gimp_flip_tool_cursor_update;
trans_class->transform = gimp_flip_tool_transform;
}
static void
gimp_sample_point_tool_class_init (GimpSamplePointToolClass *klass)
{
GimpToolClass *tool_class = GIMP_TOOL_CLASS (klass);
GimpDrawToolClass *draw_tool_class = GIMP_DRAW_TOOL_CLASS (klass);
tool_class->button_release = gimp_sample_point_tool_button_release;
tool_class->motion = gimp_sample_point_tool_motion;
draw_tool_class->draw = gimp_sample_point_tool_draw;
}
static void
gimp_guide_tool_class_init (GimpGuideToolClass *klass)
{
GimpToolClass *tool_class = GIMP_TOOL_CLASS (klass);
GimpDrawToolClass *draw_tool_class = GIMP_DRAW_TOOL_CLASS (klass);
tool_class->button_release = gimp_guide_tool_button_release;
tool_class->motion = gimp_guide_tool_motion;
draw_tool_class->draw = gimp_guide_tool_draw;
}
static void
gimp_color_tool_cursor_update (GimpTool *tool,
const GimpCoords *coords,
GdkModifierType state,
GimpDisplay *display)
{
GimpColorTool *color_tool = GIMP_COLOR_TOOL (tool);
GimpImage *image = gimp_display_get_image (display);
if (color_tool->enabled)
{
if (color_tool->sample_point)
{
gimp_tool_set_cursor (tool, display,
GIMP_CURSOR_MOUSE,
GIMP_TOOL_CURSOR_COLOR_PICKER,
GIMP_CURSOR_MODIFIER_MOVE);
}
else
{
GimpCursorModifier modifier = GIMP_CURSOR_MODIFIER_BAD;
if (gimp_image_coords_in_active_pickable (image, coords,
color_tool->options->sample_merged,
FALSE))
{
switch (color_tool->pick_mode)
{
case GIMP_COLOR_PICK_MODE_NONE:
modifier = GIMP_CURSOR_MODIFIER_NONE;
break;
case GIMP_COLOR_PICK_MODE_FOREGROUND:
modifier = GIMP_CURSOR_MODIFIER_FOREGROUND;
break;
case GIMP_COLOR_PICK_MODE_BACKGROUND:
modifier = GIMP_CURSOR_MODIFIER_BACKGROUND;
break;
case GIMP_COLOR_PICK_MODE_PALETTE:
modifier = GIMP_CURSOR_MODIFIER_PLUS;
break;
}
}
gimp_tool_set_cursor (tool, display,
GIMP_CURSOR_COLOR_PICKER,
GIMP_TOOL_CURSOR_COLOR_PICKER,
modifier);
}
return; /* don't chain up */
}
GIMP_TOOL_CLASS (parent_class)->cursor_update (tool, coords, state, display);
}
static void
gimp_rectangle_select_tool_oper_update (GimpTool *tool,
const GimpCoords *coords,
GdkModifierType state,
gboolean proximity,
GimpDisplay *display)
{
gimp_rectangle_tool_oper_update (tool, coords, state, proximity, display);
GIMP_TOOL_CLASS (parent_class)->oper_update (tool, coords, state, proximity,
display);
}
static void
gimp_rectangle_select_tool_active_modifier_key (GimpTool *tool,
GdkModifierType key,
gboolean press,
GdkModifierType state,
GimpDisplay *display)
{
GIMP_TOOL_CLASS (parent_class)->active_modifier_key (tool, key, press, state,
display);
gimp_rectangle_tool_active_modifier_key (tool, key, press, state, display);
}
static void
gimp_eraser_tool_cursor_update (GimpTool *tool,
const GimpCoords *coords,
GdkModifierType state,
GimpDisplay *display)
{
GimpEraserOptions *options = GIMP_ERASER_TOOL_GET_OPTIONS (tool);
gimp_tool_control_set_toggled (tool->control, options->anti_erase);
GIMP_TOOL_CLASS (parent_class)->cursor_update (tool, coords, state, display);
}
static gboolean
gimp_foreground_select_tool_key_press (GimpTool *tool,
GdkEventKey *kevent,
GimpDisplay *display)
{
GimpForegroundSelectTool *fg_select = GIMP_FOREGROUND_SELECT_TOOL (tool);
if (display != tool->display)
return FALSE;
if (fg_select->state == MATTING_STATE_PAINT_TRIMAP)
{
switch (kevent->keyval)
{
case GDK_KEY_Return:
case GDK_KEY_KP_Enter:
case GDK_KEY_ISO_Enter:
gimp_foreground_select_tool_response (fg_select->gui, RESPONSE_PREVIEW, fg_select);
return TRUE;
case GDK_KEY_Escape:
gimp_foreground_select_tool_response (fg_select->gui, RESPONSE_RESET, fg_select);
return TRUE;
default:
return FALSE;
}
}
else if (fg_select->state == MATTING_STATE_PREVIEW_MASK)
{
switch (kevent->keyval)
{
case GDK_KEY_Return:
case GDK_KEY_KP_Enter:
case GDK_KEY_ISO_Enter:
gimp_foreground_select_tool_response (fg_select->gui, RESPONSE_APPLY, fg_select);
return TRUE;
case GDK_KEY_Escape:
gimp_foreground_select_tool_response (fg_select->gui, RESPONSE_PREVIEW, fg_select);
return TRUE;
default:
return FALSE;
}
}
else
{
return GIMP_TOOL_CLASS (parent_class)->key_press (tool,
kevent,
display);
}
}
static void
gimp_convolve_tool_cursor_update (GimpTool *tool,
const GimpCoords *coords,
GdkModifierType state,
GimpDisplay *display)
{
GimpConvolveOptions *options = GIMP_CONVOLVE_TOOL_GET_OPTIONS (tool);
gimp_tool_control_set_toggled (tool->control,
(options->type == GIMP_SHARPEN_CONVOLVE));
GIMP_TOOL_CLASS (parent_class)->cursor_update (tool, coords, state, display);
}
static void
gimp_mybrush_tool_options_notify (GimpTool *tool,
GimpToolOptions *options,
const GParamSpec *pspec)
{
GIMP_TOOL_CLASS (parent_class)->options_notify (tool, options, pspec);
if (! strcmp (pspec->name, "radius"))
{
gimp_draw_tool_pause (GIMP_DRAW_TOOL (tool));
gimp_draw_tool_resume (GIMP_DRAW_TOOL (tool));
}
}
static void
gimp_dodge_burn_tool_cursor_update (GimpTool *tool,
GimpCoords *coords,
GdkModifierType state,
GimpDisplay *display)
{
GimpDodgeBurnOptions *options = GIMP_DODGE_BURN_TOOL_GET_OPTIONS (tool);
gimp_tool_control_set_toggled (tool->control, (options->type == GIMP_BURN));
GIMP_TOOL_CLASS (parent_class)->cursor_update (tool, coords, state,
display);
}
static gboolean
gimp_levels_tool_initialize (GimpTool *tool,
GimpDisplay *display,
GError **error)
{
GimpLevelsTool *l_tool = GIMP_LEVELS_TOOL (tool);
GimpDrawable *drawable = gimp_image_get_active_drawable (display->image);
if (! drawable)
return FALSE;
if (gimp_drawable_is_indexed (drawable))
{
g_set_error (error, 0, 0,
_("Levels does not operate on indexed layers."));
return FALSE;
}
if (! l_tool->hist)
l_tool->hist = gimp_histogram_new ();
levels_init (l_tool->levels);
l_tool->channel = GIMP_HISTOGRAM_VALUE;
l_tool->color = gimp_drawable_is_rgb (drawable);
l_tool->alpha = gimp_drawable_has_alpha (drawable);
if (l_tool->active_picker)
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (l_tool->active_picker),
FALSE);
GIMP_TOOL_CLASS (parent_class)->initialize (tool, display, error);
gimp_int_combo_box_set_sensitivity (GIMP_INT_COMBO_BOX (l_tool->channel_menu),
levels_menu_sensitivity, l_tool, NULL);
gimp_int_combo_box_set_active (GIMP_INT_COMBO_BOX (l_tool->channel_menu),
l_tool->channel);
/* FIXME: hack */
if (! l_tool->color)
l_tool->channel = (l_tool->channel == GIMP_HISTOGRAM_ALPHA) ? 1 : 0;
levels_update (l_tool, ALL);
gimp_drawable_calculate_histogram (drawable, l_tool->hist);
gimp_histogram_view_set_histogram (GIMP_HISTOGRAM_VIEW (l_tool->hist_view),
l_tool->hist);
return TRUE;
}
static void
gimp_align_tool_cursor_update (GimpTool *tool,
GimpCoords *coords,
GdkModifierType state,
GimpDisplay *display)
{
GimpAlignTool *align_tool = GIMP_ALIGN_TOOL (tool);
GimpToolCursorType tool_cursor = GIMP_TOOL_CURSOR_NONE;
GimpCursorModifier modifier = GIMP_CURSOR_MODIFIER_NONE;
if (state & GDK_SHIFT_MASK)
{
/* always add '+' when Shift is pressed, even if nothing is selected */
modifier = GIMP_CURSOR_MODIFIER_PLUS;
}
switch (align_tool->function)
{
case ALIGN_TOOL_IDLE:
tool_cursor = GIMP_TOOL_CURSOR_RECT_SELECT;
break;
case ALIGN_TOOL_PICK_LAYER:
case ALIGN_TOOL_ADD_LAYER:
tool_cursor = GIMP_TOOL_CURSOR_HAND;
break;
case ALIGN_TOOL_PICK_GUIDE:
case ALIGN_TOOL_ADD_GUIDE:
tool_cursor = GIMP_TOOL_CURSOR_MOVE;
break;
case ALIGN_TOOL_PICK_PATH:
case ALIGN_TOOL_ADD_PATH:
tool_cursor = GIMP_TOOL_CURSOR_PATHS;
break;
case ALIGN_TOOL_DRAG_BOX:
/* FIXME: it would be nice to add something here, but we cannot easily
detect when the tool is in this mode (the draw tool is always active)
so this state is not used for the moment.
*/
break;
}
gimp_tool_control_set_cursor (tool->control, GIMP_CURSOR_MOUSE);
gimp_tool_control_set_tool_cursor (tool->control, tool_cursor);
gimp_tool_control_set_cursor_modifier (tool->control, modifier);
GIMP_TOOL_CLASS (parent_class)->cursor_update (tool, coords, state, display);
}
static void
gimp_color_tool_button_press (GimpTool *tool,
const GimpCoords *coords,
guint32 time,
GdkModifierType state,
GimpButtonPressType press_type,
GimpDisplay *display)
{
GimpColorTool *color_tool = GIMP_COLOR_TOOL (tool);
GimpDisplayShell *shell = gimp_display_get_shell (display);
/* Chain up to activate the tool */
GIMP_TOOL_CLASS (parent_class)->button_press (tool, coords, time, state,
press_type, display);
if (! color_tool->enabled)
return;
if (color_tool->sample_point)
{
color_tool->moving_sample_point = TRUE;
gimp_sample_point_get_position (color_tool->sample_point,
&color_tool->sample_point_x,
&color_tool->sample_point_y);
gimp_tool_control_set_scroll_lock (tool->control, TRUE);
gimp_display_shell_selection_pause (shell);
if (! gimp_draw_tool_is_active (GIMP_DRAW_TOOL (tool)))
gimp_draw_tool_start (GIMP_DRAW_TOOL (tool), display);
gimp_tool_push_status_coords (tool, display,
gimp_tool_control_get_precision (tool->control),
_("Move Sample Point: "),
color_tool->sample_point_x,
", ",
color_tool->sample_point_y,
NULL);
}
else
{
color_tool->center_x = coords->x;
color_tool->center_y = coords->y;
gimp_draw_tool_start (GIMP_DRAW_TOOL (tool), display);
gimp_color_tool_pick (color_tool, GIMP_COLOR_PICK_STATE_START,
coords->x, coords->y);
}
}
static void
gimp_dodge_burn_tool_oper_update (GimpTool *tool,
GimpCoords *coords,
GdkModifierType state,
gboolean proximity,
GimpDisplay *display)
{
GimpDodgeBurnOptions *options = GIMP_DODGE_BURN_TOOL_GET_OPTIONS (tool);
gimp_dodge_burn_tool_status_update (tool, options->type);
GIMP_TOOL_CLASS (parent_class)->oper_update (tool, coords, state, proximity,
display);
}
static void
gimp_desaturate_tool_class_init (GimpDesaturateToolClass *klass)
{
GimpToolClass *tool_class = GIMP_TOOL_CLASS (klass);
GimpImageMapToolClass *im_tool_class = GIMP_IMAGE_MAP_TOOL_CLASS (klass);
tool_class->initialize = gimp_desaturate_tool_initialize;
im_tool_class->shell_desc = _("Desaturate (Remove Colors)");
im_tool_class->get_operation = gimp_desaturate_tool_get_operation;
im_tool_class->map = gimp_desaturate_tool_map;
im_tool_class->dialog = gimp_desaturate_tool_dialog;
}
static void
gimp_curves_tool_oper_update (GimpTool *tool,
const GimpCoords *coords,
GdkModifierType state,
gboolean proximity,
GimpDisplay *display)
{
if (gimp_image_map_tool_on_guide (GIMP_IMAGE_MAP_TOOL (tool),
coords, display))
{
GIMP_TOOL_CLASS (parent_class)->oper_update (tool, coords, state, proximity,
display);
}
else
{
GimpColorPickMode mode;
gchar *status = NULL;
GdkModifierType extend_mask = gimp_get_extend_selection_mask ();
GdkModifierType toggle_mask = gimp_get_toggle_behavior_mask ();
gimp_tool_pop_status (tool, display);
if (state & extend_mask)
{
mode = GIMP_COLOR_PICK_MODE_PALETTE;
status = g_strdup (_("Click to add a control point"));
}
else if (state & toggle_mask)
{
mode = GIMP_COLOR_PICK_MODE_PALETTE;
status = g_strdup (_("Click to add control points to all channels"));
}
else
{
mode = GIMP_COLOR_PICK_MODE_NONE;
status = gimp_suggest_modifiers (_("Click to locate on curve"),
(extend_mask | toggle_mask) & ~state,
_("%s: add control point"),
_("%s: add control points to all channels"),
NULL);
}
GIMP_COLOR_TOOL (tool)->pick_mode = mode;
if (proximity)
gimp_tool_push_status (tool, display, "%s", status);
g_free (status);
}
}
static void
gimp_convolve_tool_oper_update (GimpTool *tool,
const GimpCoords *coords,
GdkModifierType state,
gboolean proximity,
GimpDisplay *display)
{
GimpConvolveOptions *options = GIMP_CONVOLVE_TOOL_GET_OPTIONS (tool);
gimp_convolve_tool_status_update (tool, options->type);
GIMP_TOOL_CLASS (parent_class)->oper_update (tool, coords, state, proximity,
display);
}
static void
gimp_draw_tool_class_init (GimpDrawToolClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
GimpToolClass *tool_class = GIMP_TOOL_CLASS (klass);
object_class->dispose = gimp_draw_tool_dispose;
tool_class->has_display = gimp_draw_tool_has_display;
tool_class->has_image = gimp_draw_tool_has_image;
tool_class->control = gimp_draw_tool_control;
klass->draw = gimp_draw_tool_real_draw;
}
static void
gimp_color_tool_button_press (GimpTool *tool,
GimpCoords *coords,
guint32 time,
GdkModifierType state,
GimpDisplay *display)
{
GimpColorTool *color_tool = GIMP_COLOR_TOOL (tool);
GimpDisplayShell *shell = GIMP_DISPLAY_SHELL (display->shell);
/* Chain up to activate the tool */
GIMP_TOOL_CLASS (parent_class)->button_press (tool, coords, time, state,
display);
if (! color_tool->enabled)
return;
if (color_tool->sample_point)
{
color_tool->moving_sample_point = TRUE;
color_tool->sample_point_x = color_tool->sample_point->x;
color_tool->sample_point_y = color_tool->sample_point->y;
gimp_display_shell_selection_control (shell, GIMP_SELECTION_PAUSE);
gimp_draw_tool_start (GIMP_DRAW_TOOL (tool), display);
gimp_tool_push_status_coords (tool, display,
_("Move Sample Point: "),
color_tool->sample_point_x,
", ",
color_tool->sample_point_y,
NULL);
}
else
{
gint off_x, off_y;
/* Keep the coordinates of the target */
gimp_item_offsets (GIMP_ITEM (tool->drawable), &off_x, &off_y);
color_tool->center_x = coords->x - off_x;
color_tool->center_y = coords->y - off_y;
gimp_draw_tool_start (GIMP_DRAW_TOOL (tool), display);
gimp_color_tool_pick (color_tool, GIMP_COLOR_PICK_STATE_NEW,
coords->x, coords->y);
}
}
static void
gimp_curves_tool_button_release (GimpTool *tool,
GimpCoords *coords,
guint32 time,
GdkModifierType state,
GimpButtonReleaseType release_type,
GimpDisplay *display)
{
GimpCurvesTool *c_tool = GIMP_CURVES_TOOL (tool);
GimpCurvesConfig *config = c_tool->config;
if (state & GDK_SHIFT_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 & GDK_CONTROL_MASK)
{
gint i;
for (i = 0; i < 5; i++)
{
GimpCurve *curve = config->curve[i];
gdouble value = c_tool->picked_color[i];
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));
}
}
/* chain up to halt the tool */
GIMP_TOOL_CLASS (parent_class)->button_release (tool, coords, time, state,
release_type, display);
}
static gboolean
gimp_levels_tool_initialize (GimpTool *tool,
GimpDisplay *display,
GError **error)
{
GimpLevelsTool *l_tool = GIMP_LEVELS_TOOL (tool);
GimpImage *image = gimp_display_get_image (display);
GimpDrawable *drawable = gimp_image_get_active_drawable (image);
gdouble scale_factor;
gint digits;
if (! GIMP_TOOL_CLASS (parent_class)->initialize (tool, display, error))
{
return FALSE;
}
gimp_int_combo_box_set_sensitivity (GIMP_INT_COMBO_BOX (l_tool->channel_menu),
levels_menu_sensitivity, drawable, NULL);
gimp_drawable_calculate_histogram (drawable, l_tool->histogram);
gimp_histogram_view_set_histogram (GIMP_HISTOGRAM_VIEW (l_tool->histogram_view),
l_tool->histogram);
if (gimp_drawable_get_precision (drawable) == GIMP_PRECISION_U8)
{
scale_factor = 255.0;
digits = 0;
}
else
{
scale_factor = 100.0;
digits = 1;
}
gimp_prop_widget_set_factor (l_tool->low_input_spinbutton,
scale_factor, digits);
gimp_prop_widget_set_factor (l_tool->high_input_spinbutton,
scale_factor, digits);
gimp_prop_widget_set_factor (l_tool->low_output_spinbutton,
scale_factor, digits);
gimp_prop_widget_set_factor (l_tool->high_output_spinbutton,
scale_factor, digits);
gtk_adjustment_configure (l_tool->gamma_linear,
scale_factor / 2.0,
0, scale_factor, 0.1, 1.0, 0);
return TRUE;
}
