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

static voidgimp_text_tool_im_preedit_start (GtkIMContext *context,                                 GimpTextTool *text_tool){  GimpTool         *tool  = GIMP_TOOL (text_tool);  GimpDisplayShell *shell = gimp_display_get_shell (tool->display);  GtkStyle         *style = gtk_widget_get_style (shell->canvas);  GtkWidget        *frame;  GtkWidget        *ebox;  PangoRectangle    cursor_rect = { 0, };  gint              off_x, off_y;  if (text_tool->text)    gimp_text_tool_editor_get_cursor_rect (text_tool,                                           text_tool->overwrite_mode,                                           &cursor_rect);  g_object_get (text_tool, "x1", &off_x, "y1", &off_y, NULL);  text_tool->preedit_overlay = gtk_frame_new (NULL);  gtk_frame_set_shadow_type (GTK_FRAME (text_tool->preedit_overlay),                             GTK_SHADOW_OUT);  gimp_display_shell_add_overlay (shell,                                  text_tool->preedit_overlay,                                  cursor_rect.x + off_x,                                  cursor_rect.y + off_y,                                  GIMP_HANDLE_ANCHOR_NORTH_WEST, 0, 0);  gimp_overlay_box_set_child_opacity (GIMP_OVERLAY_BOX (shell->canvas),                                      text_tool->preedit_overlay, 0.7);  gtk_widget_show (text_tool->preedit_overlay);  frame = gtk_frame_new (NULL);  gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);  gtk_container_add (GTK_CONTAINER (text_tool->preedit_overlay), frame);  gtk_widget_show (frame);  ebox = gtk_event_box_new ();  gtk_widget_modify_bg (ebox, GTK_STATE_NORMAL,                        &style->base[GTK_STATE_NORMAL]);  gtk_container_add (GTK_CONTAINER (frame), ebox);  gtk_widget_show (ebox);  text_tool->preedit_label = gtk_label_new (NULL);  gtk_widget_modify_bg (text_tool->preedit_label, GTK_STATE_NORMAL,                        &style->text[GTK_STATE_NORMAL]);  gtk_misc_set_padding (GTK_MISC (text_tool->preedit_label), 2, 2);  gtk_container_add (GTK_CONTAINER (ebox), text_tool->preedit_label);  gtk_widget_show (text_tool->preedit_label);}

static voidgimp_rotate_tool_prepare (GimpTransformTool *tr_tool){  GimpRotateTool *rotate  = GIMP_ROTATE_TOOL (tr_tool);  GimpDisplay    *display = GIMP_TOOL (tr_tool)->display;  GimpImage      *image   = gimp_display_get_image (display);  gdouble         xres;  gdouble         yres;  tr_tool->px = (gdouble) (tr_tool->x1 + tr_tool->x2) / 2.0;  tr_tool->py = (gdouble) (tr_tool->y1 + tr_tool->y2) / 2.0;  tr_tool->trans_info[ANGLE]      = 0.0;  tr_tool->trans_info[REAL_ANGLE] = 0.0;  tr_tool->trans_info[PIVOT_X]    = tr_tool->px;  tr_tool->trans_info[PIVOT_Y]    = tr_tool->py;  gimp_image_get_resolution (image, &xres, &yres);  g_signal_handlers_block_by_func (rotate->sizeentry,                                   rotate_center_changed,                                   tr_tool);  gimp_size_entry_set_unit (GIMP_SIZE_ENTRY (rotate->sizeentry),                            gimp_display_get_shell (display)->unit);  gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (rotate->sizeentry), 0,                                  xres, FALSE);  gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (rotate->sizeentry), 1,                                  yres, FALSE);  gimp_size_entry_set_refval_boundaries (GIMP_SIZE_ENTRY (rotate->sizeentry), 0,                                         -65536,                                         65536 +                                         gimp_image_get_width (image));  gimp_size_entry_set_refval_boundaries (GIMP_SIZE_ENTRY (rotate->sizeentry), 1,                                         -65536,                                         65536 +                                         gimp_image_get_height (image));  gimp_size_entry_set_size (GIMP_SIZE_ENTRY (rotate->sizeentry), 0,                            tr_tool->x1, tr_tool->x2);  gimp_size_entry_set_size (GIMP_SIZE_ENTRY (rotate->sizeentry), 1,                            tr_tool->y1, tr_tool->y2);  g_signal_handlers_unblock_by_func (rotate->sizeentry,                                     rotate_center_changed,                                     tr_tool);}

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 voidgimp_operation_tool_set_config (GimpFilterTool *filter_tool,                                GimpConfig     *config){  GimpOperationTool *op_tool = GIMP_OPERATION_TOOL (filter_tool);  gimp_operation_tool_unlink_chains (op_tool);  GIMP_FILTER_TOOL_CLASS (parent_class)->set_config (filter_tool, config);  if (filter_tool->config && GIMP_TOOL (op_tool)->drawable)    gimp_operation_tool_sync_op (op_tool, FALSE);  gimp_operation_tool_relink_chains (op_tool);}

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_scale_tool_init (GimpScaleTool *scale_tool){  GimpTool          *tool    = GIMP_TOOL (scale_tool);  GimpTransformTool *tr_tool = GIMP_TRANSFORM_TOOL (scale_tool);  gimp_tool_control_set_tool_cursor (tool->control, GIMP_TOOL_CURSOR_RESIZE);  tr_tool->progress_text      = _("Scaling");  tr_tool->use_grid           = TRUE;  tr_tool->use_corner_handles = TRUE;  tr_tool->use_side_handles   = TRUE;  tr_tool->use_center_handle  = TRUE;}

static voidgimp_blend_tool_commit (GimpBlendTool *blend_tool){  GimpTool *tool = GIMP_TOOL (blend_tool);  if (blend_tool->filter)    {      gimp_drawable_filter_commit (blend_tool->filter,                                   GIMP_PROGRESS (tool), FALSE);      g_object_unref (blend_tool->filter);      blend_tool->filter = NULL;      gimp_image_flush (gimp_display_get_image (tool->display));    }}

static voidgimp_text_tool_editor_dialog (GimpTextTool *text_tool){  GimpTool          *tool    = GIMP_TOOL (text_tool);  GimpTextOptions   *options = GIMP_TEXT_TOOL_GET_OPTIONS (text_tool);  GimpDialogFactory *dialog_factory;  GtkWindow         *parent  = NULL;  gdouble            xres    = 1.0;  gdouble            yres    = 1.0;  if (text_tool->editor_dialog)    {      gtk_window_present (GTK_WINDOW (text_tool->editor_dialog));      return;    }  dialog_factory = gimp_dialog_factory_get_singleton ();  if (tool->display)    {      GimpDisplayShell *shell = gimp_display_get_shell (tool->display);      parent = GTK_WINDOW (gtk_widget_get_toplevel (GTK_WIDGET (shell)));    }  if (text_tool->image)    gimp_image_get_resolution (text_tool->image, &xres, &yres);  text_tool->editor_dialog =    gimp_text_options_editor_new (parent, tool->tool_info->gimp, options,                                  gimp_dialog_factory_get_menu_factory (dialog_factory),                                  _("GIMP Text Editor"),                                  text_tool->proxy, text_tool->buffer,                                  xres, yres);  g_object_add_weak_pointer (G_OBJECT (text_tool->editor_dialog),                             (gpointer) &text_tool->editor_dialog);  gimp_dialog_factory_add_foreign (dialog_factory,                                   "gimp-text-tool-dialog",                                   text_tool->editor_dialog);  g_signal_connect (text_tool->editor_dialog, "destroy",                    G_CALLBACK (gimp_text_tool_editor_destroy),                    text_tool);  gtk_widget_show (text_tool->editor_dialog);}

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

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_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_blend_tool_update_graph (GimpBlendTool *blend_tool){  GimpTool *tool = GIMP_TOOL (blend_tool);  gint      off_x, off_y;  gimp_item_get_offset (GIMP_ITEM (tool->drawable), &off_x, &off_y);#if 0  if (gimp_blend_tool_is_shapeburst (blend_tool))    {      gfloat start, end;      gegl_buffer_get (blend_tool->dist_buffer,                       GEGL_RECTANGLE (blend_tool->start_x - off_x,                                       blend_tool->start_y - off_y,                                       1, 1),                       1.0, babl_format("Y float"), &start,                       GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_NONE);      gegl_buffer_get (blend_tool->dist_buffer,                       GEGL_RECTANGLE (blend_tool->end_x - off_x,                                       blend_tool->end_y - off_y,                                       1, 1),                       1.0, babl_format("Y float"), &end,                       GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_NONE);      if (start != end)        {          gegl_node_set (blend_tool->subtract_node,                         "value", (gdouble) start,                         NULL);          gegl_node_set (blend_tool->divide_node,                         "value", (gdouble) (end - start),                         NULL);        }    }  else#endif    {      gegl_node_set (blend_tool->render_node,                     "start_x", blend_tool->start_x - off_x,                     "start_y", blend_tool->start_y - off_y,                     "end_x",   blend_tool->end_x - off_x,                     "end_y",   blend_tool->end_y - off_y,                     NULL);    }}

static voidgimp_cage_tool_commit (GimpCageTool *ct){  GimpTool *tool = GIMP_TOOL (ct);  gimp_tool_control_push_preserve (tool->control, TRUE);  gimp_image_map_commit (ct->image_map,                         GIMP_PROGRESS (tool));  g_object_unref (ct->image_map);  ct->image_map = NULL;  gimp_tool_control_pop_preserve (tool->control);  gimp_image_flush (gimp_display_get_image (tool->display));}

static voidgimp_tool_progress_end (GimpProgress *progress){  GimpTool *tool = GIMP_TOOL (progress);  if (tool->progress)    {      GimpDisplayShell *shell = gimp_display_get_shell (tool->progress_display);      gimp_progress_end (GIMP_PROGRESS (tool->progress));      gimp_display_shell_remove_item (shell, tool->progress);      tool->progress         = NULL;      tool->progress_display = NULL;    }}

static voidgimp_seamless_clone_tool_init (GimpSeamlessCloneTool *self){  GimpTool *tool = GIMP_TOOL (self);  gimp_tool_control_set_dirty_mask  (tool->control,                                     GIMP_DIRTY_IMAGE           |                                     GIMP_DIRTY_IMAGE_STRUCTURE |                                     GIMP_DIRTY_DRAWABLE        |                                     GIMP_DIRTY_SELECTION);  gimp_tool_control_set_tool_cursor (tool->control,                                     GIMP_TOOL_CURSOR_MOVE);  self->tool_state = SC_STATE_INIT;}

static voidgimp_region_select_tool_draw (GimpDrawTool *draw_tool){  GimpRegionSelectTool *region_sel = GIMP_REGION_SELECT_TOOL (draw_tool);  if (region_sel->segs)    {      GimpDisplayShell *shell;      shell = GIMP_DISPLAY_SHELL (GIMP_TOOL (draw_tool)->display->shell);      gimp_canvas_draw_segments (GIMP_CANVAS (shell->canvas),                                 GIMP_CANVAS_STYLE_XOR,                                 region_sel->segs, region_sel->num_segs);    }}

static voidgimp_warp_tool_init (GimpWarpTool *self){  GimpTool *tool = GIMP_TOOL (self);  gimp_tool_control_set_preserve    (tool->control, FALSE);  gimp_tool_control_set_motion_mode (tool->control, GIMP_MOTION_MODE_EXACT);  gimp_tool_control_set_dirty_mask  (tool->control,                                     GIMP_DIRTY_IMAGE           |                                     GIMP_DIRTY_IMAGE_STRUCTURE |                                     GIMP_DIRTY_DRAWABLE        |                                     GIMP_DIRTY_SELECTION);  gimp_tool_control_set_wants_click (tool->control, TRUE);  gimp_tool_control_set_tool_cursor (tool->control,                                     GIMP_TOOL_CURSOR_PERSPECTIVE);}

static voidgimp_heal_tool_init (GimpHealTool *heal){  GimpTool       *tool        = GIMP_TOOL (heal);  GimpPaintTool  *paint_tool  = GIMP_PAINT_TOOL (tool);  GimpSourceTool *source_tool = GIMP_SOURCE_TOOL (tool);  gimp_tool_control_set_tool_cursor (tool->control, GIMP_TOOL_CURSOR_HEAL);  paint_tool->status      = _("Click to heal");  paint_tool->status_ctrl = _("%s to set a new heal source");  source_tool->status_paint           = _("Click to heal");  source_tool->status_set_source      = _("Click to set a new heal source");  source_tool->status_set_source_ctrl = _("%s to set a new heal source");}

static voidgimp_region_select_tool_init (GimpRegionSelectTool *region_select){  GimpTool *tool = GIMP_TOOL (region_select);  gimp_tool_control_set_scroll_lock (tool->control, TRUE);  gimp_tool_control_set_motion_mode (tool->control, GIMP_MOTION_MODE_COMPRESS);  region_select->x               = 0;  region_select->y               = 0;  region_select->saved_threshold = 0.0;  region_select->region_mask     = NULL;  region_select->segs            = NULL;  region_select->num_segs        = 0;}

static voidgimp_ink_tool_init (GimpInkTool *ink_tool){  GimpTool *tool = GIMP_TOOL (ink_tool);  gimp_tool_control_set_tool_cursor    (tool->control, GIMP_TOOL_CURSOR_INK);  gimp_tool_control_set_action_value_2 (tool->control,                                        "tools/tools-ink-blob-size-set");  gimp_tool_control_set_action_value_3 (tool->control,                                        "tools/tools-ink-blob-aspect-set");  gimp_tool_control_set_action_value_4 (tool->control,                                        "tools/tools-ink-blob-angle-set");  gimp_paint_tool_enable_color_picker (GIMP_PAINT_TOOL (ink_tool),                                       GIMP_COLOR_PICK_MODE_FOREGROUND);}

static voidgimp_perspective_clone_tool_widget_status (GimpToolWidget           *widget,                                           const gchar              *status,                                           GimpPerspectiveCloneTool *clone_tool){  GimpTool *tool = GIMP_TOOL (clone_tool);  if (status)    {      gimp_tool_replace_status (tool, tool->display, "%s", status);    }  else    {      gimp_tool_pop_status (tool, tool->display);    }}

static GimpProgress *gimp_tool_progress_start (GimpProgress *progress,                          const gchar  *message,                          gboolean      cancelable){  GimpTool         *tool = GIMP_TOOL (progress);  GimpDisplayShell *shell;  gint              x, y;  g_return_val_if_fail (GIMP_IS_DISPLAY (tool->display), NULL);  g_return_val_if_fail (tool->progress == NULL, NULL);  shell = gimp_display_get_shell (tool->display);  x = shell->disp_width  / 2;  y = shell->disp_height / 2;  gimp_display_shell_unzoom_xy (shell, x, y, &x, &y, FALSE);  tool->progress = gimp_canvas_progress_new (shell,                                             GIMP_HANDLE_ANCHOR_CENTER,                                             x, y);  gimp_display_shell_add_unrotated_item (shell, tool->progress);  g_object_unref (tool->progress);  gimp_progress_start (GIMP_PROGRESS (tool->progress),                       message, FALSE);  gimp_widget_flush_expose (shell->canvas);  tool->progress_display = tool->display;  if (cancelable)    {      tool->progress_grab_widget = gtk_invisible_new ();      gtk_widget_show (tool->progress_grab_widget);      gtk_grab_add (tool->progress_grab_widget);      g_signal_connect (tool->progress_grab_widget, "button-press-event",                        G_CALLBACK (gimp_tool_progress_button_press),                        tool);      g_signal_connect (tool->progress_grab_widget, "key-press-event",                        G_CALLBACK (gimp_tool_progress_key_press),                        tool);    }  return progress;}

static voidgimp_seamless_clone_tool_commit (GimpSeamlessCloneTool *sc){  GimpTool *tool = GIMP_TOOL (sc);  if (sc->filter)    {      gimp_tool_control_push_preserve (tool->control, TRUE);      gimp_drawable_filter_commit (sc->filter, GIMP_PROGRESS (tool), FALSE);      g_clear_object (&sc->filter);      gimp_tool_control_pop_preserve (tool->control);      gimp_image_flush (gimp_display_get_image (tool->display));    }}

static voidgimp_guide_tool_init (GimpGuideTool *guide_tool){  GimpTool *tool = GIMP_TOOL (guide_tool);  gimp_tool_control_set_snap_to            (tool->control, FALSE);  gimp_tool_control_set_handle_empty_image (tool->control, TRUE);  gimp_tool_control_set_tool_cursor        (tool->control,                                            GIMP_TOOL_CURSOR_MOVE);  gimp_tool_control_set_scroll_lock        (tool->control, TRUE);  gimp_tool_control_set_precision          (tool->control,                                            GIMP_CURSOR_PRECISION_PIXEL_BORDER);  guide_tool->guide             = NULL;  guide_tool->guide_position    = GIMP_GUIDE_POSITION_UNDEFINED;  guide_tool->guide_orientation = GIMP_ORIENTATION_UNKNOWN;}

static voidgimp_perspective_tool_init (GimpPerspectiveTool *perspective_tool){  GimpTool          *tool    = GIMP_TOOL (perspective_tool);  GimpTransformTool *tr_tool = GIMP_TRANSFORM_TOOL (perspective_tool);  gimp_tool_control_set_tool_cursor (tool->control,                                     GIMP_TOOL_CURSOR_PERSPECTIVE);  tr_tool->progress_text      = _("Perspective transformation");  tr_tool->use_grid           = TRUE;  tr_tool->use_corner_handles = TRUE;  tr_tool->use_center_handle  = TRUE;  tr_tool->does_perspective   = TRUE;}

static voidgimp_flip_tool_init (GimpFlipTool *flip_tool){  GimpTool *tool = GIMP_TOOL (flip_tool);  gimp_tool_control_set_snap_to            (tool->control, FALSE);  gimp_tool_control_set_precision          (tool->control,                                            GIMP_CURSOR_PRECISION_PIXEL_CENTER);  gimp_tool_control_set_cursor             (tool->control, GIMP_CURSOR_MOUSE);  gimp_tool_control_set_toggle_cursor      (tool->control, GIMP_CURSOR_MOUSE);  gimp_tool_control_set_tool_cursor        (tool->control,                                            GIMP_TOOL_CURSOR_FLIP_HORIZONTAL);  gimp_tool_control_set_toggle_tool_cursor (tool->control,                                            GIMP_TOOL_CURSOR_FLIP_VERTICAL);  flip_tool->guide = NULL;}

voidgimp_text_tool_editor_button_release (GimpTextTool *text_tool){  GtkTextBuffer *buffer = GTK_TEXT_BUFFER (text_tool->buffer);  if (gtk_text_buffer_get_has_selection (buffer))    {      GimpTool         *tool  = GIMP_TOOL (text_tool);      GimpDisplayShell *shell = gimp_display_get_shell (tool->display);      GtkClipboard     *clipboard;      clipboard = gtk_widget_get_clipboard (GTK_WIDGET (shell),                                            GDK_SELECTION_PRIMARY);      gtk_text_buffer_copy_clipboard (buffer, clipboard);    }}

static voidgimp_rectangle_select_tool_real_select (GimpRectangleSelectTool *rect_sel_tool,                                        GimpChannelOps           operation,                                        gint                     x,                                        gint                     y,                                        gint                     w,                                        gint                     h){  GimpTool                   *tool    = GIMP_TOOL (rect_sel_tool);  GimpSelectionOptions       *options = GIMP_SELECTION_TOOL_GET_OPTIONS (tool);  GimpRectangleSelectOptions *rect_select_options;  GimpChannel                *channel;  rect_select_options = GIMP_RECTANGLE_SELECT_TOOL_GET_OPTIONS (tool);  channel = gimp_image_get_mask (gimp_display_get_image (tool->display));  if (rect_select_options->round_corners)    {      /* To prevent elliptification of the rectangle,       * we must cap the corner radius.       */      gdouble max    = MIN (w / 2.0, h / 2.0);      gdouble radius = MIN (rect_select_options->corner_radius, max);      gimp_channel_select_round_rect (channel,                                      x, y, w, h,                                      radius, radius,                                      operation,                                      options->antialias,                                      options->feather,                                      options->feather_radius,                                      options->feather_radius,                                      TRUE);    }  else    {      gimp_channel_select_rectangle (channel,                                     x, y, w, h,                                     operation,                                     options->feather,                                     options->feather_radius,                                     options->feather_radius,                                     TRUE);    }}

static voidgimp_perspective_clone_tool_halt (GimpPerspectiveCloneTool *clone_tool){  GimpTool *tool = GIMP_TOOL (clone_tool);  clone_tool->src_display = NULL;  g_object_set (GIMP_PAINT_TOOL (tool)->core,                "src-drawable", NULL,                NULL);  if (gimp_draw_tool_is_active (GIMP_DRAW_TOOL (tool)))    gimp_draw_tool_stop (GIMP_DRAW_TOOL (tool));  tool->display  = NULL;  tool->drawable = NULL;}