自学教程：C++ GIMP_COLOR_TOOL函数代码示例

static voidgimp_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));            }        }    }}

voidgimp_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 voidgimp_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 voidgimp_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 voidgimp_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 voidgimp_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 voidgimp_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);}

voidgimp_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 voidgimp_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 voidgimp_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. **/voidgimp_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 voidgimp_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 voidgimp_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 voidgimp_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 voidgimp_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 voidgimp_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 voidgimp_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 voidgimp_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 voidlevels_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 voidgimp_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 voidgimp_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 voidgimp_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 voidgimp_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 voidgimp_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 gbooleangimp_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 voidgimp_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 gbooleangimp_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 voidgimp_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 voidgimp_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 voidgimp_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);}