gint
gimp_image_map_config_compare (GimpImageMapConfig *a,
GimpImageMapConfig *b)
{
const gchar *name_a = gimp_object_get_name (a);
const gchar *name_b = gimp_object_get_name (b);
if (a->time > 0 && b->time > 0)
{
return - strcmp (name_a, name_b);
}
else if (a->time > 0)
{
return -1;
}
else if (b->time > 0)
{
return 1;
}
else if (name_a && name_b)
{
return strcmp (name_a, name_b);
}
else if (name_a)
{
return 1;
}
else if (name_b)
{
return -1;
}
return 0;
}
static void
plug_in_actions_unregister_procedure (GimpPDB *pdb,
GimpProcedure *procedure,
GimpActionGroup *group)
{
if (GIMP_IS_PLUG_IN_PROCEDURE (procedure))
{
GimpPlugInProcedure *plug_in_proc = GIMP_PLUG_IN_PROCEDURE (procedure);
g_signal_handlers_disconnect_by_func (plug_in_proc,
plug_in_actions_menu_path_added,
group);
if (plug_in_proc->menu_label &&
! plug_in_proc->file_proc)
{
GtkAction *action;
#if 0
g_print ("%s: %s\n", G_STRFUNC,
gimp_object_get_name (procedure));
#endif
action = gtk_action_group_get_action (GTK_ACTION_GROUP (group),
gimp_object_get_name (procedure));
if (action)
gtk_action_group_remove_action (GTK_ACTION_GROUP (group), action);
}
}
}
gboolean
gimp_pdb_item_is_attached (GimpItem *item,
GimpImage *image,
GimpPDBItemModify modify,
GError **error)
{
g_return_val_if_fail (GIMP_IS_ITEM (item), FALSE);
g_return_val_if_fail (image == NULL || GIMP_IS_IMAGE (image), FALSE);
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
if (! gimp_item_is_attached (item))
{
g_set_error (error, GIMP_PDB_ERROR, GIMP_PDB_ERROR_INVALID_ARGUMENT,
_("Item '%s' (%d) cannot be used because it has not "
"been added to an image"),
gimp_object_get_name (item),
gimp_item_get_ID (item));
return FALSE;
}
if (image && image != gimp_item_get_image (item))
{
g_set_error (error, GIMP_PDB_ERROR, GIMP_PDB_ERROR_INVALID_ARGUMENT,
_("Item '%s' (%d) cannot be used because it is "
"attached to another image"),
gimp_object_get_name (item),
gimp_item_get_ID (item));
return FALSE;
}
return gimp_pdb_item_is_modifyable (item, modify, error);
}
gboolean
gimp_pdb_item_is_in_same_tree (GimpItem *item,
GimpItem *item2,
GimpImage *image,
GError **error)
{
g_return_val_if_fail (GIMP_IS_ITEM (item), FALSE);
g_return_val_if_fail (GIMP_IS_ITEM (item2), FALSE);
g_return_val_if_fail (image == NULL || GIMP_IS_IMAGE (image), FALSE);
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
if (! gimp_pdb_item_is_in_tree (item, image, FALSE, error) ||
! gimp_pdb_item_is_in_tree (item2, image, FALSE, error))
return FALSE;
if (gimp_item_get_tree (item) != gimp_item_get_tree (item2))
{
g_set_error (error, GIMP_PDB_ERROR, GIMP_PDB_ERROR_INVALID_ARGUMENT,
_("Items '%s' (%d) and '%s' (%d) cannot be used "
"because they are not part of the same item tree"),
gimp_object_get_name (item),
gimp_item_get_ID (item),
gimp_object_get_name (item2),
gimp_item_get_ID (item2));
return FALSE;
}
return TRUE;
}
static void
gimp_pdb_real_unregister_procedure (GimpPDB *pdb,
GimpProcedure *procedure)
{
const gchar *name;
GList *list;
name = gimp_object_get_name (procedure);
list = g_hash_table_lookup (pdb->procedures, name);
if (list)
{
list = g_list_remove (list, procedure);
if (list)
{
name = gimp_object_get_name (list->data);
g_hash_table_replace (pdb->procedures, (gpointer) name, list);
}
else
{
g_hash_table_remove (pdb->procedures, name);
}
g_object_unref (procedure);
}
}
gboolean
gimp_pdb_item_is_floating (GimpItem *item,
GimpImage *dest_image,
GError **error)
{
g_return_val_if_fail (GIMP_IS_ITEM (item), FALSE);
g_return_val_if_fail (GIMP_IS_IMAGE (dest_image), FALSE);
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
if (! g_object_is_floating (item))
{
g_set_error (error, GIMP_PDB_ERROR, GIMP_PDB_ERROR_INVALID_ARGUMENT,
_("Item '%s' (%d) has already been added to an image"),
gimp_object_get_name (item),
gimp_item_get_ID (item));
return FALSE;
}
else if (gimp_item_get_image (item) != dest_image)
{
g_set_error (error, GIMP_PDB_ERROR, GIMP_PDB_ERROR_INVALID_ARGUMENT,
_("Trying to add item '%s' (%d) to wrong image"),
gimp_object_get_name (item),
gimp_item_get_ID (item));
return FALSE;
}
return TRUE;
}
gboolean
gimp_pdb_item_is_modifyable (GimpItem *item,
GimpPDBItemModify modify,
GError **error)
{
g_return_val_if_fail (GIMP_IS_ITEM (item), FALSE);
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
if ((modify & GIMP_PDB_ITEM_CONTENT) && gimp_item_is_content_locked (item))
{
g_set_error (error, GIMP_PDB_ERROR, GIMP_PDB_ERROR_INVALID_ARGUMENT,
_("Item '%s' (%d) cannot be modified because its "
"contents are locked"),
gimp_object_get_name (item),
gimp_item_get_ID (item));
return FALSE;
}
if ((modify & GIMP_PDB_ITEM_POSITION) && gimp_item_is_position_locked (item))
{
g_set_error (error, GIMP_PDB_ERROR, GIMP_PDB_ERROR_INVALID_ARGUMENT,
_("Item '%s' (%d) cannot be modified because its "
"position and size are locked"),
gimp_object_get_name (item),
gimp_item_get_ID (item));
return FALSE;
}
return TRUE;
}
static void
plug_in_actions_add_proc (GimpActionGroup *group,
GimpPlugInProcedure *proc)
{
GimpProcedureActionEntry entry;
const gchar *locale_domain;
GList *list;
locale_domain = gimp_plug_in_procedure_get_locale_domain (proc);
entry.name = gimp_object_get_name (proc);
entry.icon_name = gimp_viewable_get_icon_name (GIMP_VIEWABLE (proc));
entry.label = gimp_procedure_get_menu_label (GIMP_PROCEDURE (proc));
entry.accelerator = NULL;
entry.tooltip = gimp_procedure_get_blurb (GIMP_PROCEDURE (proc));
entry.procedure = GIMP_PROCEDURE (proc);
entry.help_id = gimp_procedure_get_help_id (GIMP_PROCEDURE (proc));
gimp_action_group_add_procedure_actions (group, &entry, 1,
G_CALLBACK (plug_in_run_cmd_callback));
for (list = proc->menu_paths; list; list = g_list_next (list))
{
const gchar *original = list->data;
const gchar *translated = dgettext (locale_domain, original);
if (plug_in_actions_check_translation (original, translated))
plug_in_actions_build_path (group, original, translated);
else
plug_in_actions_build_path (group, original, original);
}
if (proc->image_types_val)
{
GimpContext *context = gimp_get_user_context (group->gimp);
GimpImage *image = gimp_context_get_image (context);
GimpDrawable *drawable = NULL;
gboolean sensitive;
const gchar *tooltip;
if (image)
drawable = gimp_image_get_active_drawable (image);
sensitive = gimp_procedure_get_sensitive (GIMP_PROCEDURE (proc),
GIMP_OBJECT (drawable),
&tooltip);
gimp_action_group_set_action_sensitive (group,
gimp_object_get_name (proc),
sensitive);
if (! sensitive && drawable && tooltip)
gimp_action_group_set_action_tooltip (group,
gimp_object_get_name (proc),
tooltip);
}
}
void
file_open_recent_cmd_callback (GtkAction *action,
gint value,
gpointer data)
{
Gimp *gimp;
GimpImagefile *imagefile;
gint num_entries;
return_if_no_gimp (gimp, data);
num_entries = gimp_container_get_n_children (gimp->documents);
if (value >= num_entries)
return;
imagefile = (GimpImagefile *)
gimp_container_get_child_by_index (gimp->documents, value);
if (imagefile)
{
GimpDisplay *display;
GimpProgress *progress;
GimpImage *image;
GimpPDBStatusType status;
GError *error = NULL;
return_if_no_display (display, data);
g_object_ref (display);
g_object_ref (imagefile);
progress = gimp_display_get_image (display) ?
NULL : GIMP_PROGRESS (display);
image = file_open_with_display (gimp, action_data_get_context (data),
progress,
gimp_object_get_name (imagefile), FALSE,
&status, &error);
if (! image && status != GIMP_PDB_CANCEL)
{
gchar *filename =
file_utils_uri_display_name (gimp_object_get_name (imagefile));
gimp_message (gimp, G_OBJECT (display), GIMP_MESSAGE_ERROR,
_("Opening '%s' failed:\n\n%s"),
filename, error->message);
g_clear_error (&error);
g_free (filename);
}
g_object_unref (imagefile);
g_object_unref (display);
}
}
GtkWidget *
data_delete_dialog_new (GimpDataFactory *factory,
GimpData *data,
GimpContext *context,
GtkWidget *parent)
{
DataDeleteDialog *delete_data;
GtkWidget *dialog;
g_return_val_if_fail (GIMP_IS_DATA_FACTORY (factory), NULL);
g_return_val_if_fail (GIMP_IS_DATA (data), NULL);
g_return_val_if_fail (context == NULL || GIMP_IS_CONTEXT (context), NULL);
g_return_val_if_fail (GTK_IS_WIDGET (parent), NULL);
delete_data = g_slice_new0 (DataDeleteDialog);
delete_data->factory = factory;
delete_data->data = data;
delete_data->context = context;
delete_data->parent = parent;
dialog = gimp_message_dialog_new (_("Delete Object"), GTK_STOCK_DELETE,
gtk_widget_get_toplevel (parent), 0,
gimp_standard_help_func, NULL,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_DELETE, GTK_RESPONSE_OK,
NULL);
gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog),
GTK_RESPONSE_OK,
GTK_RESPONSE_CANCEL,
-1);
g_signal_connect_object (data, "disconnect",
G_CALLBACK (gtk_widget_destroy),
dialog, G_CONNECT_SWAPPED);
g_signal_connect (dialog, "response",
G_CALLBACK (data_delete_dialog_response),
delete_data);
gimp_message_box_set_primary_text (GIMP_MESSAGE_DIALOG (dialog)->box,
_("Delete '%s'?"),
gimp_object_get_name (data));
gimp_message_box_set_text (GIMP_MESSAGE_DIALOG (dialog)->box,
_("Are you sure you want to remove '%s' "
"from the list and delete it on disk?"),
gimp_object_get_name (data));
return dialog;
}
static void
vectors_edit_attributes_callback (GtkWidget *dialog,
GimpImage *image,
GimpVectors *vectors,
GimpContext *context,
const gchar *vectors_name,
gboolean vectors_visible,
gboolean vectors_linked,
GimpColorTag vectors_color_tag,
gboolean vectors_lock_content,
gboolean vectors_lock_position,
gpointer user_data)
{
GimpItem *item = GIMP_ITEM (vectors);
if (strcmp (vectors_name, gimp_object_get_name (vectors)) ||
vectors_visible != gimp_item_get_visible (item) ||
vectors_linked != gimp_item_get_linked (item) ||
vectors_color_tag != gimp_item_get_color_tag (item) ||
vectors_lock_content != gimp_item_get_lock_content (item) ||
vectors_lock_position != gimp_item_get_lock_position (item))
{
gimp_image_undo_group_start (image,
GIMP_UNDO_GROUP_ITEM_PROPERTIES,
_("Path Attributes"));
if (strcmp (vectors_name, gimp_object_get_name (vectors)))
gimp_item_rename (GIMP_ITEM (vectors), vectors_name, NULL);
if (vectors_visible != gimp_item_get_visible (item))
gimp_item_set_visible (item, vectors_visible, TRUE);
if (vectors_linked != gimp_item_get_linked (item))
gimp_item_set_linked (item, vectors_linked, TRUE);
if (vectors_color_tag != gimp_item_get_color_tag (item))
gimp_item_set_color_tag (item, vectors_color_tag, TRUE);
if (vectors_lock_content != gimp_item_get_lock_content (item))
gimp_item_set_lock_content (item, vectors_lock_content, TRUE);
if (vectors_lock_position != gimp_item_get_lock_position (item))
gimp_item_set_lock_position (item, vectors_lock_position, TRUE);
gimp_image_undo_group_end (image);
gimp_image_flush (image);
}
gtk_widget_destroy (dialog);
}
gchar *
gimp_plug_in_procedure_get_help_id (const GimpPlugInProcedure *proc)
{
const gchar *domain;
g_return_val_if_fail (GIMP_IS_PLUG_IN_PROCEDURE (proc), NULL);
domain = gimp_plug_in_procedure_get_help_domain (proc);
if (domain)
return g_strconcat (domain, "?", gimp_object_get_name (proc), NULL);
return g_strdup (gimp_object_get_name (proc));
}
/* Converts items from one image to another */
static void
file_open_convert_items (GimpImage *dest_image,
const gchar *basename,
GList *items)
{
GList *list;
for (list = items; list; list = g_list_next (list))
{
GimpItem *src = list->data;
GimpItem *item;
item = gimp_item_convert (src, dest_image, G_TYPE_FROM_INSTANCE (src));
if (g_list_length (items) == 1)
{
gimp_object_set_name (GIMP_OBJECT (item), basename);
}
else
{
gimp_object_set_name (GIMP_OBJECT (item),
gimp_object_get_name (src));
}
list->data = item;
}
}
gboolean
gimp_pdb_item_is_in_tree (GimpItem *item,
GimpImage *image,
GimpPDBItemModify modify,
GError **error)
{
g_return_val_if_fail (GIMP_IS_ITEM (item), FALSE);
g_return_val_if_fail (image == NULL || GIMP_IS_IMAGE (image), FALSE);
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
if (! gimp_pdb_item_is_attached (item, image, modify, error))
return FALSE;
if (! gimp_item_get_tree (item))
{
g_set_error (error, GIMP_PDB_ERROR, GIMP_PDB_ERROR_INVALID_ARGUMENT,
_("Item '%s' (%d) cannot be used because it is not "
"a direct child of an item tree"),
gimp_object_get_name (item),
gimp_item_get_ID (item));
return FALSE;
}
return TRUE;
}
static GList *
gimp_data_editor_get_aux_info (GimpDocked *docked)
{
GimpDataEditor *editor = GIMP_DATA_EDITOR (docked);
GList *aux_info;
GimpSessionInfoAux *aux;
aux_info = parent_docked_iface->get_aux_info (docked);
aux = gimp_session_info_aux_new (AUX_INFO_EDIT_ACTIVE,
editor->edit_active ? "true" : "false");
aux_info = g_list_append (aux_info, aux);
if (editor->data)
{
const gchar *value;
value = gimp_object_get_name (editor->data);
aux = gimp_session_info_aux_new (AUX_INFO_CURRENT_DATA, value);
aux_info = g_list_append (aux_info, aux);
}
return aux_info;
}
static void
gimp_data_editor_data_name_changed (GimpObject *object,
GimpDataEditor *editor)
{
gtk_entry_set_text (GTK_ENTRY (editor->name_entry),
gimp_object_get_name (object));
}
GimpValueArray *
procedure_commands_get_data_args (GimpProcedure *procedure,
GimpObject *object)
{
GimpValueArray *args;
gint n_args = 0;
args = gimp_procedure_get_arguments (procedure);
/* initialize the first argument */
g_value_set_int (gimp_value_array_index (args, n_args),
GIMP_RUN_INTERACTIVE);
n_args++;
if (gimp_value_array_length (args) > n_args &&
GIMP_IS_PARAM_SPEC_STRING (procedure->args[n_args]))
{
if (object)
{
g_value_set_string (gimp_value_array_index (args, n_args),
gimp_object_get_name (object));
n_args++;
}
else
{
g_warning ("Uh-oh, no active data object for the plug-in!");
gimp_value_array_unref (args);
return NULL;
}
}
gimp_value_array_truncate (args, n_args);
return args;
}
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;
/* 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);
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))
{
GimpToolOptions *src;
GimpToolOptions *dest;
GimpContextPropMask prop_mask = 0;
src = preset->tool_options;
dest = tool_manager->active_tool->tool_info->tool_options;
/* copy various data objects' additional tool options again
* manually, they might have been overwritten by e.g. the "link
* brush stuff to brush defaults" logic in gimptooloptions.c
*/
if (preset->use_brush)
prop_mask |= GIMP_CONTEXT_PROP_MASK_BRUSH;
if (preset->use_dynamics)
prop_mask |= GIMP_CONTEXT_PROP_MASK_DYNAMICS;
if (preset->use_gradient)
prop_mask |= GIMP_CONTEXT_PROP_MASK_GRADIENT;
gimp_paint_options_copy_props (GIMP_PAINT_OPTIONS (src),
GIMP_PAINT_OPTIONS (dest),
prop_mask);
}
}
const gchar *
gimp_edit_named_cut (GimpImage *image,
const gchar *name,
GimpDrawable *drawable,
GimpContext *context,
GError **error)
{
GimpBuffer *buffer;
g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
g_return_val_if_fail (name != NULL, NULL);
g_return_val_if_fail (GIMP_IS_DRAWABLE (drawable), NULL);
g_return_val_if_fail (gimp_item_is_attached (GIMP_ITEM (drawable)), NULL);
g_return_val_if_fail (GIMP_IS_CONTEXT (context), NULL);
g_return_val_if_fail (error == NULL || *error == NULL, NULL);
buffer = gimp_edit_extract (image, GIMP_PICKABLE (drawable),
context, TRUE, error);
if (buffer)
{
gimp_object_set_name (GIMP_OBJECT (buffer), name);
gimp_container_add (image->gimp->named_buffers, GIMP_OBJECT (buffer));
g_object_unref (buffer);
return gimp_object_get_name (buffer);
}
return NULL;
}
gboolean
file_procedure_in_group (GimpPlugInProcedure *file_proc,
FileProcedureGroup group)
{
const gchar *name = gimp_object_get_name (file_proc);
gboolean is_xcf_save = FALSE;
gboolean is_filter = FALSE;
is_xcf_save = (strcmp (name, "gimp-xcf-save") == 0);
is_filter = (strcmp (name, "file-gz-save") == 0 ||
strcmp (name, "file-bz2-save") == 0 ||
strcmp (name, "file-xz-save") == 0);
switch (group)
{
case FILE_PROCEDURE_GROUP_SAVE:
/* Only .xcf shall pass */
/* FIXME: Handle .gz and .bz2 properly */
return is_xcf_save || is_filter;
case FILE_PROCEDURE_GROUP_EXPORT:
/* Anything but .xcf shall pass */
/* FIXME: Handle .gz, .bz2 and .xz properly */
return ! is_xcf_save || is_filter;
case FILE_PROCEDURE_GROUP_OPEN:
/* No filter applied for Open */
return TRUE;
default:
case FILE_PROCEDURE_GROUP_ANY:
return TRUE;
}
}
static void
plug_in_actions_register_procedure (GimpPDB *pdb,
GimpProcedure *procedure,
GimpActionGroup *group)
{
if (GIMP_IS_PLUG_IN_PROCEDURE (procedure))
{
GimpPlugInProcedure *plug_in_proc = GIMP_PLUG_IN_PROCEDURE (procedure);
g_signal_connect_object (plug_in_proc, "menu-path-added",
G_CALLBACK (plug_in_actions_menu_path_added),
group, 0);
if ((plug_in_proc->menu_label || plug_in_proc->menu_paths) &&
! plug_in_proc->file_proc)
{
#if 0
g_print ("%s: %s\n", G_STRFUNC,
gimp_object_get_name (GIMP_OBJECT (procedure)));
#endif
plug_in_actions_add_proc (group, plug_in_proc);
}
}
}
GimpLayer *
gimp_image_merge_group_layer (GimpImage *image,
GimpGroupLayer *group)
{
GimpLayer *parent;
GimpLayer *layer;
gint index;
g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
g_return_val_if_fail (GIMP_IS_GROUP_LAYER (group), NULL);
g_return_val_if_fail (gimp_item_is_attached (GIMP_ITEM (group)), NULL);
g_return_val_if_fail (gimp_item_get_image (GIMP_ITEM (group)) == image, NULL);
gimp_image_undo_group_start (image, GIMP_UNDO_GROUP_IMAGE_LAYERS_MERGE,
C_("undo-type", "Merge Layer Group"));
parent = gimp_layer_get_parent (GIMP_LAYER (group));
index = gimp_item_get_index (GIMP_ITEM (group));
layer = GIMP_LAYER (gimp_item_duplicate (GIMP_ITEM (group),
GIMP_TYPE_LAYER));
gimp_object_set_name (GIMP_OBJECT (layer), gimp_object_get_name (group));
gimp_image_remove_layer (image, GIMP_LAYER (group), TRUE, NULL);
gimp_image_add_layer (image, layer, parent, index, TRUE);
gimp_image_undo_group_end (image);
return layer;
}
void
layers_edit_attributes_cmd_callback (GtkAction *action,
gpointer data)
{
LayerOptionsDialog *dialog;
GimpImage *image;
GimpLayer *layer;
GtkWidget *widget;
return_if_no_layer (image, layer, data);
return_if_no_widget (widget, data);
dialog = layer_options_dialog_new (gimp_item_get_image (GIMP_ITEM (layer)),
layer,
action_data_get_context (data),
widget,
gimp_object_get_name (layer),
layer_fill_type,
_("Layer Attributes"),
"gimp-layer-edit",
GTK_STOCK_EDIT,
_("Edit Layer Attributes"),
GIMP_HELP_LAYER_EDIT);
g_signal_connect (dialog->dialog, "response",
G_CALLBACK (layers_edit_layer_response),
dialog);
gtk_widget_show (dialog->dialog);
}
static GimpValueArray *
palettes_get_palette_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
const GimpValueArray *args,
GError **error)
{
gboolean success = TRUE;
GimpValueArray *return_vals;
gchar *name = NULL;
gint32 num_colors = 0;
GimpPalette *palette = gimp_context_get_palette (context);
if (palette)
{
name = g_strdup (gimp_object_get_name (palette));
num_colors = gimp_palette_get_n_colors (palette);
}
else
success = FALSE;
return_vals = gimp_procedure_get_return_values (procedure, success,
error ? *error : NULL);
if (success)
{
g_value_take_string (gimp_value_array_index (return_vals, 1), name);
g_value_set_int (gimp_value_array_index (return_vals, 2), num_colors);
}
return return_vals;
}
const gchar *
gimp_edit_named_copy_visible (GimpImage *image,
const gchar *name,
GimpContext *context,
GError **error)
{
GimpBuffer *buffer;
g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
g_return_val_if_fail (name != NULL, NULL);
g_return_val_if_fail (GIMP_IS_CONTEXT (context), NULL);
g_return_val_if_fail (error == NULL || *error == NULL, NULL);
buffer = gimp_edit_extract (image, GIMP_PICKABLE (image),
context, FALSE, error);
if (buffer)
{
gimp_object_set_name (GIMP_OBJECT (buffer), name);
gimp_container_add (image->gimp->named_buffers, GIMP_OBJECT (buffer));
g_object_unref (buffer);
return gimp_object_get_name (buffer);
}
return NULL;
}
void
channels_edit_attributes_cmd_callback (GtkAction *action,
gpointer data)
{
ChannelOptionsDialog *options;
GimpImage *image;
GimpChannel *channel;
GtkWidget *widget;
return_if_no_channel (image, channel, data);
return_if_no_widget (widget, data);
options = channel_options_dialog_new (image, channel,
action_data_get_context (data),
widget,
&channel->color,
gimp_object_get_name (channel),
_("Channel Attributes"),
"gimp-channel-edit",
GTK_STOCK_EDIT,
_("Edit Channel Attributes"),
GIMP_HELP_CHANNEL_EDIT,
_("Edit Channel Color"),
_("_Fill opacity:"),
FALSE);
g_signal_connect (options->dialog, "response",
G_CALLBACK (channels_edit_channel_response),
options);
gtk_widget_show (options->dialog);
}
void
gimp_plug_in_def_add_procedure (GimpPlugInDef *plug_in_def,
GimpPlugInProcedure *proc)
{
GimpPlugInProcedure *overridden;
g_return_if_fail (GIMP_IS_PLUG_IN_DEF (plug_in_def));
g_return_if_fail (GIMP_IS_PLUG_IN_PROCEDURE (proc));
overridden = gimp_plug_in_procedure_find (plug_in_def->procedures,
gimp_object_get_name (proc));
if (overridden)
gimp_plug_in_def_remove_procedure (plug_in_def, overridden);
proc->mtime = plug_in_def->mtime;
gimp_plug_in_procedure_set_locale_domain (proc,
plug_in_def->locale_domain_name);
gimp_plug_in_procedure_set_help_domain (proc,
plug_in_def->help_domain_name);
plug_in_def->procedures = g_slist_append (plug_in_def->procedures,
g_object_ref (proc));
}
static void
plug_in_menus_register_procedure (GimpPDB *pdb,
GimpProcedure *procedure,
GimpUIManager *manager)
{
if (GIMP_IS_PLUG_IN_PROCEDURE (procedure))
{
GimpPlugInProcedure *plug_in_proc = GIMP_PLUG_IN_PROCEDURE (procedure);
g_signal_connect_object (plug_in_proc, "menu-path-added",
G_CALLBACK (plug_in_menus_menu_path_added),
manager, 0);
if ((plug_in_proc->menu_label || plug_in_proc->menu_paths) &&
! plug_in_proc->file_proc)
{
GList *list;
GIMP_LOG (MENUS, "register procedure: %s",
gimp_object_get_name (procedure));
for (list = plug_in_proc->menu_paths; list; list = g_list_next (list))
plug_in_menus_menu_path_added (plug_in_proc, list->data, manager);
}
}
}
void
gimp_plug_in_add_temp_proc (GimpPlugIn *plug_in,
GimpTemporaryProcedure *proc)
{
GimpPlugInProcedure *overridden;
const gchar *locale_domain;
const gchar *help_domain;
g_return_if_fail (GIMP_IS_PLUG_IN (plug_in));
g_return_if_fail (GIMP_IS_TEMPORARY_PROCEDURE (proc));
overridden = gimp_plug_in_procedure_find (plug_in->temp_procedures,
gimp_object_get_name (proc));
if (overridden)
gimp_plug_in_remove_temp_proc (plug_in,
GIMP_TEMPORARY_PROCEDURE (overridden));
locale_domain = gimp_plug_in_manager_get_locale_domain (plug_in->manager,
plug_in->prog,
NULL);
help_domain = gimp_plug_in_manager_get_help_domain (plug_in->manager,
plug_in->prog,
NULL);
gimp_plug_in_procedure_set_locale_domain (GIMP_PLUG_IN_PROCEDURE (proc),
locale_domain);
gimp_plug_in_procedure_set_help_domain (GIMP_PLUG_IN_PROCEDURE (proc),
help_domain);
plug_in->temp_procedures = g_slist_prepend (plug_in->temp_procedures,
g_object_ref (proc));
gimp_plug_in_manager_add_temp_proc (plug_in->manager, proc);
}
static void
gimp_controller_list_select_item (GimpContainerView *view,
GimpViewable *viewable,
gpointer insert_data,
GimpControllerList *list)
{
gboolean selected;
list->dest_info = GIMP_CONTROLLER_INFO (viewable);
selected = GIMP_IS_CONTROLLER_INFO (list->dest_info);
if (list->remove_button)
{
GimpObject *object = GIMP_OBJECT (list->dest_info);
gchar *tip = NULL;
gtk_widget_set_sensitive (list->remove_button, selected);
if (selected)
tip =
g_strdup_printf (_("Remove '%s' from the list of active controllers"),
gimp_object_get_name (object));
gimp_help_set_help_data (list->remove_button, tip, NULL);
g_free (tip);
}
gtk_widget_set_sensitive (list->edit_button, selected);
gtk_widget_set_sensitive (list->up_button, selected);
gtk_widget_set_sensitive (list->down_button, selected);
}
