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

static voidgimp_curves_tool_color_picked (GimpColorTool      *color_tool,                               GimpColorPickState  pick_state,                               gdouble             x,                               gdouble             y,                               const Babl         *sample_format,                               gpointer            pixel,                               const GimpRGB      *color){  GimpCurvesTool   *tool    = GIMP_CURVES_TOOL (color_tool);  GimpImageMapTool *im_tool = GIMP_IMAGE_MAP_TOOL (color_tool);  GimpCurvesConfig *config  = GIMP_CURVES_CONFIG (im_tool->config);  GimpDrawable     *drawable;  drawable = GIMP_IMAGE_MAP_TOOL (tool)->drawable;  tool->picked_color[GIMP_HISTOGRAM_RED]   = color->r;  tool->picked_color[GIMP_HISTOGRAM_GREEN] = color->g;  tool->picked_color[GIMP_HISTOGRAM_BLUE]  = color->b;  if (gimp_drawable_has_alpha (drawable))    tool->picked_color[GIMP_HISTOGRAM_ALPHA] = color->a;  else    tool->picked_color[GIMP_HISTOGRAM_ALPHA] = -1;  tool->picked_color[GIMP_HISTOGRAM_VALUE] = MAX (MAX (color->r, color->g),                                                  color->b);  gimp_curve_view_set_xpos (GIMP_CURVE_VIEW (tool->graph),                            tool->picked_color[config->channel]);}

voidgimp_image_map_tool_edit_as (GimpImageMapTool *im_tool,                             const gchar      *new_tool_id,                             GimpConfig       *config){  GimpDisplay  *display;  GimpContext  *user_context;  GimpToolInfo *tool_info;  GimpTool     *new_tool;  g_return_if_fail (GIMP_IS_IMAGE_MAP_TOOL (im_tool));  g_return_if_fail (new_tool_id);  g_return_if_fail (GIMP_IS_CONFIG (config));  display = GIMP_TOOL (im_tool)->display;  user_context = gimp_get_user_context (display->gimp);  tool_info = (GimpToolInfo *)    gimp_container_get_child_by_name (display->gimp->tool_info_list,                                      new_tool_id);  gimp_context_set_tool (user_context, tool_info);  tool_manager_initialize_active (display->gimp, display);  new_tool = tool_manager_get_active (display->gimp);  GIMP_IMAGE_MAP_TOOL (new_tool)->default_config = g_object_ref (config);  gimp_image_map_tool_reset (GIMP_IMAGE_MAP_TOOL (new_tool));}

static voidgimp_image_map_tool_options_notify (GimpTool         *tool,                                    GimpToolOptions  *options,                                    const GParamSpec *pspec){  GimpImageMapTool    *image_map_tool = GIMP_IMAGE_MAP_TOOL (tool);  GimpImageMapOptions *im_options     = GIMP_IMAGE_MAP_OPTIONS (options);  if (! strcmp (pspec->name, "preview") &&      image_map_tool->image_map)    {      if (im_options->preview)        {          gimp_tool_control_push_preserve (tool->control, TRUE);          gimp_image_map_tool_map (image_map_tool);          gimp_tool_control_pop_preserve (tool->control);        }      else        {          gimp_tool_control_push_preserve (tool->control, TRUE);          gimp_image_map_abort (image_map_tool->image_map);          gimp_tool_control_pop_preserve (tool->control);        }    }  else if (! strcmp (pspec->name, "region") &&           image_map_tool->image_map)    {      gimp_image_map_set_region (image_map_tool->image_map, im_options->region);      gimp_image_map_tool_preview (image_map_tool);    }}

static voidgimp_colorize_tool_config_notify (GObject          *object,                                  GParamSpec       *pspec,                                  GimpColorizeTool *col_tool){  GimpColorizeConfig *config = GIMP_COLORIZE_CONFIG (object);  if (! col_tool->hue_data)    return;  if (! strcmp (pspec->name, "hue"))    {      gtk_adjustment_set_value (col_tool->hue_data,                                config->hue * 360.0);    }  else if (! strcmp (pspec->name, "saturation"))    {      gtk_adjustment_set_value (col_tool->saturation_data,                                config->saturation * 100.0);    }  else if (! strcmp (pspec->name, "lightness"))    {      gtk_adjustment_set_value (col_tool->lightness_data,                                config->lightness * 100.0);    }  gimp_image_map_tool_preview (GIMP_IMAGE_MAP_TOOL (col_tool));}

static gbooleangimp_colorize_tool_initialize (GimpTool     *tool,                               GimpDisplay  *display,                               GError      **error){  GimpColorizeTool *col_tool = GIMP_COLORIZE_TOOL (tool);  GimpDrawable     *drawable = gimp_image_get_active_drawable (display->image);  if (! drawable)    return FALSE;  if (! gimp_drawable_is_rgb (drawable))    {      g_set_error (error, 0, 0,                   _("Colorize operates only on RGB color layers."));      return FALSE;    }  gimp_config_reset (GIMP_CONFIG (col_tool->config));  GIMP_TOOL_CLASS (parent_class)->initialize (tool, display, error);  gimp_image_map_tool_preview (GIMP_IMAGE_MAP_TOOL (tool));  return TRUE;}

static gbooleangimp_desaturate_tool_initialize (GimpTool     *tool,                                GimpDisplay  *display,                                GError      **error){  GimpDesaturateTool *desaturate_tool = GIMP_DESATURATE_TOOL (tool);  GimpDrawable       *drawable;  drawable = gimp_image_get_active_drawable (display->image);  if (! drawable)    return FALSE;  if (! gimp_drawable_is_rgb (drawable))    {      g_set_error (error, 0, 0,                   _("Desaturate does only operate on RGB layers."));      return FALSE;    }  gimp_config_reset (GIMP_CONFIG (desaturate_tool->config));  GIMP_TOOL_CLASS (parent_class)->initialize (tool, display, error);  gimp_int_radio_group_set_active (GTK_RADIO_BUTTON (desaturate_tool->button),                                   desaturate_tool->config->mode);  gimp_image_map_tool_preview (GIMP_IMAGE_MAP_TOOL (desaturate_tool));  return TRUE;}

static voidgimp_operation_tool_dialog (GimpImageMapTool *image_map_tool){  GimpOperationTool *tool = GIMP_OPERATION_TOOL (image_map_tool);  GtkWidget         *main_vbox;  main_vbox = gimp_image_map_tool_dialog_get_vbox (image_map_tool);  /*  The options vbox  */  tool->options_box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);  gtk_box_pack_start (GTK_BOX (main_vbox), tool->options_box,                      FALSE, FALSE, 0);  gtk_widget_show (tool->options_box);  if (tool->options_table)    {      gtk_container_add (GTK_CONTAINER (tool->options_box),                         tool->options_table);      gtk_widget_show (tool->options_table);    }  if (tool->undo_desc)    g_object_set (GIMP_IMAGE_MAP_TOOL (tool)->dialog,                  "description", tool->undo_desc,                  NULL);}

static voidgimp_curves_tool_color_picked (GimpColorTool      *color_tool,                               GimpColorPickState  pick_state,                               GimpImageType       sample_type,                               GimpRGB            *color,                               gint                color_index){  GimpCurvesTool *tool = GIMP_CURVES_TOOL (color_tool);  GimpDrawable   *drawable;  drawable = GIMP_IMAGE_MAP_TOOL (tool)->drawable;  tool->picked_color[GIMP_HISTOGRAM_RED]   = color->r;  tool->picked_color[GIMP_HISTOGRAM_GREEN] = color->g;  tool->picked_color[GIMP_HISTOGRAM_BLUE]  = color->b;  if (gimp_drawable_has_alpha (drawable))    tool->picked_color[GIMP_HISTOGRAM_ALPHA] = color->a;  tool->picked_color[GIMP_HISTOGRAM_VALUE] = MAX (MAX (color->r, color->g),                                                  color->b);  gimp_curve_view_set_xpos (GIMP_CURVE_VIEW (tool->graph),                            tool->picked_color[tool->config->channel]);}

static gbooleangimp_posterize_tool_initialize (GimpTool     *tool,                                GimpDisplay  *display,                                GError      **error){  GimpPosterizeTool *posterize_tool = GIMP_POSTERIZE_TOOL (tool);  GimpImage         *image          = gimp_display_get_image (display);  GimpDrawable      *drawable;  drawable = gimp_image_get_active_drawable (image);  if (! drawable)    return FALSE;  if (gimp_drawable_is_indexed (drawable))    {      g_set_error_literal (error, GIMP_ERROR, GIMP_FAILED,			   _("Posterize does not operate on indexed layers."));      return FALSE;    }  gimp_config_reset (GIMP_CONFIG (posterize_tool->config));  if (! GIMP_TOOL_CLASS (parent_class)->initialize (tool, display, error))    {      return FALSE;    }  gtk_adjustment_set_value (posterize_tool->levels_data,                            posterize_tool->config->levels);  gimp_image_map_tool_preview (GIMP_IMAGE_MAP_TOOL (posterize_tool));  return TRUE;}

static voidbrightness_contrast_config_notify (GObject                    *object,                                   GParamSpec                 *pspec,                                   GimpBrightnessContrastTool *bc_tool){  GimpBrightnessContrastConfig *config;  config = GIMP_BRIGHTNESS_CONTRAST_CONFIG (object);  if (! bc_tool->brightness_data)    return;  if (! strcmp (pspec->name, "brightness"))    {      gtk_adjustment_set_value (bc_tool->brightness_data,                                config->brightness * 127.0);    }  else if (! strcmp (pspec->name, "contrast"))    {      gtk_adjustment_set_value (bc_tool->contrast_data,                                config->contrast * 127.0);    }  gimp_image_map_tool_preview (GIMP_IMAGE_MAP_TOOL (bc_tool));}

static gbooleangimp_threshold_tool_initialize (GimpTool     *tool,                                GimpDisplay  *display,                                GError      **error){  GimpThresholdTool *t_tool   = GIMP_THRESHOLD_TOOL (tool);  GimpImage         *image    = gimp_display_get_image (display);  GimpDrawable      *drawable = gimp_image_get_active_drawable (image);  if (! drawable)    return FALSE;  gimp_config_reset (GIMP_CONFIG (t_tool->config));  if (! GIMP_TOOL_CLASS (parent_class)->initialize (tool, display, error))    {      return FALSE;    }  gimp_drawable_calculate_histogram (drawable, t_tool->histogram);  gimp_histogram_view_set_histogram (t_tool->histogram_box->view,                                     t_tool->histogram);  gimp_image_map_tool_preview (GIMP_IMAGE_MAP_TOOL (t_tool));  return TRUE;}

static GtkWidget *gimp_levels_tool_color_picker_new (GimpLevelsTool *tool,                                   guint           value){  const gchar *stock_id;  const gchar *help;  switch (value & 0xF)    {    case PICK_LOW_INPUT:      stock_id = GIMP_STOCK_COLOR_PICKER_BLACK;      help     = _("Pick black point");      break;    case PICK_GAMMA:      stock_id = GIMP_STOCK_COLOR_PICKER_GRAY;      help     = _("Pick gray point");      break;    case PICK_HIGH_INPUT:      stock_id = GIMP_STOCK_COLOR_PICKER_WHITE;      help     = _("Pick white point");      break;    default:      return NULL;    }  return gimp_image_map_tool_add_color_picker (GIMP_IMAGE_MAP_TOOL (tool),                                               GUINT_TO_POINTER (value),                                               stock_id,                                               help);}

static gbooleangimp_image_map_tool_key_press (GimpTool    *tool,                               GdkEventKey *kevent,                               GimpDisplay *display){  GimpImageMapTool *image_map_tool = GIMP_IMAGE_MAP_TOOL (tool);  if (display == tool->display)    {      switch (kevent->keyval)        {        case GDK_Return:        case GDK_KP_Enter:        case GDK_ISO_Enter:          gimp_image_map_tool_response (NULL, GTK_RESPONSE_OK, image_map_tool);          return TRUE;        case GDK_BackSpace:          gimp_image_map_tool_response (NULL, RESPONSE_RESET, image_map_tool);          return TRUE;        case GDK_Escape:          gimp_image_map_tool_response (NULL, GTK_RESPONSE_CANCEL, image_map_tool);          return TRUE;        }    }  return FALSE;}

static voidgimp_gegl_tool_config_notify (GObject      *object,                              GParamSpec   *pspec,                              GimpGeglTool *tool){  gimp_image_map_tool_preview (GIMP_IMAGE_MAP_TOOL (tool));}

static voidgimp_operation_tool_aux_input_notify (GimpBufferSourceBox *box,                                      const GParamSpec    *pspec,                                      GimpOperationTool   *tool){    gimp_image_map_tool_preview (GIMP_IMAGE_MAP_TOOL (tool));}

static voidgimp_image_map_tool_finalize (GObject *object){  GimpImageMapTool *image_map_tool = GIMP_IMAGE_MAP_TOOL (object);  if (image_map_tool->operation)    {      g_object_unref (image_map_tool->operation);      image_map_tool->operation = NULL;    }  if (image_map_tool->config)    {      g_object_unref (image_map_tool->config);      image_map_tool->config = NULL;    }  if (image_map_tool->default_config)    {      g_object_unref (image_map_tool->default_config);      image_map_tool->default_config = NULL;    }  if (image_map_tool->shell)    {      gtk_widget_destroy (image_map_tool->shell);      image_map_tool->shell        = NULL;      image_map_tool->main_vbox    = NULL;      image_map_tool->settings_box = NULL;      image_map_tool->label_group  = NULL;    }  G_OBJECT_CLASS (parent_class)->finalize (object);}

static voidgimp_levels_tool_color_picked (GimpColorTool      *color_tool,                               GimpColorPickState  pick_state,                               GimpImageType       sample_type,                               GimpRGB            *color,                               gint                color_index){  GimpLevelsTool *tool = GIMP_LEVELS_TOOL (color_tool);  guchar          col[5];  guint           value;  gimp_rgba_get_uchar (color,                       col + RED_PIX,                       col + GREEN_PIX,                       col + BLUE_PIX,                       col + ALPHA_PIX);  value = GPOINTER_TO_UINT (g_object_get_data (G_OBJECT (tool->active_picker),                                               "pick_value"));  if (value & ALL_CHANNELS && GIMP_IMAGE_TYPE_IS_RGB (sample_type))    {      GimpHistogramChannel  channel;      /*  first reset the value channel  */      switch (value & 0xF)        {        case LOW_INPUT:          tool->levels->low_input[GIMP_HISTOGRAM_VALUE] = 0;          break;        case GAMMA:          tool->levels->gamma[GIMP_HISTOGRAM_VALUE] = 1.0;          break;        case HIGH_INPUT:          tool->levels->high_input[GIMP_HISTOGRAM_VALUE] = 255;          break;        default:          break;        }      /*  then adjust all color channels  */      for (channel = GIMP_HISTOGRAM_RED;           channel <= GIMP_HISTOGRAM_BLUE;           channel++)        {          levels_input_adjust_by_color (tool->levels,                                        value, channel, col);        }    }  else    {      levels_input_adjust_by_color (tool->levels,                                    value, tool->channel, col);    }  levels_update (tool, ALL);  gimp_image_map_tool_preview (GIMP_IMAGE_MAP_TOOL (tool));}

static voidgimp_desaturate_tool_init (GimpDesaturateTool *desaturate_tool){  GimpImageMapTool *im_tool = GIMP_IMAGE_MAP_TOOL (desaturate_tool);  im_tool->apply_func = (GimpImageMapApplyFunc) desaturate_region;  im_tool->apply_data = &desaturate_tool->mode;}

static voidgimp_levels_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_levels_tool_config_notify),                           object, 0);}

static voidgimp_image_map_tool_constructed (GObject *object){  GimpImageMapTool *im_tool = GIMP_IMAGE_MAP_TOOL (object);  G_OBJECT_CLASS (parent_class)->constructed (object);  gimp_image_map_tool_get_operation (im_tool);}

static voidlevels_stretch_callback (GtkWidget      *widget,                      GimpLevelsTool *tool){  levels_stretch (tool->levels, tool->hist, tool->color);  levels_update (tool, ALL);  gimp_image_map_tool_preview (GIMP_IMAGE_MAP_TOOL (tool));}

static voidlevels_channel_reset_callback (GtkWidget      *widget,                               GimpLevelsTool *tool){  levels_channel_reset (tool->levels, tool->channel);  levels_update (tool, ALL);  gimp_image_map_tool_preview (GIMP_IMAGE_MAP_TOOL (tool));}

static voidgimp_posterize_tool_init (GimpPosterizeTool *posterize_tool){  GimpImageMapTool *im_tool = GIMP_IMAGE_MAP_TOOL (posterize_tool);  posterize_tool->lut = gimp_lut_new ();  im_tool->apply_func = (GimpImageMapApplyFunc) gimp_lut_process;  im_tool->apply_data = posterize_tool->lut;}

static voidgimp_brightness_contrast_tool_init (GimpBrightnessContrastTool *bc_tool){  GimpImageMapTool *im_tool = GIMP_IMAGE_MAP_TOOL (bc_tool);  bc_tool->lut = gimp_lut_new ();  im_tool->apply_func = (GimpImageMapApplyFunc) gimp_lut_process;  im_tool->apply_data = bc_tool->lut;}

static voidgimp_operation_tool_dialog (GimpImageMapTool *im_tool){  GimpOperationTool *tool = GIMP_OPERATION_TOOL (im_tool);  GtkWidget         *main_vbox;  main_vbox = gimp_image_map_tool_dialog_get_vbox (im_tool);  /*  The options vbox  */  tool->options_box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2);  gtk_box_pack_start (GTK_BOX (main_vbox), tool->options_box,                      FALSE, FALSE, 0);  gtk_widget_show (tool->options_box);  if (tool->aux_input_box)    {      gtk_box_pack_start (GTK_BOX (tool->options_box), tool->aux_input_box,                          FALSE, FALSE, 0);      gtk_widget_show (tool->aux_input_box);    }  if (tool->aux2_input_box)    {      gtk_box_pack_start (GTK_BOX (tool->options_box), tool->aux2_input_box,                          FALSE, FALSE, 0);      gtk_widget_show (tool->aux2_input_box);    }  if (tool->options_gui)    {      gtk_box_pack_start (GTK_BOX (tool->options_box), tool->options_gui,                          FALSE, FALSE, 0);      gtk_widget_show (tool->options_gui);    }  if (tool->undo_desc)    gimp_tool_gui_set_description (GIMP_IMAGE_MAP_TOOL (tool)->gui,                                   tool->undo_desc);  if (tool->icon_name)    gimp_tool_gui_set_icon_name (GIMP_IMAGE_MAP_TOOL (tool)->gui,                                 tool->icon_name);}

static voidgimp_curves_tool_button_release (GimpTool              *tool,                                 const GimpCoords      *coords,                                 guint32                time,                                 GdkModifierType        state,                                 GimpButtonReleaseType  release_type,                                 GimpDisplay           *display){  GimpCurvesTool   *c_tool  = GIMP_CURVES_TOOL (tool);  GimpImageMapTool *im_tool = GIMP_IMAGE_MAP_TOOL (tool);  GimpCurvesConfig *config  = GIMP_CURVES_CONFIG (im_tool->config);  if (state & gimp_get_extend_selection_mask ())    {      GimpCurve *curve = config->curve[config->channel];      gdouble    value = c_tool->picked_color[config->channel];      gint       closest;      closest = gimp_curve_get_closest_point (curve, value);      gimp_curve_view_set_selected (GIMP_CURVE_VIEW (c_tool->graph),                                    closest);      gimp_curve_set_point (curve, closest,                            value, gimp_curve_map_value (curve, value));    }  else if (state & gimp_get_toggle_behavior_mask ())    {      GimpHistogramChannel channel;      for (channel = GIMP_HISTOGRAM_VALUE;           channel <= GIMP_HISTOGRAM_ALPHA;           channel++)        {          GimpCurve *curve = config->curve[channel];          gdouble    value = c_tool->picked_color[channel];          gint       closest;          if (value != -1)            {              closest = gimp_curve_get_closest_point (curve, value);              gimp_curve_view_set_selected (GIMP_CURVE_VIEW (c_tool->graph),                                            closest);              gimp_curve_set_point (curve, closest,                                    value, gimp_curve_map_value (curve, value));            }        }    }  /*  chain up to halt the tool */  GIMP_TOOL_CLASS (parent_class)->button_release (tool, coords, time, state,                                                  release_type, display);}

static voidgimp_hue_saturation_tool_init (GimpHueSaturationTool *hs_tool){  GimpImageMapTool *im_tool = GIMP_IMAGE_MAP_TOOL (hs_tool);  hs_tool->hue_saturation = g_slice_new0 (HueSaturation);  hue_saturation_init (hs_tool->hue_saturation);  im_tool->apply_func = (GimpImageMapApplyFunc) hue_saturation;  im_tool->apply_data = hs_tool->hue_saturation;}

static voidgimp_color_balance_tool_init (GimpColorBalanceTool *cb_tool){  GimpImageMapTool *im_tool = GIMP_IMAGE_MAP_TOOL (cb_tool);  cb_tool->color_balance = g_slice_new0 (ColorBalance);  color_balance_init (cb_tool->color_balance);  im_tool->apply_func = (GimpImageMapApplyFunc) color_balance;  im_tool->apply_data = cb_tool->color_balance;}

static voidlevels_gamma_adjustment_update (GtkAdjustment  *adjustment,                                GimpLevelsTool *tool){  if (tool->levels->gamma[tool->channel] != adjustment->value)    {      tool->levels->gamma[tool->channel] = adjustment->value;      levels_update (tool, INPUT_LEVELS | INPUT_SLIDERS);      gimp_image_map_tool_preview (GIMP_IMAGE_MAP_TOOL (tool));    }}

static voidgimp_levels_tool_init (GimpLevelsTool *tool){  GimpImageMapTool *im_tool = GIMP_IMAGE_MAP_TOOL (tool);  tool->lut           = gimp_lut_new ();  tool->histogram     = gimp_histogram_new ();  tool->active_picker = NULL;  im_tool->apply_func = (GimpImageMapApplyFunc) gimp_lut_process;  im_tool->apply_data = tool->lut;}