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

voidregister_message_procs (GimpPDB *pdb){  GimpProcedure *procedure;  /*   * gimp-message   */  procedure = gimp_procedure_new (message_invoker);  gimp_object_set_static_name (GIMP_OBJECT (procedure),                               "gimp-message");  gimp_procedure_set_static_strings (procedure,                                     "gimp-message",                                     "Displays a dialog box with a message.",                                     "Displays a dialog box with a message. Useful for status or error reporting. The message must be in UTF-8 encoding.",                                     "Manish Singh",                                     "Manish Singh",                                     "1998",                                     NULL);  gimp_procedure_add_argument (procedure,                               gimp_param_spec_string ("message",                                                       "message",                                                       "Message to display in the dialog",                                                       FALSE, FALSE, FALSE,                                                       NULL,                                                       GIMP_PARAM_READWRITE));  gimp_pdb_register_procedure (pdb, procedure);  g_object_unref (procedure);  /*   * gimp-message-get-handler   */  procedure = gimp_procedure_new (message_get_handler_invoker);  gimp_object_set_static_name (GIMP_OBJECT (procedure),                               "gimp-message-get-handler");  gimp_procedure_set_static_strings (procedure,                                     "gimp-message-get-handler",                                     "Returns the current state of where warning messages are displayed.",                                     "This procedure returns the way g_message warnings are displayed. They can be shown in a dialog box or printed on the console where gimp was started.",                                     "Manish Singh",                                     "Manish Singh",                                     "1998",                                     NULL);  gimp_procedure_add_return_value (procedure,                                   g_param_spec_enum ("handler",                                                      "handler",                                                      "The current handler type",                                                      GIMP_TYPE_MESSAGE_HANDLER_TYPE,                                                      GIMP_MESSAGE_BOX,                                                      GIMP_PARAM_READWRITE));  gimp_pdb_register_procedure (pdb, procedure);  g_object_unref (procedure);  /*   * gimp-message-set-handler   */  procedure = gimp_procedure_new (message_set_handler_invoker);  gimp_object_set_static_name (GIMP_OBJECT (procedure),                               "gimp-message-set-handler");  gimp_procedure_set_static_strings (procedure,                                     "gimp-message-set-handler",                                     "Controls where warning messages are displayed.",                                     "This procedure controls how g_message warnings are displayed. They can be shown in a dialog box or printed on the console where gimp was started.",                                     "Manish Singh",                                     "Manish Singh",                                     "1998",                                     NULL);  gimp_procedure_add_argument (procedure,                               g_param_spec_enum ("handler",                                                  "handler",                                                  "The new handler type",                                                  GIMP_TYPE_MESSAGE_HANDLER_TYPE,                                                  GIMP_MESSAGE_BOX,                                                  GIMP_PARAM_READWRITE));  gimp_pdb_register_procedure (pdb, procedure);  g_object_unref (procedure);}

static voidplug_in_actions_history_changed (GimpPlugInManager *manager,                                 GimpActionGroup   *group){    GimpPlugInProcedure *proc;    gint                 i;    proc = gimp_plug_in_manager_history_nth (manager, 0);    if (proc)    {        GtkAction   *actual_action;        const gchar *label;        gchar       *repeat;        gchar       *reshow;        gboolean     sensitive = FALSE;        /*  copy the sensitivity of the plug-in procedure's actual action         *  instead of calling plug_in_actions_update() because doing the         *  latter would set the sensitivity of this image's action on         *  all images' actions. See bug #517683.         */        actual_action = gtk_action_group_get_action (GTK_ACTION_GROUP (group),                        GIMP_OBJECT (proc)->name);        if (actual_action)            sensitive = gtk_action_get_sensitive (actual_action);        label = gimp_plug_in_procedure_get_label (proc);        repeat = g_strdup_printf (_("Re_peat /"%s/""),  label);        reshow = g_strdup_printf (_("R_e-Show /"%s/""), label);        gimp_action_group_set_action_label (group, "plug-in-repeat", repeat);        gimp_action_group_set_action_label (group, "plug-in-reshow", reshow);        gimp_action_group_set_action_sensitive (group, "plug-in-repeat", sensitive);        gimp_action_group_set_action_sensitive (group, "plug-in-reshow", sensitive);        g_free (repeat);        g_free (reshow);    }    else    {        gimp_action_group_set_action_label (group, "plug-in-repeat",                                            _("Repeat Last"));        gimp_action_group_set_action_label (group, "plug-in-reshow",                                            _("Re-Show Last"));        gimp_action_group_set_action_sensitive (group, "plug-in-repeat", FALSE);        gimp_action_group_set_action_sensitive (group, "plug-in-reshow", FALSE);    }    for (i = 0; i < gimp_plug_in_manager_history_length (manager); i++)    {        GtkAction *action;        GtkAction *actual_action;        gchar     *name      = g_strdup_printf ("plug-in-recent-%02d", i + 1);        gboolean   sensitive = FALSE;        action = gtk_action_group_get_action (GTK_ACTION_GROUP (group), name);        g_free (name);        proc = gimp_plug_in_manager_history_nth (manager, i);        /*  see comment above  */        actual_action = gtk_action_group_get_action (GTK_ACTION_GROUP (group),                        GIMP_OBJECT (proc)->name);        if (actual_action)            sensitive = gtk_action_get_sensitive (actual_action);        g_object_set (action,                      "visible",   TRUE,                      "sensitive", sensitive,                      "procedure", proc,                      "label",     gimp_plug_in_procedure_get_label (proc),                      "stock-id",  gimp_plug_in_procedure_get_stock_id (proc),                      "tooltip",   gimp_plug_in_procedure_get_blurb (proc),                      NULL);    }    for (; i < gimp_plug_in_manager_history_size (manager); i++)    {        GtkAction *action;        gchar     *name = g_strdup_printf ("plug-in-recent-%02d", i + 1);        action = gtk_action_group_get_action (GTK_ACTION_GROUP (group), name);        g_free (name);        g_object_set (action,                      "visible",   FALSE,                      "procedure", NULL,                      NULL);    }}

//.........这里部分代码省略.........                     const gchar            *blurb,                     const gchar            *help,                     const gchar            *menu_label,                     const gchar            *menu_accel,                     const gchar            *help_domain,                     const gchar            *help_data,                     const gchar            *stock_id,                     gpointer                data){  Gimp         *gimp = (Gimp *) data;  GimpToolInfo *tool_info;  const gchar  *paint_core_name;  gboolean      visible;  g_return_if_fail (GIMP_IS_GIMP (gimp));  g_return_if_fail (g_type_is_a (tool_type, GIMP_TYPE_TOOL));  g_return_if_fail (tool_options_type == G_TYPE_NONE ||                    g_type_is_a (tool_options_type, GIMP_TYPE_TOOL_OPTIONS));  if (tool_options_type == G_TYPE_NONE)    tool_options_type = GIMP_TYPE_TOOL_OPTIONS;  if (tool_type == GIMP_TYPE_PENCIL_TOOL)    {      paint_core_name = "gimp-pencil";    }  else if (tool_type == GIMP_TYPE_PAINTBRUSH_TOOL)    {      paint_core_name = "gimp-paintbrush";    }  else if (tool_type == GIMP_TYPE_ERASER_TOOL)    {      paint_core_name = "gimp-eraser";    }  else if (tool_type == GIMP_TYPE_AIRBRUSH_TOOL)    {      paint_core_name = "gimp-airbrush";    }  else if (tool_type == GIMP_TYPE_CLONE_TOOL)    {      paint_core_name = "gimp-clone";    }  else if (tool_type == GIMP_TYPE_HEAL_TOOL)    {      paint_core_name = "gimp-heal";    }  else if (tool_type == GIMP_TYPE_PERSPECTIVE_CLONE_TOOL)    {      paint_core_name = "gimp-perspective-clone";    }  else if (tool_type == GIMP_TYPE_CONVOLVE_TOOL)    {      paint_core_name = "gimp-convolve";    }  else if (tool_type == GIMP_TYPE_SMUDGE_TOOL)    {      paint_core_name = "gimp-smudge";    }  else if (tool_type == GIMP_TYPE_DODGE_BURN_TOOL)    {      paint_core_name = "gimp-dodge-burn";    }  else if (tool_type == GIMP_TYPE_INK_TOOL)    {      paint_core_name = "gimp-ink";    }  else    {      paint_core_name = "gimp-paintbrush";    }  tool_info = gimp_tool_info_new (gimp,                                  tool_type,                                  tool_options_type,                                  context_props,                                  identifier,                                  blurb,                                  help,                                  menu_label,                                  menu_accel,                                  help_domain,                                  help_data,                                  paint_core_name,                                  stock_id);  visible = (! g_type_is_a (tool_type, GIMP_TYPE_IMAGE_MAP_TOOL));  g_object_set (tool_info, "visible", visible, NULL);  g_object_set_data (G_OBJECT (tool_info), "gimp-tool-default-visible",                     GINT_TO_POINTER (visible));  g_object_set_data (G_OBJECT (tool_info), "gimp-tool-options-gui-func",                     options_gui_func);  gimp_container_add (gimp->tool_info_list, GIMP_OBJECT (tool_info));  g_object_unref (tool_info);  if (tool_type == GIMP_TYPE_PAINTBRUSH_TOOL)    gimp_tool_info_set_standard (gimp, tool_info);}

GimpVectors *gimp_image_merge_visible_vectors (GimpImage  *image,                                  GError    **error){  GList       *list;  GList       *merge_list = NULL;  GimpVectors *vectors;  g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);  g_return_val_if_fail (error == NULL || *error == NULL, NULL);  for (list = gimp_image_get_vectors_iter (image);       list;       list = g_list_next (list))    {      vectors = list->data;      if (gimp_item_get_visible (GIMP_ITEM (vectors)))        merge_list = g_list_prepend (merge_list, vectors);    }  merge_list = g_list_reverse (merge_list);  if (merge_list && merge_list->next)    {      GimpVectors *target_vectors;      gchar       *name;      gint         pos;      gimp_set_busy (image->gimp);      gimp_image_undo_group_start (image, GIMP_UNDO_GROUP_IMAGE_VECTORS_MERGE,                                   C_("undo-type", "Merge Visible Paths"));      vectors = GIMP_VECTORS (merge_list->data);      name = g_strdup (gimp_object_get_name (vectors));      pos = gimp_item_get_index (GIMP_ITEM (vectors));      target_vectors = GIMP_VECTORS (gimp_item_duplicate (GIMP_ITEM (vectors),                                                          GIMP_TYPE_VECTORS));      gimp_image_remove_vectors (image, vectors, TRUE, NULL);      for (list = g_list_next (merge_list);           list;           list = g_list_next (list))        {          vectors = list->data;          gimp_vectors_add_strokes (vectors, target_vectors);          gimp_image_remove_vectors (image, vectors, TRUE, NULL);        }      gimp_object_take_name (GIMP_OBJECT (target_vectors), name);      g_list_free (merge_list);      /* FIXME tree */      gimp_image_add_vectors (image, target_vectors, NULL, pos, TRUE);      gimp_unset_busy (image->gimp);      gimp_image_undo_group_end (image);      return target_vectors;    }  else    {      g_set_error_literal (error, GIMP_ERROR, GIMP_FAILED,			   _("Not enough visible paths for a merge. "			     "There must be at least two."));      return NULL;    }}

voidplug_in_actions_update (GimpActionGroup *group,                        gpointer         data){    GimpImage         *image = action_data_get_image (data);    GimpPlugInManager *manager;    GimpImageType      type  = -1;    GSList            *list;    gint               i;    manager = group->gimp->plug_in_manager;    if (image)    {        GimpDrawable *drawable = gimp_image_get_active_drawable (image);        if (drawable)            type = gimp_drawable_type (drawable);    }    for (list = manager->plug_in_procedures; list; list = g_slist_next (list))    {        GimpPlugInProcedure *proc = list->data;        if ((proc->menu_label || proc->menu_paths) &&                ! proc->file_proc                      &&                proc->image_types_val)        {            gboolean sensitive = gimp_plug_in_procedure_get_sensitive (proc, type);            gimp_action_group_set_action_sensitive (group,                                                    GIMP_OBJECT (proc)->name,                                                    sensitive);        }    }    if (manager->history &&            gimp_plug_in_procedure_get_sensitive (manager->history->data, type))    {        gimp_action_group_set_action_sensitive (group, "plug-in-repeat", TRUE);        gimp_action_group_set_action_sensitive (group, "plug-in-reshow", TRUE);    }    else    {        gimp_action_group_set_action_sensitive (group, "plug-in-repeat", FALSE);        gimp_action_group_set_action_sensitive (group, "plug-in-reshow", FALSE);    }    for (list = manager->history, i = 0; list; list = list->next, i++)    {        GimpPlugInProcedure *proc = list->data;        gchar               *name = g_strdup_printf ("plug-in-recent-%02d",                                    i + 1);        gboolean             sensitive;        sensitive = gimp_plug_in_procedure_get_sensitive (proc, type);        gimp_action_group_set_action_sensitive (group, name, sensitive);        g_free (name);    }}

static gbooleangimp_text_layer_render (GimpTextLayer *layer){  GimpDrawable   *drawable;  GimpItem       *item;  GimpImage      *image;  GimpTextLayout *layout;  gdouble         xres;  gdouble         yres;  gint            width;  gint            height;  if (! layer->text)    return FALSE;  drawable = GIMP_DRAWABLE (layer);  item     = GIMP_ITEM (layer);  image    = gimp_item_get_image (item);  if (gimp_container_is_empty (image->gimp->fonts))    {      gimp_message_literal (image->gimp, NULL, GIMP_MESSAGE_ERROR,			    _("Due to lack of any fonts, "			      "text functionality is not available."));      return FALSE;    }  gimp_image_get_resolution (image, &xres, &yres);  layout = gimp_text_layout_new (layer->text, xres, yres);  g_object_freeze_notify (G_OBJECT (drawable));  if (gimp_text_layout_get_size (layout, &width, &height) &&      (width  != gimp_item_get_width  (item) ||       height != gimp_item_get_height (item)))    {      GeglBuffer *new_buffer;      new_buffer = gegl_buffer_new (GEGL_RECTANGLE (0, 0, width, height),                                    gimp_drawable_get_format (drawable));      gimp_drawable_set_buffer (drawable, FALSE, NULL, new_buffer);      g_object_unref (new_buffer);      if (gimp_layer_get_mask (GIMP_LAYER (layer)))        {          GimpLayerMask *mask = gimp_layer_get_mask (GIMP_LAYER (layer));          static GimpContext *unused_eek = NULL;          if (! unused_eek)            unused_eek = gimp_context_new (image->gimp, "eek", NULL);          gimp_item_resize (GIMP_ITEM (mask), unused_eek, width, height, 0, 0);        }    }  if (layer->auto_rename)    {      GimpItem *item = GIMP_ITEM (layer);      gchar    *name = NULL;      if (layer->text->text)        {          name = gimp_utf8_strtrim (layer->text->text, 30);        }      else if (layer->text->markup)        {          gchar *tmp = gimp_markup_extract_text (layer->text->markup);          name = gimp_utf8_strtrim (tmp, 30);          g_free (tmp);        }      if (! name)        name = g_strdup (_("Empty Text Layer"));      if (gimp_item_is_attached (item))        {          gimp_item_tree_rename_item (gimp_item_get_tree (item), item,                                      name, FALSE, NULL);          g_free (name);        }      else        {          gimp_object_take_name (GIMP_OBJECT (layer), name);        }    }  gimp_text_layer_render_layout (layer, layout);  g_object_unref (layout);  g_object_thaw_notify (G_OBJECT (drawable));  return (width > 0 && height > 0);}

voidregister_guides_procs (GimpPDB *pdb){  GimpProcedure *procedure;  /*   * gimp-image-add-hguide   */  procedure = gimp_procedure_new (image_add_hguide_invoker);  gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-image-add-hguide");  gimp_procedure_set_static_strings (procedure,                                     "gimp-image-add-hguide",                                     "Add a horizontal guide to an image.",                                     "This procedure adds a horizontal guide to an image. It takes the input image and the y-position of the new guide as parameters. It returns the guide ID of the new guide.",                                     "Adam D. Moss",                                     "Adam D. Moss",                                     "1998",                                     NULL);  gimp_procedure_add_argument (procedure,                               gimp_param_spec_image_id ("image",                                                         "image",                                                         "The image",                                                         pdb->gimp, FALSE,                                                         GIMP_PARAM_READWRITE));  gimp_procedure_add_argument (procedure,                               gimp_param_spec_int32 ("yposition",                                                      "yposition",                                                      "The guide's y-offset from top of image",                                                      0, G_MAXINT32, 0,                                                      GIMP_PARAM_READWRITE));  gimp_procedure_add_return_value (procedure,                                   g_param_spec_uint ("guide",                                                      "guide",                                                      "The new guide",                                                      1, G_MAXUINT32, 1,                                                      GIMP_PARAM_READWRITE));  gimp_pdb_register_procedure (pdb, procedure);  g_object_unref (procedure);  /*   * gimp-image-add-vguide   */  procedure = gimp_procedure_new (image_add_vguide_invoker);  gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-image-add-vguide");  gimp_procedure_set_static_strings (procedure,                                     "gimp-image-add-vguide",                                     "Add a vertical guide to an image.",                                     "This procedure adds a vertical guide to an image. It takes the input image and the x-position of the new guide as parameters. It returns the guide ID of the new guide.",                                     "Adam D. Moss",                                     "Adam D. Moss",                                     "1998",                                     NULL);  gimp_procedure_add_argument (procedure,                               gimp_param_spec_image_id ("image",                                                         "image",                                                         "The image",                                                         pdb->gimp, FALSE,                                                         GIMP_PARAM_READWRITE));  gimp_procedure_add_argument (procedure,                               gimp_param_spec_int32 ("xposition",                                                      "xposition",                                                      "The guide's x-offset from left of image",                                                      0, G_MAXINT32, 0,                                                      GIMP_PARAM_READWRITE));  gimp_procedure_add_return_value (procedure,                                   g_param_spec_uint ("guide",                                                      "guide",                                                      "The new guide",                                                      1, G_MAXUINT32, 1,                                                      GIMP_PARAM_READWRITE));  gimp_pdb_register_procedure (pdb, procedure);  g_object_unref (procedure);  /*   * gimp-image-delete-guide   */  procedure = gimp_procedure_new (image_delete_guide_invoker);  gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-image-delete-guide");  gimp_procedure_set_static_strings (procedure,                                     "gimp-image-delete-guide",                                     "Deletes a guide from an image.",                                     "This procedure takes an image and a guide ID as input and removes the specified guide from the specified image.",                                     "Adam D. Moss",                                     "Adam D. Moss",                                     "1998",                                     NULL);  gimp_procedure_add_argument (procedure,                               gimp_param_spec_image_id ("image",                                                         "image",                                                         "The image",                                                         pdb->gimp, FALSE,                                                         GIMP_PARAM_READWRITE));  gimp_procedure_add_argument (procedure,                               g_param_spec_uint ("guide",                                                  "guide",                                                  "The ID of the guide to be removed",                                                  1, G_MAXUINT32, 1,                                                  GIMP_PARAM_READWRITE));  gimp_pdb_register_procedure (pdb, procedure);  g_object_unref (procedure);//.........这里部分代码省略.........

//.........这里部分代码省略.........        case GIMP_PASTE_TYPE_NEW_LAYER:          layer_type = G_TYPE_FROM_INSTANCE (layer);          break;        default:          g_return_val_if_reached (NULL);        }      layer = GIMP_LAYER (gimp_item_convert (GIMP_ITEM (layer),                                             image, layer_type));      switch (paste_type)        {        case GIMP_PASTE_TYPE_FLOATING:        case GIMP_PASTE_TYPE_FLOATING_INTO:          /*  when pasting as floating selection, get rid of the layer mask,           *  and make sure the layer has the right format           */          if (gimp_layer_get_mask (layer))            gimp_layer_apply_mask (layer, GIMP_MASK_DISCARD, FALSE);          if (gimp_drawable_get_format (GIMP_DRAWABLE (layer)) !=              floating_format)            {              gimp_drawable_convert_type (GIMP_DRAWABLE (layer), image,                                          gimp_drawable_get_base_type (drawable),                                          gimp_drawable_get_precision (drawable),                                          TRUE,                                          NULL,                                          GEGL_DITHER_NONE, GEGL_DITHER_NONE,                                          FALSE, NULL);            }          break;        default:          break;        }    }  else if (GIMP_IS_BUFFER (paste))    {      layer = gimp_layer_new_from_buffer (GIMP_BUFFER (paste), image,                                          floating_format,                                          _("Pasted Layer"),                                          GIMP_OPACITY_OPAQUE, GIMP_NORMAL_MODE);    }  if (! layer)    return NULL;  gimp_edit_get_paste_offset (image, drawable, GIMP_OBJECT (layer),                              viewport_x,                              viewport_y,                              viewport_width,                              viewport_height,                              &offset_x,                              &offset_y);  gimp_item_set_offset (GIMP_ITEM (layer), offset_x, offset_y);  gimp_image_undo_group_start (image, GIMP_UNDO_GROUP_EDIT_PASTE,                               C_("undo-type", "Paste"));  switch (paste_type)    {    case GIMP_PASTE_TYPE_FLOATING:      /*  if there is a selection mask clear it - this might not       *  always be desired, but in general, it seems like the correct       *  behavior       */      if (! gimp_channel_is_empty (gimp_image_get_mask (image)))        gimp_channel_clear (gimp_image_get_mask (image), NULL, TRUE);      /* fall thru */    case GIMP_PASTE_TYPE_FLOATING_INTO:      floating_sel_attach (layer, drawable);      break;    case GIMP_PASTE_TYPE_NEW_LAYER:      {        GimpLayer *parent   = NULL;        gint       position = 0;        /* always add on top of the passed layer, where we would         * attach a floating selection         */        if (GIMP_IS_LAYER (drawable))          {            parent   = gimp_layer_get_parent (GIMP_LAYER (drawable));            position = gimp_item_get_index (GIMP_ITEM (drawable));          }        gimp_image_add_layer (image, layer, parent, position, TRUE);      }      break;    }  gimp_image_undo_group_end (image);  return layer;}

voidregister_plug_in_procs (GimpPDB *pdb){  GimpProcedure *procedure;  /*   * gimp-plugins-query   */  procedure = gimp_procedure_new (plugins_query_invoker);  gimp_object_set_static_name (GIMP_OBJECT (procedure),                               "gimp-plugins-query");  gimp_procedure_set_static_strings (procedure,                                     "gimp-plugins-query",                                     "Queries the plugin database for its contents.",                                     "This procedure queries the contents of the plugin database.",                                     "Andy Thomas",                                     "Andy Thomas",                                     "1998",                                     NULL);  gimp_procedure_add_argument (procedure,                               gimp_param_spec_string ("search-string",                                                       "search string",                                                       "If not an empty string then use this as a search pattern",                                                       FALSE, FALSE, FALSE,                                                       NULL,                                                       GIMP_PARAM_READWRITE | GIMP_PARAM_NO_VALIDATE));  gimp_procedure_add_return_value (procedure,                                   gimp_param_spec_int32 ("num-plugins",                                                          "num plugins",                                                          "The number of plugins",                                                          0, G_MAXINT32, 0,                                                          GIMP_PARAM_READWRITE));  gimp_procedure_add_return_value (procedure,                                   gimp_param_spec_string_array ("menu-path",                                                                 "menu path",                                                                 "The menu path of the plugin",                                                                 GIMP_PARAM_READWRITE));  gimp_procedure_add_return_value (procedure,                                   gimp_param_spec_int32 ("num-plugins",                                                          "num plugins",                                                          "The number of plugins",                                                          0, G_MAXINT32, 0,                                                          GIMP_PARAM_READWRITE));  gimp_procedure_add_return_value (procedure,                                   gimp_param_spec_string_array ("plugin-accelerator",                                                                 "plugin accelerator",                                                                 "String representing keyboard accelerator (could be empty string)",                                                                 GIMP_PARAM_READWRITE));  gimp_procedure_add_return_value (procedure,                                   gimp_param_spec_int32 ("num-plugins",                                                          "num plugins",                                                          "The number of plugins",                                                          0, G_MAXINT32, 0,                                                          GIMP_PARAM_READWRITE));  gimp_procedure_add_return_value (procedure,                                   gimp_param_spec_string_array ("plugin-location",                                                                 "plugin location",                                                                 "Location of the plugin program",                                                                 GIMP_PARAM_READWRITE));  gimp_procedure_add_return_value (procedure,                                   gimp_param_spec_int32 ("num-plugins",                                                          "num plugins",                                                          "The number of plugins",                                                          0, G_MAXINT32, 0,                                                          GIMP_PARAM_READWRITE));  gimp_procedure_add_return_value (procedure,                                   gimp_param_spec_string_array ("plugin-image-type",                                                                 "plugin image type",                                                                 "Type of image that this plugin will work on",                                                                 GIMP_PARAM_READWRITE));  gimp_procedure_add_return_value (procedure,                                   gimp_param_spec_int32 ("num-plugins",                                                          "num plugins",                                                          "The number of plugins",                                                          0, G_MAXINT32, 0,                                                          GIMP_PARAM_READWRITE));  gimp_procedure_add_return_value (procedure,                                   gimp_param_spec_int32_array ("plugin-install-time",                                                                "plugin install time",                                                                "Time that the plugin was installed",                                                                GIMP_PARAM_READWRITE));  gimp_procedure_add_return_value (procedure,                                   gimp_param_spec_int32 ("num-plugins",                                                          "num plugins",                                                          "The number of plugins",                                                          0, G_MAXINT32, 0,                                                          GIMP_PARAM_READWRITE));  gimp_procedure_add_return_value (procedure,                                   gimp_param_spec_string_array ("plugin-real-name",                                                                 "plugin real name",                                                                 "The internal name of the plugin",                                                                 GIMP_PARAM_READWRITE));  gimp_pdb_register_procedure (pdb, procedure);  g_object_unref (procedure);  /*   * gimp-plugin-domain-register   */  procedure = gimp_procedure_new (plugin_domain_register_invoker);  gimp_object_set_static_name (GIMP_OBJECT (procedure),//.........这里部分代码省略.........

voidregister_patterns_procs (GimpPDB *pdb){  GimpProcedure *procedure;  /*   * gimp-patterns-refresh   */  procedure = gimp_procedure_new (patterns_refresh_invoker);  gimp_object_set_static_name (GIMP_OBJECT (procedure),                               "gimp-patterns-refresh");  gimp_procedure_set_static_strings (procedure,                                     "gimp-patterns-refresh",                                     "Refresh current patterns. This function always succeeds.",                                     "This procedure retrieves all patterns currently in the user's pattern path and updates all pattern dialogs accordingly.",                                     "Michael Natterer <[email
C++ GIMP_OBJECT_CLASS函数代码示例
C++ GIMP_ITEM函数代码示例