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

GObject *gimp_curves_config_new_spline (gint32         channel,                               const gdouble *points,                               gint           n_points){  GimpCurvesConfig *config;  GimpCurve        *curve;  gint              i;  g_return_val_if_fail (channel >= GIMP_HISTOGRAM_VALUE &&                        channel <= GIMP_HISTOGRAM_ALPHA, NULL);  g_return_val_if_fail (points != NULL, NULL);  g_return_val_if_fail (n_points >= 2 && n_points <= 1024, NULL);  config = g_object_new (GIMP_TYPE_CURVES_CONFIG, NULL);  curve = config->curve[channel];  gimp_data_freeze (GIMP_DATA (curve));  gimp_curve_set_curve_type (curve, GIMP_CURVE_SMOOTH);  gimp_curve_set_n_samples (curve, n_points);  /*  unset the last point  */  gimp_curve_set_point (curve, curve->n_points - 1, -1.0, -1.0);  for (i = 0; i < n_points; i++)    gimp_curve_set_point (curve, i,                          (gdouble) points[i * 2],                          (gdouble) points[i * 2 + 1]);  gimp_data_thaw (GIMP_DATA (curve));  return G_OBJECT (config);}

static GimpValueArray *palette_delete_invoker (GimpProcedure         *procedure,                        Gimp                  *gimp,                        GimpContext           *context,                        GimpProgress          *progress,                        const GimpValueArray  *args,                        GError               **error){  gboolean success = TRUE;  const gchar *name;  name = g_value_get_string (gimp_value_array_index (args, 0));  if (success)    {      GimpPalette *palette = gimp_pdb_get_palette (gimp, name, FALSE, error);      if (palette && gimp_data_is_deletable (GIMP_DATA (palette)))        success = gimp_data_factory_data_delete (gimp->palette_factory,                                                 GIMP_DATA (palette),                                                 TRUE, error);      else        success = FALSE;    }  return gimp_procedure_get_return_values (procedure, success,                                           error ? *error : NULL);}

GObject *gimp_curves_config_new_explicit (gint32         channel,                                 const gdouble *samples,                                 gint           n_samples){  GimpCurvesConfig *config;  GimpCurve        *curve;  gint              i;  g_return_val_if_fail (channel >= GIMP_HISTOGRAM_VALUE &&                        channel <= GIMP_HISTOGRAM_ALPHA, NULL);  g_return_val_if_fail (samples != NULL, NULL);  g_return_val_if_fail (n_samples >= 2 && n_samples <= 4096, NULL);  config = g_object_new (GIMP_TYPE_CURVES_CONFIG, NULL);  curve = config->curve[channel];  gimp_data_freeze (GIMP_DATA (curve));  gimp_curve_set_curve_type (curve, GIMP_CURVE_FREE);  gimp_curve_set_n_samples (curve, n_samples);  for (i = 0; i < n_samples; i++)    gimp_curve_set_curve (curve,                          (gdouble) i / (gdouble) (n_samples - 1),                          (gdouble) samples[i]);  gimp_data_thaw (GIMP_DATA (curve));  return G_OBJECT (config);}

voidgradient_editor_load_right_cmd_callback (GtkAction *action,                                         gint       value,                                         gpointer   data){  GimpGradientEditor  *editor      = GIMP_GRADIENT_EDITOR (data);  GimpDataEditor      *data_editor = GIMP_DATA_EDITOR (data);  GimpGradient        *gradient;  GimpGradientSegment *seg;  GimpRGB              color;  GimpGradientColor    color_type = GIMP_GRADIENT_COLOR_FIXED;  gradient = GIMP_GRADIENT (data_editor->data);  switch (value)    {    case GRADIENT_EDITOR_COLOR_NEIGHBOR_ENDPOINT:      if (editor->control_sel_r->next != NULL)        seg = editor->control_sel_r->next;      else        seg = gimp_gradient_segment_get_first (editor->control_sel_r);      color      = seg->left_color;      color_type = seg->left_color_type;      break;    case GRADIENT_EDITOR_COLOR_OTHER_ENDPOINT:      color      = editor->control_sel_l->left_color;      color_type = editor->control_sel_l->left_color_type;      break;    case GRADIENT_EDITOR_COLOR_FOREGROUND:      gimp_context_get_foreground (data_editor->context, &color);      break;    case GRADIENT_EDITOR_COLOR_BACKGROUND:      gimp_context_get_background (data_editor->context, &color);      break;    default: /* Load a color */      color = editor->saved_colors[value - GRADIENT_EDITOR_COLOR_FIRST_CUSTOM];      break;    }  gimp_data_freeze (GIMP_DATA (gradient));  gimp_gradient_segment_range_blend (gradient,                                     editor->control_sel_l,                                     editor->control_sel_r,                                     &editor->control_sel_l->left_color,                                     &color,                                     TRUE, TRUE);  gimp_gradient_segment_set_right_color_type (gradient,                                              editor->control_sel_l,                                              color_type);  gimp_data_thaw (GIMP_DATA (gradient));}

static voidgimp_brush_editor_update_brush (GtkAdjustment   *adjustment,                                GimpBrushEditor *editor){  GimpBrushGenerated *brush;  gdouble             radius;  gint                spikes;  gdouble             hardness;  gdouble             ratio;  gdouble             angle;  gdouble             spacing;  if (! GIMP_IS_BRUSH_GENERATED (GIMP_DATA_EDITOR (editor)->data))    return;  brush = GIMP_BRUSH_GENERATED (GIMP_DATA_EDITOR (editor)->data);  radius   = gtk_adjustment_get_value (editor->radius_data);  spikes   = ROUND (gtk_adjustment_get_value (editor->spikes_data));  hardness = gtk_adjustment_get_value (editor->hardness_data);  ratio    = gtk_adjustment_get_value (editor->aspect_ratio_data);  angle    = gtk_adjustment_get_value (editor->angle_data);  spacing  = gtk_adjustment_get_value (editor->spacing_data);  if (radius   != gimp_brush_generated_get_radius       (brush) ||      spikes   != gimp_brush_generated_get_spikes       (brush) ||      hardness != gimp_brush_generated_get_hardness     (brush) ||      ratio    != gimp_brush_generated_get_aspect_ratio (brush) ||      angle    != gimp_brush_generated_get_angle        (brush) ||      spacing  != gimp_brush_get_spacing                (GIMP_BRUSH (brush)))    {      g_signal_handlers_block_by_func (brush,                                       gimp_brush_editor_notify_brush,                                       editor);      gimp_data_freeze (GIMP_DATA (brush));      g_object_freeze_notify (G_OBJECT (brush));      gimp_brush_generated_set_radius       (brush, radius);      gimp_brush_generated_set_spikes       (brush, spikes);      gimp_brush_generated_set_hardness     (brush, hardness);      gimp_brush_generated_set_aspect_ratio (brush, ratio);      gimp_brush_generated_set_angle        (brush, angle);      gimp_brush_set_spacing                (GIMP_BRUSH (brush), spacing);      g_object_thaw_notify (G_OBJECT (brush));      gimp_data_thaw (GIMP_DATA (brush));      g_signal_handlers_unblock_by_func (brush,                                         gimp_brush_editor_notify_brush,                                         editor);    }}

static GimpValueArray *palette_is_editable_invoker (GimpProcedure         *procedure,                             Gimp                  *gimp,                             GimpContext           *context,                             GimpProgress          *progress,                             const GimpValueArray  *args,                             GError               **error){  gboolean success = TRUE;  GimpValueArray *return_vals;  const gchar *name;  gboolean editable = FALSE;  name = g_value_get_string (gimp_value_array_index (args, 0));  if (success)    {      GimpPalette *palette = gimp_pdb_get_palette (gimp, name, FALSE, error);      if (palette)        editable = gimp_data_is_writable (GIMP_DATA (palette));      else        success = FALSE;    }  return_vals = gimp_procedure_get_return_values (procedure, success,                                                  error ? *error : NULL);  if (success)    g_value_set_boolean (gimp_value_array_index (return_vals, 1), editable);  return return_vals;}

static GValueArray *palette_set_columns_invoker (GimpProcedure     *procedure,                             Gimp              *gimp,                             GimpContext       *context,                             GimpProgress      *progress,                             const GValueArray *args){  gboolean success = TRUE;  const gchar *name;  gint32 columns;  name = g_value_get_string (&args->values[0]);  columns = g_value_get_int (&args->values[1]);  if (success)    {      GimpPalette *palette = (GimpPalette *)        gimp_container_get_child_by_name (gimp->palette_factory->container, name);      if (palette && GIMP_DATA (palette)->writable)        gimp_palette_set_columns (palette, columns);      else        success = FALSE;    }  return gimp_procedure_get_return_values (procedure, success);}

static GValueArray *palette_is_editable_invoker (GimpProcedure     *procedure,                             Gimp              *gimp,                             GimpContext       *context,                             GimpProgress      *progress,                             const GValueArray *args){  gboolean success = TRUE;  GValueArray *return_vals;  const gchar *name;  gboolean editable = FALSE;  name = g_value_get_string (&args->values[0]);  if (success)    {      GimpPalette *palette = (GimpPalette *)        gimp_container_get_child_by_name (gimp->palette_factory->container, name);      if (palette)        editable = GIMP_DATA (palette)->writable;      else        success = FALSE;    }  return_vals = gimp_procedure_get_return_values (procedure, success);  if (success)    g_value_set_boolean (&return_vals->values[1], editable);  return return_vals;}

voiddynamics_actions_update (GimpActionGroup *group,                         gpointer         user_data){  GimpContext  *context  = action_data_get_context (user_data);  GimpDynamics *dynamics = NULL;  GimpData     *data     = NULL;  const gchar  *filename = NULL;  if (context)    {      dynamics = gimp_context_get_dynamics (context);      if (dynamics)        {          data = GIMP_DATA (dynamics);          filename = gimp_data_get_filename (data);        }    }#define SET_SENSITIVE(action,condition) /        gimp_action_group_set_action_sensitive (group, action, (condition) != 0)  SET_SENSITIVE ("dynamics-edit",          dynamics);  SET_SENSITIVE ("dynamics-duplicate",     dynamics && GIMP_DATA_GET_CLASS (data)->duplicate);  SET_SENSITIVE ("dynamics-copy-location", dynamics && filename);  SET_SENSITIVE ("dynamics-delete",        dynamics && gimp_data_is_deletable (data));#undef SET_SENSITIVE}

GimpGradient *gimp_pdb_get_gradient (Gimp         *gimp,                       const gchar  *name,                       gboolean      writable,                       GError      **error){  GimpGradient *gradient;  g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);  g_return_val_if_fail (error == NULL || *error == NULL, NULL);  if (! name || ! strlen (name))    {      g_set_error_literal (error, GIMP_PDB_ERROR, GIMP_PDB_ERROR_INVALID_ARGUMENT,			   _("Invalid empty gradient name"));      return NULL;    }  gradient = (GimpGradient *) gimp_pdb_get_data_factory_item (gimp->gradient_factory, name);  if (! gradient)    {      g_set_error (error, GIMP_PDB_ERROR, GIMP_PDB_ERROR_INVALID_ARGUMENT,                   _("Gradient '%s' not found"), name);    }  else if (writable && ! gimp_data_is_writable (GIMP_DATA (gradient)))    {      g_set_error (error, GIMP_PDB_ERROR, GIMP_PDB_ERROR_INVALID_ARGUMENT,                   _("Gradient '%s' is not editable"), name);      return NULL;    }  return gradient;}

GimpDynamics *gimp_pdb_get_dynamics (Gimp         *gimp,                       const gchar  *name,                       gboolean      writable,                       GError      **error){  GimpDynamics *dynamics;  g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);  g_return_val_if_fail (error == NULL || *error == NULL, NULL);  if (! name || ! strlen (name))    {      g_set_error_literal (error, GIMP_PDB_ERROR, GIMP_PDB_ERROR_INVALID_ARGUMENT,			   _("Invalid empty paint dynamics name"));      return NULL;    }  dynamics = (GimpDynamics *) gimp_pdb_get_data_factory_item (gimp->dynamics_factory, name);  if (! dynamics)    {      g_set_error (error, GIMP_PDB_ERROR, GIMP_PDB_ERROR_INVALID_ARGUMENT,                   _("Paint dynamics '%s' not found"), name);    }  else if (writable && ! gimp_data_is_writable (GIMP_DATA (dynamics)))    {      g_set_error (error, GIMP_PDB_ERROR, GIMP_PDB_ERROR_INVALID_ARGUMENT,                   _("Paint dynamics '%s' is not editable"), name);      return NULL;    }  return dynamics;}

GimpData *gimp_pattern_new (GimpContext *context,                  const gchar *name){  GimpPattern *pattern;  guchar      *data;  gint         row, col;  g_return_val_if_fail (name != NULL, NULL);  g_return_val_if_fail (name[0] != '/n', NULL);  pattern = g_object_new (GIMP_TYPE_PATTERN,                          "name", name,                          NULL);  pattern->mask = gimp_temp_buf_new (32, 32, babl_format ("R'G'B' u8"));  data = gimp_temp_buf_get_data (pattern->mask);  for (row = 0; row < gimp_temp_buf_get_height (pattern->mask); row++)    for (col = 0; col < gimp_temp_buf_get_width (pattern->mask); col++)      {        memset (data, (col % 2) && (row % 2) ? 255 : 0, 3);        data += 3;      }  return GIMP_DATA (pattern);}

GimpPalette *gimp_pdb_get_palette (Gimp         *gimp,                      const gchar  *name,                      gboolean      writable,                      GError      **error){  GimpPalette *palette;  g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);  g_return_val_if_fail (error == NULL || *error == NULL, NULL);  if (! name || ! strlen (name))    {      g_set_error_literal (error, GIMP_PDB_ERROR, GIMP_PDB_ERROR_INVALID_ARGUMENT,			   _("Invalid empty palette name"));      return NULL;    }  palette = (GimpPalette *) gimp_pdb_get_data_factory_item (gimp->palette_factory, name);  if (! palette)    {      g_set_error (error, GIMP_PDB_ERROR, GIMP_PDB_ERROR_INVALID_ARGUMENT,                   _("Palette '%s' not found"), name);    }  else if (writable && ! gimp_data_is_writable (GIMP_DATA (palette)))    {      g_set_error (error, GIMP_PDB_ERROR, GIMP_PDB_ERROR_INVALID_ARGUMENT,                   _("Palette '%s' is not editable"), name);      return NULL;    }  return palette;}

GimpData *gimp_brush_generated_new (const gchar             *name,                          GimpBrushGeneratedShape  shape,                          gfloat                   radius,                          gint                     spikes,                          gfloat                   hardness,                          gfloat                   aspect_ratio,                          gfloat                   angle){  GimpBrushGenerated *brush;  g_return_val_if_fail (name != NULL, NULL);  g_return_val_if_fail (*name != '/0', NULL);  brush = g_object_new (GIMP_TYPE_BRUSH_GENERATED,                        "name",         name,                        "mime-type",    "application/x-gimp-brush-generated",                        "spacing",      20.0,                        "shape",        shape,                        "radius",       radius,                        "spikes",       spikes,                        "hardness",     hardness,                        "aspect-ratio", aspect_ratio,                        "angle",        angle,                        NULL);  return GIMP_DATA (brush);}

GimpBrush *gimp_pdb_get_brush (Gimp         *gimp,                    const gchar  *name,                    gboolean      writable,                    GError      **error){  GimpBrush *brush;  g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);  g_return_val_if_fail (error == NULL || *error == NULL, NULL);  if (! name || ! strlen (name))    {      g_set_error_literal (error, GIMP_PDB_ERROR, GIMP_PDB_ERROR_INVALID_ARGUMENT,			   _("Invalid empty brush name"));      return NULL;    }  brush = (GimpBrush *) gimp_pdb_get_data_factory_item (gimp->brush_factory, name);  if (! brush)    {      g_set_error (error, GIMP_PDB_ERROR, GIMP_PDB_ERROR_INVALID_ARGUMENT,                   _("Brush '%s' not found"), name);    }  else if (writable && ! gimp_data_is_writable (GIMP_DATA (brush)))    {      g_set_error (error, GIMP_PDB_ERROR, GIMP_PDB_ERROR_INVALID_ARGUMENT,                   _("Brush '%s' is not editable"), name);      return NULL;    }  return brush;}

voidgimp_curve_delete_point (GimpCurve *curve,                         gint       point){  g_return_if_fail (GIMP_IS_CURVE (curve));  g_return_if_fail (point >= 0 && point < curve->n_points);  if (point == 0)    {      curve->points[0].x = 0.0;      curve->points[0].y = 0.0;    }  else if (point == curve->n_points - 1)    {      curve->points[curve->n_points - 1].x = 1.0;      curve->points[curve->n_points - 1].y = 1.0;    }  else    {      curve->points[point].x = -1.0;      curve->points[point].y = -1.0;    }  g_object_notify (G_OBJECT (curve), "points");  gimp_data_dirty (GIMP_DATA (curve));}

static voidpalette_editor_edit_color_update (GimpColorDialog      *dialog,                                  const GimpRGB        *color,                                  GimpColorDialogState  state,                                  GimpPaletteEditor    *editor){  GimpPalette *palette = GIMP_PALETTE (GIMP_DATA_EDITOR (editor)->data);  switch (state)    {    case GIMP_COLOR_DIALOG_UPDATE:      break;    case GIMP_COLOR_DIALOG_OK:      if (editor->color)        {          editor->color->color = *color;          gimp_data_dirty (GIMP_DATA (palette));        }      /* Fallthrough */    case GIMP_COLOR_DIALOG_CANCEL:      gtk_widget_hide (editor->color_dialog);      break;    }}

voidtool_presets_actions_update (GimpActionGroup *group,                             gpointer         user_data){  GimpContext    *context     = action_data_get_context (user_data);  GimpToolPreset *tool_preset = NULL;  GimpData       *data        = NULL;  GFile          *file        = NULL;  if (context)    {      tool_preset = gimp_context_get_tool_preset (context);      if (tool_preset)        {          data = GIMP_DATA (tool_preset);          file = gimp_data_get_file (data);        }    }#define SET_SENSITIVE(action,condition) /        gimp_action_group_set_action_sensitive (group, action, (condition) != 0)  SET_SENSITIVE ("tool-presets-edit",                 tool_preset);  SET_SENSITIVE ("tool-presets-duplicate",            tool_preset && GIMP_DATA_GET_CLASS (data)->duplicate);  SET_SENSITIVE ("tool-presets-copy-location",        file);  SET_SENSITIVE ("tool-presets-show-in-file-manager", file);  SET_SENSITIVE ("tool-presets-restore",              tool_preset);  SET_SENSITIVE ("tool-presets-delete",               tool_preset && gimp_data_is_deletable (data));#undef SET_SENSITIVE}

voidcontext_brush_shape_cmd_callback (GtkAction *action,                                  gint       value,                                  gpointer   data){  GimpContext *context;  GimpBrush   *brush;  return_if_no_context (context, data);  brush = gimp_context_get_brush (context);  if (GIMP_IS_BRUSH_GENERATED (brush) &&      gimp_data_is_writable (GIMP_DATA (brush)))    {      GimpBrushGenerated *generated = GIMP_BRUSH_GENERATED (brush);      GimpDisplay        *display;      const char         *value_desc;      gimp_brush_generated_set_shape (generated,                                      (GimpBrushGeneratedShape) value);      gimp_enum_get_value (GIMP_TYPE_BRUSH_GENERATED_SHAPE, value,                           NULL, NULL, &value_desc, NULL);      display = action_data_get_display (data);      if (value_desc && display)        {          action_message (display, G_OBJECT (brush),                          _("Brush Shape: %s"), value_desc);        }    }}

voidgimp_drawable_curves_spline (GimpDrawable *drawable,                             GimpProgress *progress,                             gint32        channel,                             const guint8 *points,                             gint          n_points){  GimpCurvesConfig *config;  GimpCurve        *curve;  gint              i;  g_return_if_fail (GIMP_IS_DRAWABLE (drawable));  g_return_if_fail (! gimp_drawable_is_indexed (drawable));  g_return_if_fail (gimp_item_is_attached (GIMP_ITEM (drawable)));  g_return_if_fail (channel >= GIMP_HISTOGRAM_VALUE &&                    channel <= GIMP_HISTOGRAM_ALPHA);  if (channel == GIMP_HISTOGRAM_ALPHA)    g_return_if_fail (gimp_drawable_has_alpha (drawable));  if (gimp_drawable_is_gray (drawable))    g_return_if_fail (channel == GIMP_HISTOGRAM_VALUE ||                      channel == GIMP_HISTOGRAM_ALPHA);  config = g_object_new (GIMP_TYPE_CURVES_CONFIG, NULL);  curve = config->curve[channel];  gimp_data_freeze (GIMP_DATA (curve));  /* FIXME: create a curves object with the right number of points */  /*  unset the last point  */  gimp_curve_set_point (curve, curve->n_points - 1, -1, -1);  n_points = MIN (n_points / 2, curve->n_points);  for (i = 0; i < n_points; i++)    gimp_curve_set_point (curve, i,                          (gdouble) points[i * 2]     / 255.0,                          (gdouble) points[i * 2 + 1] / 255.0);  gimp_data_thaw (GIMP_DATA (curve));  gimp_drawable_curves (drawable, progress, config);  g_object_unref (config);}

voidcontext_brush_radius_cmd_callback (GtkAction *action,                                   gint       value,                                   gpointer   data){  GimpContext *context;  GimpBrush   *brush;  return_if_no_context (context, data);  brush = gimp_context_get_brush (context);  if (GIMP_IS_BRUSH_GENERATED (brush) &&      gimp_data_is_writable (GIMP_DATA (brush)))    {      GimpBrushGenerated *generated = GIMP_BRUSH_GENERATED (brush);      GimpDisplay        *display;      gdouble             radius;      gdouble             min_radius;      radius = gimp_brush_generated_get_radius (generated);      /* If the user uses a high precision radius adjustment command       * then we allow a minimum radius of 0.1 px, otherwise we set the       * minimum radius to 1.0 px and adjust the radius to 1.0 px if it       * is less than 1.0 px. This prevents irritating 0.1, 1.1, 2.1 etc       * radius sequences when 1.0 px steps are used.       */      switch ((GimpActionSelectType) value)        {        case GIMP_ACTION_SELECT_SMALL_PREVIOUS:        case GIMP_ACTION_SELECT_SMALL_NEXT:        case GIMP_ACTION_SELECT_PERCENT_PREVIOUS:        case GIMP_ACTION_SELECT_PERCENT_NEXT:          min_radius = 0.1;          break;        default:          min_radius = 1.0;          if (radius < 1.0)            radius = 1.0;          break;        }      radius = action_select_value ((GimpActionSelectType) value,                                    radius,                                    min_radius, 4000.0, min_radius,                                    0.1, 1.0, 10.0, 0.05, FALSE);      gimp_brush_generated_set_radius (generated, radius);      display = action_data_get_display (data);      if (display)        {          action_message (action_data_get_display (data), G_OBJECT (brush),                          _("Brush Radius: %2.2f"), radius);        }    }}

static voidpalette_editor_drop_palette (GtkWidget    *widget,                             gint          x,                             gint          y,                             GimpViewable *viewable,                             gpointer      data){  gimp_data_editor_set_data (GIMP_DATA_EDITOR (data), GIMP_DATA (viewable));}

static GimpData *gimp_pattern_duplicate (GimpData *data){  GimpPattern *pattern = g_object_new (GIMP_TYPE_PATTERN, NULL);  pattern->mask = gimp_temp_buf_copy (GIMP_PATTERN (data)->mask);  return GIMP_DATA (pattern);}

voidgimp_drawable_curves_explicit (GimpDrawable *drawable,                               GimpProgress *progress,                               gint32        channel,                               const guint8 *points,                               gint          n_points){  GimpCurvesConfig *config;  GimpCurve        *curve;  gint              i;  g_return_if_fail (GIMP_IS_DRAWABLE (drawable));  g_return_if_fail (! gimp_drawable_is_indexed (drawable));  g_return_if_fail (gimp_item_is_attached (GIMP_ITEM (drawable)));  g_return_if_fail (channel >= GIMP_HISTOGRAM_VALUE &&                    channel <= GIMP_HISTOGRAM_ALPHA);  if (channel == GIMP_HISTOGRAM_ALPHA)    g_return_if_fail (gimp_drawable_has_alpha (drawable));  if (gimp_drawable_is_gray (drawable))    g_return_if_fail (channel == GIMP_HISTOGRAM_VALUE ||                      channel == GIMP_HISTOGRAM_ALPHA);  config = g_object_new (GIMP_TYPE_CURVES_CONFIG, NULL);  curve = config->curve[channel];  gimp_data_freeze (GIMP_DATA (curve));  gimp_curve_set_curve_type (curve, GIMP_CURVE_FREE);  for (i = 0; i < 256; i++)    gimp_curve_set_curve (curve,                          (gdouble) i         / 255.0,                          (gdouble) points[i] / 255.0);  gimp_data_thaw (GIMP_DATA (curve));  gimp_drawable_curves (drawable, progress, config);  g_object_unref (config);}

static GValueArray *palette_entry_set_name_invoker (GimpProcedure     *procedure,                                Gimp              *gimp,                                GimpContext       *context,                                GimpProgress      *progress,                                const GValueArray *args){  gboolean success = TRUE;  const gchar *name;  gint32 entry_num;  const gchar *entry_name;  name = g_value_get_string (&args->values[0]);  entry_num = g_value_get_int (&args->values[1]);  entry_name = g_value_get_string (&args->values[2]);  if (success)    {      GimpPalette *palette = (GimpPalette *)        gimp_container_get_child_by_name (gimp->palette_factory->container, name);      if (palette && GIMP_DATA (palette)->writable)        {          if (entry_num >= 0 && entry_num < palette->n_colors)            {              GimpPaletteEntry *entry = g_list_nth_data (palette->colors, entry_num);              g_free (entry->name);              entry->name = g_strdup (entry_name);              gimp_data_dirty (GIMP_DATA (palette));            }          else            success = FALSE;        }      else        success = FALSE;    }  return gimp_procedure_get_return_values (procedure, success);}

static voidgimp_data_factory_view_tree_name_edited (GtkCellRendererText *cell,                                         const gchar         *path_str,                                         const gchar         *new_name,                                         GimpDataFactoryView *view){  GimpContainerTreeView *tree_view;  GtkTreePath           *path;  GtkTreeIter            iter;  tree_view = GIMP_CONTAINER_TREE_VIEW (GIMP_CONTAINER_EDITOR (view)->view);  path = gtk_tree_path_new_from_string (path_str);  if (gtk_tree_model_get_iter (tree_view->model, &iter, path))    {      GimpViewRenderer *renderer;      GimpData         *data;      gchar            *name;      gtk_tree_model_get (tree_view->model, &iter,                          tree_view->model_column_renderer, &renderer,                          -1);      data = GIMP_DATA (renderer->viewable);      if (! new_name)        new_name = "";      name = g_strstrip (g_strdup (new_name));      if (data->writable && strlen (name))        {          gimp_object_take_name (GIMP_OBJECT (data), name);        }      else        {          g_free (name);          name = gimp_viewable_get_description (renderer->viewable, NULL);          gtk_list_store_set (GTK_LIST_STORE (tree_view->model), &iter,                              tree_view->model_column_name, name,                              -1);          g_free (name);        }      g_object_unref (renderer);    }  gtk_tree_path_free (path);}

voidgradient_editor_right_color_type_cmd_callback (GtkAction *action,                                               GtkAction *current,                                               gpointer   data){  GimpGradientEditor *editor = GIMP_GRADIENT_EDITOR (data);  GimpGradient       *gradient;  gint                value;  gradient = GIMP_GRADIENT (GIMP_DATA_EDITOR (editor)->data);  value = gtk_radio_action_get_current_value (GTK_RADIO_ACTION (action));  if (gradient && value >= 0)    {      GimpGradientColor color_type = value;      GimpRGB           color;      gimp_gradient_get_color_at (gradient,                                  GIMP_DATA_EDITOR (editor)->context,                                  editor->control_sel_r,                                  editor->control_sel_r->right, FALSE,                                  &color);      gimp_data_freeze (GIMP_DATA (gradient));      gimp_gradient_segment_set_right_color_type (gradient,                                                  editor->control_sel_r,                                                  color_type);      if (color_type == GIMP_GRADIENT_COLOR_FIXED)        gimp_gradient_segment_set_right_color (gradient,                                               editor->control_sel_r,                                               &color);      gimp_data_thaw (GIMP_DATA (gradient));    }}

static GValueArray *palette_delete_invoker (GimpProcedure     *procedure,                        Gimp              *gimp,                        GimpContext       *context,                        GimpProgress      *progress,                        const GValueArray *args){  gboolean success = TRUE;  const gchar *name;  name = g_value_get_string (&args->values[0]);  if (success)    {      GimpPalette *palette = (GimpPalette *)        gimp_container_get_child_by_name (gimp->palette_factory->container, name);      if (palette && GIMP_DATA (palette)->deletable)        {          GError *error = NULL;          success = gimp_data_factory_data_delete (gimp->palette_factory,                                                   GIMP_DATA (palette),                                                   TRUE, &error);          if (! success)            {              gimp_message (gimp, G_OBJECT (progress), GIMP_MESSAGE_ERROR,                                   "%s", error->message);              g_clear_error (&error);            }        }      else        success = FALSE;    }  return gimp_procedure_get_return_values (procedure, success);}

voidtool_options_delete_preset_cmd_callback (GtkAction *action,        gint       value,        gpointer   data){    GimpEditor     *editor    = GIMP_EDITOR (data);    GimpContext    *context   = gimp_get_user_context (gimp_editor_get_ui_manager (editor)->gimp);    GimpToolInfo   *tool_info = gimp_context_get_tool (context);    GimpToolPreset *preset;    preset = (GimpToolPreset *)             gimp_container_get_child_by_index (tool_info->presets, value);    if (preset &&            gimp_data_is_deletable (GIMP_DATA (preset)))    {        GimpDataFactory *factory = context->gimp->tool_preset_factory;        GtkWidget       *dialog;        dialog = data_delete_dialog_new (factory, GIMP_DATA (preset), NULL,                                         GTK_WIDGET (editor));        gtk_widget_show (dialog);    }}

voidgimp_curve_set_curve_type (GimpCurve     *curve,                           GimpCurveType  curve_type){  g_return_if_fail (GIMP_IS_CURVE (curve));  if (curve->curve_type != curve_type)    {      g_object_freeze_notify (G_OBJECT (curve));      curve->curve_type = curve_type;      if (curve_type == GIMP_CURVE_SMOOTH)        {          gint n_points;          gint i;          for (i = 0; i < curve->n_points; i++)            {              curve->points[i].x = -1;              curve->points[i].y = -1;            }          /*  pick some points from the curve and make them control           *  points           */          n_points = CLAMP (9, curve->n_points / 2, curve->n_points);          for (i = 0; i < n_points; i++)            {              gint sample = i * (curve->n_samples - 1) / (n_points - 1);              gint point  = i * (curve->n_points  - 1) / (n_points - 1);              curve->points[point].x = ((gdouble) sample /                                        (gdouble) (curve->n_samples - 1));              curve->points[point].y = curve->samples[sample];            }          g_object_notify (G_OBJECT (curve), "points");        }      g_object_notify (G_OBJECT (curve), "curve-type");      g_object_thaw_notify (G_OBJECT (curve));      gimp_data_dirty (GIMP_DATA (curve));    }}