本文整理汇总了C++中GIMP_OBJECT函数的典型用法代码示例。如果您正苦于以下问题：C++ GIMP_OBJECT函数的具体用法？C++ GIMP_OBJECT怎么用？C++ GIMP_OBJECT使用的例子？那么恭喜您, 这里精选的函数代码示例或许可以为您提供帮助。
在下文中一共展示了GIMP_OBJECT函数的15个代码示例，这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞，您的评价将有助于系统推荐出更棒的C++代码示例。
示例1: register_message_procs
void
register_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);
}示例2: plug_in_actions_history_changed
static void
plug_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);
}
}示例3: gimp_tools_register
//.........这里部分代码省略.........
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);
}示例4: gimp_image_merge_visible_vectors
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;
}
}示例5: plug_in_actions_update
void
plug_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);
}
}示例6: gimp_text_layer_render
static gboolean
gimp_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);
}示例7: register_guides_procs
void
register_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);
//.........这里部分代码省略.........
示例8: gimp_edit_paste
//.........这里部分代码省略.........
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;
}示例9: register_plug_in_procs
void
register_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),
//.........这里部分代码省略.........
示例10: register_patterns_procs
void
register_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 protected]>",
"Michael Natterer",
"2002",
NULL);
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-patterns-get-list
*/
procedure = gimp_procedure_new (patterns_get_list_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-patterns-get-list");
gimp_procedure_set_static_strings (procedure,
"gimp-patterns-get-list",
"Retrieve a complete listing of the available patterns.",
"This procedure returns a complete listing of available GIMP patterns. Each name returned can be used as input to the 'gimp-context-set-pattern'.",
"Spencer Kimball & Peter Mattis",
"Spencer Kimball & Peter Mattis",
"1995-1996",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("filter",
"filter",
"An optional regular expression used to filter the list",
FALSE, TRUE, FALSE,
NULL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("num-patterns",
"num patterns",
"The number of patterns in the pattern list",
0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_string_array ("pattern-list",
"pattern list",
"The list of pattern names",
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-patterns-get-pattern
*/
procedure = gimp_procedure_new (patterns_get_pattern_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-patterns-get-pattern");
gimp_procedure_set_static_strings (procedure,
"gimp-patterns-get-pattern",
"Deprecated: Use 'gimp-context-get-pattern' instead.",
"Deprecated: Use 'gimp-context-get-pattern' instead.",
"",
"",
"",
"gimp-context-get-pattern");
gimp_procedure_add_return_value (procedure,
gimp_param_spec_string ("name",
"name",
"The pattern name",
FALSE, FALSE, FALSE,
NULL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("width",
"width",
"The pattern width",
G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("height",
"height",
"The pattern height",
G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-patterns-get-pattern-data
*/
procedure = gimp_procedure_new (patterns_get_pattern_data_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-patterns-get-pattern-data");
gimp_procedure_set_static_strings (procedure,
//.........这里部分代码省略.........
示例11: gimp_device_info_set_device
void
gimp_device_info_set_device (GimpDeviceInfo *info,
GdkDevice *device,
GdkDisplay *display)
{
gint i;
g_return_if_fail (GIMP_IS_DEVICE_INFO (info));
g_return_if_fail ((device == NULL && display == NULL) ||
(GDK_IS_DEVICE (device) && GDK_IS_DISPLAY (display)));
g_return_if_fail ((info->device == NULL && GDK_IS_DEVICE (device)) ||
(GDK_IS_DEVICE (info->device) && device == NULL));
g_return_if_fail (device == NULL ||
strcmp (device->name,
gimp_object_get_name (info)) == 0);
if (device)
{
info->device = device;
info->display = display;
g_object_set_data (G_OBJECT (device), GIMP_DEVICE_INFO_DATA_KEY, info);
gimp_device_info_set_mode (info, info->mode);
if (info->n_axes != device->num_axes)
g_printerr ("%s: stored 'num-axes' for device '%s' doesn't match "
"number of axes present in device\n",
G_STRFUNC, device->name);
for (i = 0; i < MIN (info->n_axes, device->num_axes); i++)
gimp_device_info_set_axis_use (info, i,
info->axes[i]);
if (info->n_keys != device->num_keys)
g_printerr ("%s: stored 'num-keys' for device '%s' doesn't match "
"number of keys present in device\n",
G_STRFUNC, device->name);
for (i = 0; i < MIN (info->n_keys, device->num_keys); i++)
gimp_device_info_set_key (info, i,
info->keys[i].keyval,
info->keys[i].modifiers);
}
else
{
device = info->device;
display = info->display;
info->device = NULL;
info->display = NULL;
g_object_set_data (G_OBJECT (device), GIMP_DEVICE_INFO_DATA_KEY, NULL);
gimp_device_info_set_mode (info, device->mode);
info->n_axes = device->num_axes;
info->axes = g_renew (GdkAxisUse, info->axes, info->n_axes);
memset (info->axes, 0, info->n_axes * sizeof (GdkAxisUse));
for (i = 0; i < device->num_axes; i++)
gimp_device_info_set_axis_use (info, i,
device->axes[i].use);
info->n_keys = device->num_keys;
info->keys = g_renew (GdkDeviceKey, info->keys, info->n_keys);
memset (info->keys, 0, info->n_keys * sizeof (GdkDeviceKey));
for (i = 0; i < MIN (info->n_keys, device->num_keys); i++)
gimp_device_info_set_key (info, i,
device->keys[i].keyval,
device->keys[i].modifiers);
}
/* sort order depends on device presence */
gimp_object_name_changed (GIMP_OBJECT (info));
g_object_notify (G_OBJECT (info), "device");
gimp_device_info_changed (info);
}示例12: register_palettes_procs
void
register_palettes_procs (GimpPDB *pdb)
{
GimpProcedure *procedure;
/*
* gimp-palettes-refresh
*/
procedure = gimp_procedure_new (palettes_refresh_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-palettes-refresh");
gimp_procedure_set_static_strings (procedure,
"gimp-palettes-refresh",
"Refreshes current palettes. This function always succeeds.",
"This procedure retrieves all palettes currently in the user's palette path and updates the palette dialogs accordingly.",
"Adrian Likins <[email protected]>",
"Adrian Likins",
"1998",
NULL);
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-palettes-get-list
*/
procedure = gimp_procedure_new (palettes_get_list_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-palettes-get-list");
gimp_procedure_set_static_strings (procedure,
"gimp-palettes-get-list",
"Retrieves a list of all of the available palettes",
"This procedure returns a complete listing of available palettes. Each name returned can be used as input to the command 'gimp-context-set-palette'.",
"Nathan Summers <[email protected]>",
"Nathan Summers",
"2001",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("filter",
"filter",
"An optional regular expression used to filter the list",
FALSE, TRUE, FALSE,
NULL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("num-palettes",
"num palettes",
"The number of palettes in the list",
0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_string_array ("palette-list",
"palette list",
"The list of palette names",
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-palettes-get-palette
*/
procedure = gimp_procedure_new (palettes_get_palette_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-palettes-get-palette");
gimp_procedure_set_static_strings (procedure,
"gimp-palettes-get-palette",
"Deprecated: Use 'gimp-context-get-palette' instead.",
"Deprecated: Use 'gimp-context-get-palette' instead.",
"",
"",
"",
"gimp-context-get-palette");
gimp_procedure_add_return_value (procedure,
gimp_param_spec_string ("name",
"name",
"The palette name",
FALSE, TRUE, FALSE,
NULL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("num-colors",
"num colors",
"The palette num_colors",
G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-palettes-get-palette-entry
*/
procedure = gimp_procedure_new (palettes_get_palette_entry_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-palettes-get-palette-entry");
gimp_procedure_set_static_strings (procedure,
"gimp-palettes-get-palette-entry",
"Deprecated: Use 'gimp-palette-entry-get-color' instead.",
"Deprecated: Use 'gimp-palette-entry-get-color' instead.",
"",
"",
"",
//.........这里部分代码省略.........
示例13: register_floating_sel_procs
void
register_floating_sel_procs (GimpPDB *pdb)
{
GimpProcedure *procedure;
/*
* gimp-floating-sel-remove
*/
procedure = gimp_procedure_new (floating_sel_remove_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-floating-sel-remove");
gimp_procedure_set_static_strings (procedure,
"gimp-floating-sel-remove",
"Remove the specified floating selection from its associated drawable.",
"This procedure removes the floating selection completely, without any side effects. The associated drawable is then set to active.",
"Spencer Kimball & Peter Mattis",
"Spencer Kimball & Peter Mattis",
"1995-1996",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_layer_id ("floating-sel",
"floating sel",
"The floating selection",
pdb->gimp, FALSE,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-floating-sel-anchor
*/
procedure = gimp_procedure_new (floating_sel_anchor_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-floating-sel-anchor");
gimp_procedure_set_static_strings (procedure,
"gimp-floating-sel-anchor",
"Anchor the specified floating selection to its associated drawable.",
"This procedure anchors the floating selection to its associated drawable. This is similar to merging with a merge type of ClipToBottomLayer. The floating selection layer is no longer valid after this operation.",
"Spencer Kimball & Peter Mattis",
"Spencer Kimball & Peter Mattis",
"1995-1996",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_layer_id ("floating-sel",
"floating sel",
"The floating selection",
pdb->gimp, FALSE,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-floating-sel-to-layer
*/
procedure = gimp_procedure_new (floating_sel_to_layer_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-floating-sel-to-layer");
gimp_procedure_set_static_strings (procedure,
"gimp-floating-sel-to-layer",
"Transforms the specified floating selection into a layer.",
"This procedure transforms the specified floating selection into a layer with the same offsets and extents. The composited image will look precisely the same, but the floating selection layer will no longer be clipped to the extents of the drawable it was attached to. The floating selection will become the active layer. This procedure will not work if the floating selection has a different base type from the underlying image. This might be the case if the floating selection is above an auxillary channel or a layer mask.",
"Spencer Kimball & Peter Mattis",
"Spencer Kimball & Peter Mattis",
"1995-1996",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_layer_id ("floating-sel",
"floating sel",
"The floating selection",
pdb->gimp, FALSE,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-floating-sel-attach
*/
procedure = gimp_procedure_new (floating_sel_attach_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-floating-sel-attach");
gimp_procedure_set_static_strings (procedure,
"gimp-floating-sel-attach",
"Attach the specified layer as floating to the specified drawable.",
"This procedure attaches the layer as floating selection to the drawable.",
"Spencer Kimball & Peter Mattis",
"Spencer Kimball & Peter Mattis",
"1995-1996",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_layer_id ("layer",
"layer",
"The layer (is attached as floating selection)",
pdb->gimp, FALSE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_drawable_id ("drawable",
"drawable",
"The drawable (where to attach the floating selection)",
pdb->gimp, FALSE,
GIMP_PARAM_READWRITE));
//.........这里部分代码省略.........
示例14: register_channel_procs
void
register_channel_procs (GimpPDB *pdb)
{
GimpProcedure *procedure;
/*
* gimp-channel-new
*/
procedure = gimp_procedure_new (channel_new_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-channel-new");
gimp_procedure_set_static_strings (procedure,
"gimp-channel-new",
"Create a new channel.",
"This procedure creates a new channel with the specified width and height. Name, opacity, and color are also supplied parameters. The new channel still needs to be added to the image, as this is not automatic. Add the new channel with the 'gimp-image-add-channel' command. Other attributes such as channel show masked, should be set with explicit procedure calls. The channel's contents are undefined initially.",
"Spencer Kimball & Peter Mattis",
"Spencer Kimball & Peter Mattis",
"1995-1996",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_image_id ("image",
"image",
"The image to which to add the channel",
pdb->gimp, FALSE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("width",
"width",
"The channel width",
1, GIMP_MAX_IMAGE_SIZE, 1,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("height",
"height",
"The channel height",
1, GIMP_MAX_IMAGE_SIZE, 1,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("name",
"name",
"The channel name",
FALSE, FALSE, FALSE,
NULL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_double ("opacity",
"opacity",
"The channel opacity",
0, 100, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_rgb ("color",
"color",
"The channel compositing color",
FALSE,
NULL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_channel_id ("channel",
"channel",
"The newly created channel",
pdb->gimp, FALSE,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-channel-new-from-component
*/
procedure = gimp_procedure_new (channel_new_from_component_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-channel-new-from-component");
gimp_procedure_set_static_strings (procedure,
"gimp-channel-new-from-component",
"Create a new channel from a color component",
"This procedure creates a new channel from a color component.",
"Shlomi Fish <[email protected]>",
"Shlomi Fish",
"2005",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_image_id ("image",
"image",
"The image to which to add the channel",
pdb->gimp, FALSE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_enum ("component",
"component",
"The image component",
GIMP_TYPE_CHANNEL_TYPE,
GIMP_RED_CHANNEL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("name",
"name",
"The channel name",
FALSE, FALSE, FALSE,
NULL,
GIMP_PARAM_READWRITE));
//.........这里部分代码省略.........
示例15: tool_manager_preset_changed
static void
tool_manager_preset_changed (GimpContext *user_context,
GimpToolPreset *preset,
GimpToolManager *tool_manager)
{
GimpToolInfo *preset_tool;
gchar *options_name;
gboolean tool_change = FALSE;
if (! preset || user_context->gimp->busy)
return;
preset_tool = gimp_context_get_tool (GIMP_CONTEXT (preset->tool_options));
if (preset_tool != gimp_context_get_tool (user_context))
tool_change = TRUE;
if (! tool_change)
tool_manager_disconnect_options (tool_manager, user_context, preset_tool);
/* save the name, we don't want to overwrite it */
options_name = g_strdup (gimp_object_get_name (preset_tool->tool_options));
gimp_config_copy (GIMP_CONFIG (preset->tool_options),
GIMP_CONFIG (preset_tool->tool_options), 0);
/* restore the saved name */
gimp_object_take_name (GIMP_OBJECT (preset_tool->tool_options), options_name);
if (tool_change)
gimp_context_set_tool (user_context, preset_tool);
else
tool_manager_connect_options (tool_manager, user_context, preset_tool);
gimp_context_copy_properties (GIMP_CONTEXT (preset->tool_options),
user_context,
gimp_tool_preset_get_prop_mask (preset));
if (GIMP_IS_PAINT_OPTIONS (preset->tool_options))
{
GimpCoreConfig *config = user_context->gimp->config;
GimpToolOptions *src = preset->tool_options;
GimpToolOptions *dest = tool_manager->active_tool->tool_info->tool_options;
/* if connect_options() did overwrite the brush options and the
* preset contains a brush, use the brush options from the
* preset
*/
if (config->global_brush && preset->use_brush)
gimp_paint_options_copy_brush_props (GIMP_PAINT_OPTIONS (src),
GIMP_PAINT_OPTIONS (dest));
if (config->global_dynamics && preset->use_dynamics)
gimp_paint_options_copy_dynamics_props (GIMP_PAINT_OPTIONS (src),
GIMP_PAINT_OPTIONS (dest));
if (config->global_gradient && preset->use_gradient)
gimp_paint_options_copy_gradient_props (GIMP_PAINT_OPTIONS (src),
GIMP_PAINT_OPTIONS (dest));
}
}