static void gimp_paint_tool_modifier_key (GimpTool *tool, GdkModifierType key, gboolean press, GdkModifierType state, GimpDisplay *display) { GimpPaintTool *paint_tool = GIMP_PAINT_TOOL (tool); GimpDrawTool *draw_tool = GIMP_DRAW_TOOL (tool); if (paint_tool->pick_colors && ! paint_tool->draw_line) { if ((state & gimp_get_all_modifiers_mask ()) == gimp_get_constrain_behavior_mask ()) { if (! gimp_color_tool_is_enabled (GIMP_COLOR_TOOL (tool))) { GimpToolInfo *info = gimp_get_tool_info (display->gimp, "gimp-color-picker-tool"); if (GIMP_IS_TOOL_INFO (info)) { if (gimp_draw_tool_is_active (draw_tool)) gimp_draw_tool_stop (draw_tool); gimp_color_tool_enable (GIMP_COLOR_TOOL (tool), GIMP_COLOR_OPTIONS (info->tool_options)); switch (GIMP_COLOR_TOOL (tool)->pick_mode) { case GIMP_COLOR_PICK_MODE_FOREGROUND: gimp_tool_push_status (tool, display, _("Click in any image to pick the " "foreground color")); break; case GIMP_COLOR_PICK_MODE_BACKGROUND: gimp_tool_push_status (tool, display, _("Click in any image to pick the " "background color")); break; default: break; } } } } else { if (gimp_color_tool_is_enabled (GIMP_COLOR_TOOL (tool))) { gimp_tool_pop_status (tool, display); gimp_color_tool_disable (GIMP_COLOR_TOOL (tool)); } } } }
void gimp_color_tool_start_sample_point (GimpTool *tool, GimpDisplay *display) { GimpColorTool *color_tool; g_return_if_fail (GIMP_IS_COLOR_TOOL (tool)); g_return_if_fail (GIMP_IS_DISPLAY (display)); color_tool = GIMP_COLOR_TOOL (tool); gimp_display_shell_selection_control (GIMP_DISPLAY_SHELL (display->shell), GIMP_SELECTION_PAUSE); tool->display = display; gimp_tool_control_activate (tool->control); if (color_tool->sample_point) gimp_display_shell_draw_sample_point (GIMP_DISPLAY_SHELL (display->shell), color_tool->sample_point, FALSE); color_tool->sample_point = NULL; color_tool->moving_sample_point = TRUE; color_tool->sample_point_x = -1; color_tool->sample_point_y = -1; gimp_tool_set_cursor (tool, display, GIMP_CURSOR_MOUSE, GIMP_TOOL_CURSOR_COLOR_PICKER, GIMP_CURSOR_MODIFIER_MOVE); gimp_draw_tool_start (GIMP_DRAW_TOOL (tool), display); }
static void gimp_color_picker_tool_init (GimpColorPickerTool *picker_tool) { GimpColorTool *color_tool = GIMP_COLOR_TOOL (picker_tool); color_tool->pick_mode = GIMP_COLOR_PICK_MODE_FOREGROUND; }
static void gimp_color_tool_control (GimpTool *tool, GimpToolAction action, GimpDisplay *display) { GimpColorTool *color_tool = GIMP_COLOR_TOOL (tool); GimpDisplayShell *shell = GIMP_DISPLAY_SHELL (display->shell); switch (action) { case GIMP_TOOL_ACTION_PAUSE: break; case GIMP_TOOL_ACTION_RESUME: if (color_tool->sample_point && gimp_display_shell_get_show_sample_points (shell)) gimp_display_shell_draw_sample_point (shell, color_tool->sample_point, TRUE); break; case GIMP_TOOL_ACTION_HALT: if (color_tool->sample_point && gimp_display_shell_get_show_sample_points (shell)) gimp_display_shell_draw_sample_point (shell, color_tool->sample_point, FALSE); break; } GIMP_TOOL_CLASS (parent_class)->control (tool, action, display); }
static void gimp_color_tool_motion (GimpTool *tool, const GimpCoords *coords, guint32 time, GdkModifierType state, GimpDisplay *display) { GimpColorTool *color_tool = GIMP_COLOR_TOOL (tool); if (! color_tool->enabled) return; if (! color_tool->sample_point) { gimp_draw_tool_pause (GIMP_DRAW_TOOL (tool)); color_tool->center_x = coords->x; color_tool->center_y = coords->y; gimp_draw_tool_resume (GIMP_DRAW_TOOL (tool)); gimp_color_tool_pick (color_tool, GIMP_COLOR_PICK_STATE_UPDATE, coords->x, coords->y); } }
static void gimp_color_tool_button_release (GimpTool *tool, const GimpCoords *coords, guint32 time, GdkModifierType state, GimpButtonReleaseType release_type, GimpDisplay *display) { GimpColorTool *color_tool = GIMP_COLOR_TOOL (tool); /* Chain up to halt the tool */ GIMP_TOOL_CLASS (parent_class)->button_release (tool, coords, time, state, release_type, display); if (! color_tool->enabled) return; if (! color_tool->sample_point) { gimp_draw_tool_stop (GIMP_DRAW_TOOL (tool)); gimp_color_tool_pick (color_tool, GIMP_COLOR_PICK_STATE_END, coords->x, coords->y); } }
static void gimp_curves_tool_oper_update (GimpTool *tool, GimpCoords *coords, GdkModifierType state, gboolean proximity, GimpDisplay *display) { GimpColorPickMode mode = GIMP_COLOR_PICK_MODE_NONE; const gchar *status = NULL; GIMP_TOOL_CLASS (parent_class)->oper_update (tool, coords, state, proximity, display); gimp_tool_pop_status (tool, display); if (state & GDK_SHIFT_MASK) { mode = GIMP_COLOR_PICK_MODE_PALETTE; status = _("Click to add a control point"); } else if (state & GDK_CONTROL_MASK) { mode = GIMP_COLOR_PICK_MODE_PALETTE; status = _("Click to add control points to all channels"); } GIMP_COLOR_TOOL (tool)->pick_mode = mode; if (status && proximity) gimp_tool_push_status (tool, display, "%s", status); }
void gimp_color_tool_start_sample_point (GimpTool *tool, GimpDisplay *display) { GimpColorTool *color_tool; g_return_if_fail (GIMP_IS_COLOR_TOOL (tool)); g_return_if_fail (GIMP_IS_DISPLAY (display)); color_tool = GIMP_COLOR_TOOL (tool); gimp_display_shell_selection_pause (gimp_display_get_shell (display)); tool->display = display; gimp_tool_control_activate (tool->control); gimp_tool_control_set_scroll_lock (tool->control, TRUE); if (gimp_draw_tool_is_active (GIMP_DRAW_TOOL (tool))) gimp_draw_tool_stop (GIMP_DRAW_TOOL (tool)); color_tool->sample_point = NULL; color_tool->moving_sample_point = TRUE; color_tool->sample_point_x = SAMPLE_POINT_POSITION_INVALID; color_tool->sample_point_y = SAMPLE_POINT_POSITION_INVALID; gimp_tool_set_cursor (tool, display, GIMP_CURSOR_MOUSE, GIMP_TOOL_CURSOR_COLOR_PICKER, GIMP_CURSOR_MODIFIER_MOVE); gimp_draw_tool_start (GIMP_DRAW_TOOL (tool), display); }
static void gimp_paint_tool_cursor_update (GimpTool *tool, const GimpCoords *coords, GdkModifierType state, GimpDisplay *display) { GimpPaintTool *paint_tool = GIMP_PAINT_TOOL (tool); GimpCursorModifier modifier; GimpCursorModifier toggle_modifier; GimpCursorModifier old_modifier; GimpCursorModifier old_toggle_modifier; modifier = tool->control->cursor_modifier; toggle_modifier = tool->control->toggle_cursor_modifier; old_modifier = modifier; old_toggle_modifier = toggle_modifier; if (! gimp_color_tool_is_enabled (GIMP_COLOR_TOOL (tool))) { GimpImage *image = gimp_display_get_image (display); GimpDrawable *drawable = gimp_image_get_active_drawable (image); if (gimp_viewable_get_children (GIMP_VIEWABLE (drawable)) || gimp_item_is_content_locked (GIMP_ITEM (drawable)) || ! gimp_item_is_visible (GIMP_ITEM (drawable))) { modifier = GIMP_CURSOR_MODIFIER_BAD; toggle_modifier = GIMP_CURSOR_MODIFIER_BAD; } if (! paint_tool->show_cursor && modifier != GIMP_CURSOR_MODIFIER_BAD) { gimp_tool_set_cursor (tool, display, GIMP_CURSOR_NONE, GIMP_TOOL_CURSOR_NONE, GIMP_CURSOR_MODIFIER_NONE); return; } gimp_tool_control_set_cursor_modifier (tool->control, modifier); gimp_tool_control_set_toggle_cursor_modifier (tool->control, toggle_modifier); } GIMP_TOOL_CLASS (parent_class)->cursor_update (tool, coords, state, display); /* reset old stuff here so we are not interferring with the modifiers * set by our subclasses */ gimp_tool_control_set_cursor_modifier (tool->control, old_modifier); gimp_tool_control_set_toggle_cursor_modifier (tool->control, old_toggle_modifier); }
static void gimp_color_picker_tool_constructed (GObject *object) { GimpTool *tool = GIMP_TOOL (object); G_OBJECT_CLASS (parent_class)->constructed (object); gimp_color_tool_enable (GIMP_COLOR_TOOL (object), GIMP_COLOR_TOOL_GET_OPTIONS (tool)); }
/** * gimp_paint_tool_enable_color_picker: * @tool: a #GimpPaintTool * @mode: the #GimpColorPickMode to set * * This is a convenience function used from the init method of paint * tools that want the color picking functionality. The @mode that is * set here is used to decide what cursor modifier to draw and if the * picked color goes to the foreground or background color. **/ void gimp_paint_tool_enable_color_picker (GimpPaintTool *tool, GimpColorPickMode mode) { g_return_if_fail (GIMP_IS_PAINT_TOOL (tool)); tool->pick_colors = TRUE; GIMP_COLOR_TOOL (tool)->pick_mode = mode; }
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_color_tool_finalize (GObject *object) { GimpColorTool *color_tool = GIMP_COLOR_TOOL (object); if (color_tool->options) { g_object_unref (color_tool->options); color_tool->options = NULL; } G_OBJECT_CLASS (parent_class)->finalize (object); }
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_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_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_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)); }
static void gimp_image_map_tool_color_picker_toggled (GtkWidget *widget, GimpImageMapTool *im_tool) { if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget))) { if (im_tool->active_picker == widget) return; if (im_tool->active_picker) gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (im_tool->active_picker), FALSE); im_tool->active_picker = widget; gimp_color_tool_enable (GIMP_COLOR_TOOL (im_tool), GIMP_COLOR_TOOL_GET_OPTIONS (im_tool)); } else if (im_tool->active_picker == widget) { im_tool->active_picker = NULL; gimp_color_tool_disable (GIMP_COLOR_TOOL (im_tool)); } }
static void levels_input_picker_toggled (GtkWidget *widget, GimpLevelsTool *tool) { if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget))) { if (tool->active_picker == widget) return; if (tool->active_picker) gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (tool->active_picker), FALSE); tool->active_picker = widget; gimp_color_tool_enable (GIMP_COLOR_TOOL (tool), GIMP_COLOR_TOOL_GET_OPTIONS (tool)); } else if (tool->active_picker == widget) { tool->active_picker = NULL; gimp_color_tool_disable (GIMP_COLOR_TOOL (tool)); } }
static void gimp_color_tool_draw (GimpDrawTool *draw_tool) { GimpColorTool *color_tool = GIMP_COLOR_TOOL (draw_tool); if (color_tool->enabled) { if (color_tool->sample_point) { GimpImage *image = gimp_display_get_image (draw_tool->display); GimpCanvasItem *item; gint index; gint x; gint y; gimp_sample_point_get_position (color_tool->sample_point, &x, &y); index = g_list_index (gimp_image_get_sample_points (image), color_tool->sample_point) + 1; item = gimp_draw_tool_add_sample_point (draw_tool, x, y, index); gimp_canvas_item_set_highlight (item, TRUE); } if (color_tool->moving_sample_point) { if (color_tool->sample_point_x != SAMPLE_POINT_POSITION_INVALID && color_tool->sample_point_y != SAMPLE_POINT_POSITION_INVALID) { gimp_draw_tool_add_crosshair (draw_tool, color_tool->sample_point_x, color_tool->sample_point_y); } } else if (color_tool->options->sample_average && gimp_tool_control_is_active (GIMP_TOOL (draw_tool)->control)) { gdouble radius = color_tool->options->average_radius; gimp_draw_tool_add_rectangle (draw_tool, FALSE, color_tool->center_x - radius, color_tool->center_y - radius, 2 * radius + 1, 2 * radius + 1); } } }
static void gimp_paint_tool_motion (GimpTool *tool, const GimpCoords *coords, guint32 time, GdkModifierType state, GimpDisplay *display) { GimpPaintTool *paint_tool = GIMP_PAINT_TOOL (tool); GimpPaintOptions *paint_options = GIMP_PAINT_TOOL_GET_OPTIONS (tool); GimpPaintCore *core = paint_tool->core; GimpImage *image = gimp_display_get_image (display); GimpDrawable *drawable = gimp_image_get_active_drawable (image); GimpCoords curr_coords; gint off_x, off_y; GIMP_TOOL_CLASS (parent_class)->motion (tool, coords, time, state, display); if (gimp_color_tool_is_enabled (GIMP_COLOR_TOOL (tool))) return; curr_coords = *coords; gimp_paint_core_smooth_coords (core, paint_options, &curr_coords); gimp_item_get_offset (GIMP_ITEM (drawable), &off_x, &off_y); curr_coords.x -= off_x; curr_coords.y -= off_y; /* don't paint while the Shift key is pressed for line drawing */ if (paint_tool->draw_line) { gimp_paint_core_set_current_coords (core, &curr_coords); return; } gimp_draw_tool_pause (GIMP_DRAW_TOOL (tool)); gimp_paint_core_interpolate (core, drawable, paint_options, &curr_coords, time); gimp_projection_flush_now (gimp_image_get_projection (image)); gimp_display_flush_now (display); gimp_draw_tool_resume (GIMP_DRAW_TOOL (tool)); }
static void gimp_paint_tool_button_release (GimpTool *tool, const GimpCoords *coords, guint32 time, GdkModifierType state, GimpButtonReleaseType release_type, GimpDisplay *display) { GimpPaintTool *paint_tool = GIMP_PAINT_TOOL (tool); GimpPaintOptions *paint_options = GIMP_PAINT_TOOL_GET_OPTIONS (tool); GimpPaintCore *core = paint_tool->core; GimpDisplayShell *shell = gimp_display_get_shell (display); GimpImage *image = gimp_display_get_image (display); GimpDrawable *drawable = gimp_image_get_active_drawable (image); if (gimp_color_tool_is_enabled (GIMP_COLOR_TOOL (tool))) { GIMP_TOOL_CLASS (parent_class)->button_release (tool, coords, time, state, release_type, display); return; } gimp_draw_tool_pause (GIMP_DRAW_TOOL (tool)); /* Let the specific painting function finish up */ gimp_paint_core_paint (core, drawable, paint_options, GIMP_PAINT_STATE_FINISH, time); /* resume the current selection */ gimp_display_shell_selection_resume (shell); /* chain up to halt the tool */ GIMP_TOOL_CLASS (parent_class)->button_release (tool, coords, time, state, release_type, display); if (release_type == GIMP_BUTTON_RELEASE_CANCEL) gimp_paint_core_cancel (core, drawable); else gimp_paint_core_finish (core, drawable, TRUE); gimp_image_flush (image); gimp_draw_tool_resume (GIMP_DRAW_TOOL (tool)); }
static void gimp_color_tool_oper_update (GimpTool *tool, const GimpCoords *coords, GdkModifierType state, gboolean proximity, GimpDisplay *display) { GimpColorTool *color_tool = GIMP_COLOR_TOOL (tool); GimpDisplayShell *shell = gimp_display_get_shell (display); GimpImage *image = gimp_display_get_image (display); GimpSamplePoint *sample_point = NULL; if (color_tool->enabled && gimp_display_shell_get_show_sample_points (shell) && proximity) { gint snap_distance = display->config->snap_distance; sample_point = gimp_image_find_sample_point (image, coords->x, coords->y, FUNSCALEX (shell, snap_distance), FUNSCALEY (shell, snap_distance)); } if (color_tool->sample_point != sample_point) { GimpDrawTool *draw_tool = GIMP_DRAW_TOOL (tool); gimp_draw_tool_pause (draw_tool); if (gimp_draw_tool_is_active (draw_tool) && draw_tool->display != display) gimp_draw_tool_stop (draw_tool); color_tool->sample_point = sample_point; if (! gimp_draw_tool_is_active (draw_tool)) gimp_draw_tool_start (draw_tool, display); gimp_draw_tool_resume (draw_tool); } }
static void gimp_color_tool_draw (GimpDrawTool *draw_tool) { GimpColorTool *color_tool = GIMP_COLOR_TOOL (draw_tool); if (color_tool->enabled) { if (color_tool->moving_sample_point) { if (color_tool->sample_point_x != -1 && color_tool->sample_point_y != -1) { gimp_draw_tool_draw_line (draw_tool, 0, color_tool->sample_point_y + 0.5, draw_tool->display->image->width, color_tool->sample_point_y + 0.5, FALSE); gimp_draw_tool_draw_line (draw_tool, color_tool->sample_point_x + 0.5, 0, color_tool->sample_point_x + 0.5, draw_tool->display->image->height, FALSE); } } else { if (color_tool->options->sample_average) { gdouble radius = color_tool->options->average_radius; gimp_draw_tool_draw_rectangle (draw_tool, FALSE, color_tool->center_x - radius, color_tool->center_y - radius, 2 * radius + 1, 2 * radius + 1, TRUE); } } } GIMP_DRAW_TOOL_CLASS (parent_class)->draw (draw_tool); }
static gboolean gimp_curves_tool_initialize (GimpTool *tool, GimpDisplay *display, GError **error) { GimpCurvesTool *c_tool = GIMP_CURVES_TOOL (tool); GimpImage *image = gimp_display_get_image (display); GimpDrawable *drawable = gimp_image_get_active_drawable (image); GimpHistogram *histogram; if (! GIMP_TOOL_CLASS (parent_class)->initialize (tool, display, error)) { return FALSE; } /* always pick colors */ gimp_color_tool_enable (GIMP_COLOR_TOOL (tool), GIMP_COLOR_TOOL_GET_OPTIONS (tool)); gimp_int_combo_box_set_sensitivity (GIMP_INT_COMBO_BOX (c_tool->channel_menu), curves_menu_sensitivity, drawable, NULL); histogram = gimp_histogram_new (TRUE); gimp_drawable_calculate_histogram (drawable, histogram); gimp_histogram_view_set_background (GIMP_HISTOGRAM_VIEW (c_tool->graph), histogram); g_object_unref (histogram); if (gimp_drawable_get_precision (drawable) == GIMP_PRECISION_U8) { gimp_curve_view_set_range_x (GIMP_CURVE_VIEW (c_tool->graph), 0, 255); gimp_curve_view_set_range_y (GIMP_CURVE_VIEW (c_tool->graph), 0, 255); } else { gimp_curve_view_set_range_x (GIMP_CURVE_VIEW (c_tool->graph), 0.0, 1.0); gimp_curve_view_set_range_y (GIMP_CURVE_VIEW (c_tool->graph), 0.0, 1.0); } return TRUE; }
static void gimp_brush_tool_oper_update (GimpTool *tool, const GimpCoords *coords, GdkModifierType state, gboolean proximity, GimpDisplay *display) { GimpPaintOptions *paint_options = GIMP_PAINT_TOOL_GET_OPTIONS (tool); GimpDrawable *drawable; gimp_draw_tool_pause (GIMP_DRAW_TOOL (tool)); GIMP_TOOL_CLASS (parent_class)->oper_update (tool, coords, state, proximity, display); drawable = gimp_image_get_active_drawable (gimp_display_get_image (display)); if (! gimp_color_tool_is_enabled (GIMP_COLOR_TOOL (tool)) && drawable && proximity) { GimpContext *context = GIMP_CONTEXT (paint_options); GimpPaintTool *paint_tool = GIMP_PAINT_TOOL (tool); GimpBrushCore *brush_core = GIMP_BRUSH_CORE (paint_tool->core); gimp_brush_core_set_brush (brush_core, gimp_context_get_brush (context)); gimp_brush_core_set_dynamics (brush_core, gimp_context_get_dynamics (context)); if (GIMP_BRUSH_CORE_GET_CLASS (brush_core)->handles_transforming_brush) { gimp_brush_core_eval_transform_dynamics (brush_core, drawable, paint_options, coords); } } gimp_draw_tool_resume (GIMP_DRAW_TOOL (tool)); }
static gboolean gimp_curves_tool_initialize (GimpTool *tool, GimpDisplay *display, GError **error) { GimpCurvesTool *c_tool = GIMP_CURVES_TOOL (tool); GimpDrawable *drawable = gimp_image_get_active_drawable (display->image); GimpHistogram *histogram; if (! drawable) return FALSE; if (gimp_drawable_is_indexed (drawable)) { g_set_error (error, 0, 0, _("Curves does not operate on indexed layers.")); return FALSE; } gimp_config_reset (GIMP_CONFIG (c_tool->config)); GIMP_TOOL_CLASS (parent_class)->initialize (tool, display, error); /* always pick colors */ gimp_color_tool_enable (GIMP_COLOR_TOOL (tool), GIMP_COLOR_TOOL_GET_OPTIONS (tool)); gimp_int_combo_box_set_sensitivity (GIMP_INT_COMBO_BOX (c_tool->channel_menu), curves_menu_sensitivity, drawable, NULL); histogram = gimp_histogram_new (); gimp_drawable_calculate_histogram (drawable, histogram); gimp_histogram_view_set_background (GIMP_HISTOGRAM_VIEW (c_tool->graph), histogram); gimp_histogram_unref (histogram); return TRUE; }
static void gimp_brush_tool_cursor_update (GimpTool *tool, const GimpCoords *coords, GdkModifierType state, GimpDisplay *display) { GimpBrushTool *brush_tool = GIMP_BRUSH_TOOL (tool); GimpBrushCore *brush_core = GIMP_BRUSH_CORE (GIMP_PAINT_TOOL (brush_tool)->core); if (! gimp_color_tool_is_enabled (GIMP_COLOR_TOOL (tool))) { if (! brush_core->main_brush || ! brush_core->dynamics) { gimp_tool_set_cursor (tool, display, gimp_tool_control_get_cursor (tool->control), gimp_tool_control_get_tool_cursor (tool->control), GIMP_CURSOR_MODIFIER_BAD); return; } } 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); /* 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) { gimp_tool_control_halt (tool->control); gimp_sample_point_tool_start_edit (tool, display, color_tool->sample_point); } else { color_tool->center_x = coords->x; color_tool->center_y = coords->y; if (! gimp_draw_tool_is_active (GIMP_DRAW_TOOL (tool))) 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_color_tool_oper_update (GimpTool *tool, GimpCoords *coords, GdkModifierType state, gboolean proximity, GimpDisplay *display) { GimpColorTool *color_tool = GIMP_COLOR_TOOL (tool); GimpDisplayShell *shell = GIMP_DISPLAY_SHELL (display->shell); GimpSamplePoint *sample_point = NULL; if (color_tool->enabled && gimp_display_shell_get_show_sample_points (shell) && proximity) { gint snap_distance; snap_distance = GIMP_DISPLAY_CONFIG (display->image->gimp->config)->snap_distance; sample_point = gimp_image_find_sample_point (display->image, coords->x, coords->y, FUNSCALEX (shell, snap_distance), FUNSCALEY (shell, snap_distance)); } if (color_tool->sample_point && color_tool->sample_point != sample_point) gimp_image_update_sample_point (shell->display->image, color_tool->sample_point); color_tool->sample_point = sample_point; if (color_tool->sample_point) gimp_display_shell_draw_sample_point (shell, color_tool->sample_point, TRUE); }