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

static voidgimp_source_tool_modifier_key (GimpTool        *tool,                               GdkModifierType  key,                               gboolean         press,                               GdkModifierType  state,                               GimpDisplay     *display){  GimpSourceTool    *source_tool = GIMP_SOURCE_TOOL (tool);  GimpPaintTool     *paint_tool  = GIMP_PAINT_TOOL (tool);  GimpSourceOptions *options     = GIMP_SOURCE_TOOL_GET_OPTIONS (tool);  if (options->use_source && key == GDK_CONTROL_MASK)    {      gimp_draw_tool_pause (GIMP_DRAW_TOOL (tool));      if (press)        {          paint_tool->status = source_tool->status_set_source;          source_tool->show_source_outline = FALSE;        }      else        {          paint_tool->status = source_tool->status_paint;          source_tool->show_source_outline = TRUE;        }      gimp_draw_tool_resume (GIMP_DRAW_TOOL (tool));    }  GIMP_TOOL_CLASS (parent_class)->modifier_key (tool, key, press, state,                                                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_warp_tool_start (GimpWarpTool *wt,                      GimpDisplay  *display){  GimpTool      *tool     = GIMP_TOOL (wt);  GimpImage     *image    = gimp_display_get_image (display);  GimpDrawable  *drawable = gimp_image_get_active_drawable (image);  const Babl    *format;  GeglRectangle  bbox;  tool->display  = display;  tool->drawable = drawable;  /* Create the coords buffer, with the size of the selection */  format = babl_format_n (babl_type ("float"), 2);  gimp_item_mask_intersect (GIMP_ITEM (drawable), &bbox.x, &bbox.y,                            &bbox.width, &bbox.height);#ifdef WARP_DEBUG  g_printerr ("Initialize coordinate buffer (%d,%d) at %d,%d/n",              bbox.width, bbox.height, bbox.x, bbox.y);#endif  wt->coords_buffer = gegl_buffer_new (&bbox, format);  gimp_warp_tool_create_image_map (wt, drawable);  if (! gimp_draw_tool_is_active (GIMP_DRAW_TOOL (wt)))    gimp_draw_tool_start (GIMP_DRAW_TOOL (wt), display);}

static voidgimp_text_tool_select_all (GimpTextTool *text_tool,                           gboolean      select){  GtkTextBuffer *buffer = GTK_TEXT_BUFFER (text_tool->buffer);  gimp_draw_tool_pause (GIMP_DRAW_TOOL (text_tool));  if (select)    {      GtkTextIter start, end;      gtk_text_buffer_get_bounds (buffer, &start, &end);      gtk_text_buffer_select_range (buffer, &start, &end);    }  else    {      GtkTextIter cursor;      gtk_text_buffer_get_iter_at_mark (buffer, &cursor,					gtk_text_buffer_get_insert (buffer));      gtk_text_buffer_move_mark_by_name (buffer, "selection_bound", &cursor);    }  gimp_draw_tool_resume (GIMP_DRAW_TOOL (text_tool));}

static voidgimp_cage_tool_motion (GimpTool         *tool,                       const GimpCoords *coords,                       guint32           time,                       GdkModifierType   state,                       GimpDisplay      *display){  GimpCageTool    *ct       = GIMP_CAGE_TOOL (tool);  GimpCageOptions *options  = GIMP_CAGE_TOOL_GET_OPTIONS (ct);  gimp_draw_tool_pause (GIMP_DRAW_TOOL (tool));  ct->cursor_x = coords->x;  ct->cursor_y = coords->y;  switch (ct->tool_state)    {    case CAGE_STATE_MOVE_HANDLE:    case CAGE_STATE_CLOSING:    case DEFORM_STATE_MOVE_HANDLE:      gimp_cage_config_add_displacement (ct->config,                                         options->cage_mode,                                         ct->cursor_x - ct->movement_start_x,                                         ct->cursor_y - ct->movement_start_y);      break;    }  gimp_draw_tool_resume (GIMP_DRAW_TOOL (tool));}

static voidgimp_source_tool_button_press (GimpTool        *tool,                               GimpCoords      *coords,                               guint32          time,                               GdkModifierType  state,                               GimpDisplay     *display){  GimpPaintTool  *paint_tool  = GIMP_PAINT_TOOL (tool);  GimpSourceTool *source_tool = GIMP_SOURCE_TOOL (tool);  GimpSourceCore *source      = GIMP_SOURCE_CORE (paint_tool->core);  gimp_draw_tool_pause (GIMP_DRAW_TOOL (tool));  if ((state & (GDK_CONTROL_MASK | GDK_SHIFT_MASK)) == GDK_CONTROL_MASK)    {      source->set_source = TRUE;      source_tool->src_display = display;    }  else    {      source->set_source = FALSE;    }  GIMP_TOOL_CLASS (parent_class)->button_press (tool, coords, time, state,                                                display);  source_tool->src_x = source->src_x;  source_tool->src_y = source->src_y;  gimp_draw_tool_resume (GIMP_DRAW_TOOL (tool));}

static voidgimp_align_tool_button_press (GimpTool            *tool,                              const GimpCoords    *coords,                              guint32              time,                              GdkModifierType      state,                              GimpButtonPressType  press_type,                              GimpDisplay         *display){    GimpAlignTool *align_tool  = GIMP_ALIGN_TOOL (tool);    gimp_draw_tool_pause (GIMP_DRAW_TOOL (tool));    /*  If the tool was being used in another image... reset it  */    if (display != tool->display)        gimp_tool_control (tool, GIMP_TOOL_ACTION_HALT, display);    tool->display = display;    gimp_tool_control_activate (tool->control);    align_tool->x2 = align_tool->x1 = coords->x;    align_tool->y2 = align_tool->y1 = coords->y;    if (! gimp_draw_tool_is_active (GIMP_DRAW_TOOL (tool)))        gimp_draw_tool_start (GIMP_DRAW_TOOL (tool), display);    gimp_draw_tool_resume (GIMP_DRAW_TOOL (tool));}

static voidgimp_move_tool_start_guide (GimpMoveTool        *move,                            GimpDisplay         *display,                            GimpOrientationType  orientation){  GimpTool *tool = GIMP_TOOL (move);  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));  move->guide             = NULL;  move->moving_guide      = TRUE;  move->guide_position    = GUIDE_POSITION_INVALID;  move->guide_orientation = orientation;  gimp_tool_set_cursor (tool, display,                        GIMP_CURSOR_MOUSE,                        GIMP_TOOL_CURSOR_HAND,                        GIMP_CURSOR_MODIFIER_MOVE);  gimp_draw_tool_start (GIMP_DRAW_TOOL (move), display);}

static voidgimp_source_tool_button_press (GimpTool            *tool,                               const GimpCoords    *coords,                               guint32              time,                               GdkModifierType      state,                               GimpButtonPressType  press_type,                               GimpDisplay         *display){  GimpPaintTool  *paint_tool  = GIMP_PAINT_TOOL (tool);  GimpSourceTool *source_tool = GIMP_SOURCE_TOOL (tool);  GimpSourceCore *source      = GIMP_SOURCE_CORE (paint_tool->core);  GdkModifierType toggle_mask = gimp_get_toggle_behavior_mask ();  gimp_draw_tool_pause (GIMP_DRAW_TOOL (tool));  if ((state & (toggle_mask | GDK_SHIFT_MASK)) == toggle_mask)    {      source->set_source = TRUE;      gimp_source_tool_set_src_display (source_tool, display);    }  else    {      source->set_source = FALSE;    }  GIMP_TOOL_CLASS (parent_class)->button_press (tool, coords, time, state,                                                press_type, display);  source_tool->src_x = source->src_x;  source_tool->src_y = source->src_y;  gimp_draw_tool_resume (GIMP_DRAW_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_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_text_tool_toggle_overwrite (GimpTextTool *text_tool){  gimp_draw_tool_pause (GIMP_DRAW_TOOL (text_tool));  text_tool->overwrite_mode = ! text_tool->overwrite_mode;  gimp_draw_tool_resume (GIMP_DRAW_TOOL (text_tool));}

static voidgimp_blend_tool_button_press (GimpTool            *tool,                              const GimpCoords    *coords,                              guint32              time,                              GdkModifierType      state,                              GimpButtonPressType  press_type,                              GimpDisplay         *display){  GimpBlendTool *blend_tool = GIMP_BLEND_TOOL (tool);  if (tool->display && display != tool->display)    {      gimp_tool_pop_status (tool, tool->display);      gimp_blend_tool_halt (blend_tool);    }  blend_tool->grabbed_point = gimp_blend_tool_get_point_under_cursor (blend_tool);  if (blend_tool->grabbed_point == POINT_NONE &&      ! gimp_draw_tool_is_active (GIMP_DRAW_TOOL (tool)))    {      blend_tool->start_x = coords->x;      blend_tool->start_y = coords->y;      if (gimp_blend_tool_is_shapeburst (blend_tool))        {          blend_tool->grabbed_point = POINT_FILL_MODE;        }      else        {          blend_tool->grabbed_point = POINT_INIT_MODE;        }    }  else if ((state & GDK_MOD1_MASK) &&           gimp_draw_tool_is_active (GIMP_DRAW_TOOL (tool)))    {      blend_tool->grabbed_point = POINT_BOTH;    }  gimp_blend_tool_point_motion (blend_tool,                                state & gimp_get_constrain_behavior_mask ());  tool->display = display;  gimp_blend_tool_update_items (blend_tool);  if (blend_tool->grabbed_point != POINT_FILL_MODE &&      blend_tool->grabbed_point != POINT_INIT_MODE)    {      gimp_blend_tool_update_graph (blend_tool);      gimp_drawable_filter_apply (blend_tool->filter, NULL);    }  gimp_tool_control_activate (tool->control);  gimp_blend_tool_push_status (blend_tool, state, display);}

static voidgimp_cage_tool_remove_last_handle (GimpCageTool *ct){  GimpCageConfig *config = ct->config;  gimp_draw_tool_pause (GIMP_DRAW_TOOL (ct));  gimp_cage_config_remove_last_cage_point (config);  gimp_draw_tool_resume (GIMP_DRAW_TOOL (ct));}

voidgimp_warp_tool_button_release (GimpTool              *tool,                               const GimpCoords      *coords,                               guint32                time,                               GdkModifierType        state,                               GimpButtonReleaseType  release_type,                               GimpDisplay           *display){  GimpWarpTool *wt = GIMP_WARP_TOOL (tool);  gimp_draw_tool_pause (GIMP_DRAW_TOOL (wt));  gimp_tool_control_halt (tool->control);  g_source_remove (wt->stroke_timer);  wt->stroke_timer = 0;  g_signal_handlers_disconnect_by_func (wt->current_stroke,                                        gimp_warp_tool_stroke_changed,                                        wt);#ifdef WARP_DEBUG  g_printerr ("%s/n", gegl_path_to_string (wt->current_stroke));#endif  g_object_unref (wt->current_stroke);  wt->current_stroke = NULL;  if (release_type == GIMP_BUTTON_RELEASE_CANCEL)    {      gimp_warp_tool_undo (tool, display);      /*  the just undone stroke has no business on the redo stack  */      g_object_unref (wt->redo_stack->data);      wt->redo_stack = g_list_remove_link (wt->redo_stack, wt->redo_stack);    }  else    {      if (wt->redo_stack)        {          /*  the redo stack becomes invalid by actually doing a stroke  */          g_list_free_full (wt->redo_stack, (GDestroyNotify) g_object_unref);          wt->redo_stack = NULL;        }      gimp_tool_push_status (tool, tool->display,                             _("Press ENTER to commit the transform"));    }  gimp_draw_tool_resume (GIMP_DRAW_TOOL (tool));  /*  update the undo actions / menu items  */  gimp_image_flush (gimp_display_get_image (GIMP_TOOL (wt)->display));}

static voidgimp_align_tool_clear_selected (GimpAlignTool *align_tool){    gimp_draw_tool_pause (GIMP_DRAW_TOOL (align_tool));    while (align_tool->selected_objects)        gimp_align_tool_object_removed (align_tool->selected_objects->data,                                        align_tool);    gimp_draw_tool_resume (GIMP_DRAW_TOOL (align_tool));}

static voidgimp_paint_tool_cursor_notify (GimpDisplayConfig *config,                               GParamSpec        *pspec,                               GimpPaintTool     *paint_tool){  gimp_draw_tool_pause (GIMP_DRAW_TOOL (paint_tool));  paint_tool->show_cursor = config->show_paint_tool_cursor;  paint_tool->draw_brush  = config->show_brush_outline;  gimp_draw_tool_resume (GIMP_DRAW_TOOL (paint_tool));}

static voidgimp_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 voidgimp_seamless_clone_tool_oper_update (GimpTool         *tool,                                      const GimpCoords *coords,                                      GdkModifierType   state,                                      gboolean          proximity,                                      GimpDisplay      *display){  gimp_draw_tool_pause (GIMP_DRAW_TOOL (tool));  /* TODO: Modify data here */  gimp_draw_tool_resume (GIMP_DRAW_TOOL (tool));}

static voidgimp_seamless_clone_tool_button_press (GimpTool            *tool,                                       const GimpCoords    *coords,                                       guint32              time,                                       GdkModifierType      state,                                       GimpButtonPressType  press_type,                                       GimpDisplay         *display){  GimpSeamlessCloneTool *sc = GIMP_SEAMLESS_CLONE_TOOL (tool);  if (display != tool->display)    {      gimp_seamless_clone_tool_start (sc, display);      /* Center the paste on the mouse */      sc->xoff = (gint) coords->x - sc->width / 2;      sc->yoff = (gint) coords->y - sc->height / 2;    }  if (sc->tool_state == SC_STATE_RENDER_WAIT &&      gimp_seamless_clone_tool_is_in_paste_c (sc, coords))    {      gimp_draw_tool_pause (GIMP_DRAW_TOOL (sc));      /* Record previous location, in case the user cancels the       * movement       */      sc->xoff_p = sc->xoff;      sc->yoff_p = sc->yoff;      /* Record the mouse location, so that the dragging offset can be       * calculated       */      sc->xclick = coords->x;      sc->yclick = coords->y;      gimp_draw_tool_resume (GIMP_DRAW_TOOL (tool));      if (gimp_seamless_clone_tool_render_node_update (sc))        {          gimp_seamless_clone_tool_filter_update (sc);        }      sc->tool_state = SC_STATE_RENDER_MOTION;      /* In order to receive motion events from the current click, we must       * activate the tool control       */      gimp_tool_control_activate (tool->control);    }}

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_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_warp_tool_halt (GimpWarpTool *wt){  GimpTool        *tool    = GIMP_TOOL (wt);  GimpWarpOptions *options = GIMP_WARP_TOOL_GET_OPTIONS (wt);  if (wt->coords_buffer)    {      g_object_unref (wt->coords_buffer);      wt->coords_buffer = NULL;    }  if (wt->graph)    {      g_object_unref (wt->graph);      wt->graph       = NULL;      wt->render_node = NULL;    }  if (wt->image_map)    {      gimp_image_map_abort (wt->image_map);      g_object_unref (wt->image_map);      wt->image_map = NULL;      gimp_image_flush (gimp_display_get_image (tool->display));    }  if (wt->redo_stack)    {      g_list_free_full (wt->redo_stack, (GDestroyNotify) g_object_unref);      wt->redo_stack = NULL;    }  tool->display  = NULL;  tool->drawable = NULL;  if (gimp_draw_tool_is_active (GIMP_DRAW_TOOL (wt)))    gimp_draw_tool_stop (GIMP_DRAW_TOOL (wt));  if (options->animate_button)    {      gtk_widget_set_sensitive (options->animate_button, FALSE);      g_signal_handlers_disconnect_by_func (options->animate_button,                                            gimp_warp_tool_animate,                                            wt);    }}

static gbooleangimp_n_point_deformation_tool_canvas_update_timeout (GimpNPointDeformationTool *npd_tool){  if (! GIMP_TOOL (npd_tool)->drawable)    return FALSE;  gimp_npd_debug (("canvas update thread/n"));  gimp_draw_tool_pause (GIMP_DRAW_TOOL(npd_tool));  gimp_draw_tool_resume (GIMP_DRAW_TOOL(npd_tool));  gimp_npd_debug (("canvas update thread stop/n"));  return TRUE;}

static voidgimp_n_point_deformation_tool_oper_update (GimpTool         *tool,                                           const GimpCoords *coords,                                           GdkModifierType   state,                                           gboolean          proximity,                                           GimpDisplay      *display){  GimpNPointDeformationTool *npd_tool  = GIMP_N_POINT_DEFORMATION_TOOL (tool);  GimpDrawTool              *draw_tool = GIMP_DRAW_TOOL (tool);  gimp_draw_tool_pause (draw_tool);  if (npd_tool->active)    {      NPDModel         *model = npd_tool->model;      GimpDisplayShell *shell = gimp_display_get_shell (display);      NPDPoint          p;      npd_tool->cp_scaled_radius = model->control_point_radius / shell->scale_x;      p.x = coords->x - npd_tool->offset_x;      p.y = coords->y - npd_tool->offset_y;      npd_tool->hovering_cp =        npd_get_control_point_with_radius_at (model,                                              &p,                                              npd_tool->cp_scaled_radius);    }  npd_tool->cursor_x = coords->x;  npd_tool->cursor_y = coords->y;  gimp_draw_tool_resume (draw_tool);}

static voidgimp_align_tool_object_removed (GObject       *object,                                GimpAlignTool *align_tool){    gimp_draw_tool_pause (GIMP_DRAW_TOOL (align_tool));    if (align_tool->selected_objects)        g_signal_handlers_disconnect_by_func (object,                                              gimp_align_tool_object_removed,                                              align_tool);    align_tool->selected_objects = g_list_remove (align_tool->selected_objects,                                   object);    gimp_draw_tool_resume (GIMP_DRAW_TOOL (align_tool));}

static voidgimp_align_tool_motion (GimpTool         *tool,                        const GimpCoords *coords,                        guint32           time,                        GdkModifierType   state,                        GimpDisplay      *display){    GimpAlignTool *align_tool = GIMP_ALIGN_TOOL (tool);    gimp_draw_tool_pause (GIMP_DRAW_TOOL (tool));    align_tool->x2 = coords->x;    align_tool->y2 = coords->y;    gimp_draw_tool_resume (GIMP_DRAW_TOOL (tool));}