void
dialogs_init (Gimp *gimp,
GimpMenuFactory *menu_factory)
{
gint i;
g_return_if_fail (GIMP_IS_GIMP (gimp));
g_return_if_fail (GIMP_IS_MENU_FACTORY (menu_factory));
global_dialog_factory = gimp_dialog_factory_new ("toplevel",
gimp_get_user_context (gimp),
menu_factory,
NULL);
global_toolbox_factory = gimp_dialog_factory_new ("toolbox",
gimp_get_user_context (gimp),
menu_factory,
dialogs_toolbox_get);
gimp_dialog_factory_set_constructor (global_toolbox_factory,
dialogs_dockable_constructor);
global_dock_factory = gimp_dialog_factory_new ("dock",
gimp_get_user_context (gimp),
menu_factory,
dialogs_dock_new);
gimp_dialog_factory_set_constructor (global_dock_factory,
dialogs_dockable_constructor);
for (i = 0; i < G_N_ELEMENTS (toplevel_entries); i++)
gimp_dialog_factory_register_entry (global_dialog_factory,
toplevel_entries[i].identifier,
gettext (toplevel_entries[i].name),
gettext (toplevel_entries[i].blurb),
toplevel_entries[i].stock_id,
toplevel_entries[i].help_id,
toplevel_entries[i].new_func,
toplevel_entries[i].view_size,
toplevel_entries[i].singleton,
toplevel_entries[i].session_managed,
toplevel_entries[i].remember_size,
toplevel_entries[i].remember_if_open);
for (i = 0; i < G_N_ELEMENTS (dock_entries); i++)
gimp_dialog_factory_register_entry (global_dock_factory,
dock_entries[i].identifier,
gettext (dock_entries[i].name),
gettext (dock_entries[i].blurb),
dock_entries[i].stock_id,
dock_entries[i].help_id,
dock_entries[i].new_func,
dock_entries[i].view_size,
dock_entries[i].singleton,
dock_entries[i].session_managed,
dock_entries[i].remember_size,
dock_entries[i].remember_if_open);
}
/* This function is called for filenames passed on the command-line
* or from the D-Bus service.
*/
gboolean
file_open_from_command_line (Gimp *gimp,
GFile *file,
gboolean as_new,
GObject *screen,
gint monitor)
{
GimpImage *image;
GimpObject *display;
GimpPDBStatusType status;
gboolean success = FALSE;
GError *error = NULL;
g_return_val_if_fail (GIMP_IS_GIMP (gimp), FALSE);
g_return_val_if_fail (G_IS_FILE (file), FALSE);
g_return_val_if_fail (screen == NULL || G_IS_OBJECT (screen), FALSE);
display = gimp_get_empty_display (gimp);
/* show the progress in the last opened display, see bug #704896 */
if (! display)
display = gimp_context_get_display (gimp_get_user_context (gimp));
if (display)
g_object_add_weak_pointer (G_OBJECT (display), (gpointer) &display);
image = file_open_with_display (gimp,
gimp_get_user_context (gimp),
GIMP_PROGRESS (display),
file, as_new,
screen, monitor,
&status, &error);
if (image)
{
success = TRUE;
g_object_set_data_full (G_OBJECT (gimp), GIMP_FILE_OPEN_LAST_FILE_KEY,
g_object_ref (file),
(GDestroyNotify) g_object_unref);
}
else if (status != GIMP_PDB_CANCEL && display)
{
gimp_message (gimp, G_OBJECT (display), GIMP_MESSAGE_ERROR,
_("Opening '%s' failed: %s"),
gimp_file_get_utf8_name (file), error->message);
g_clear_error (&error);
}
if (display)
g_object_remove_weak_pointer (G_OBJECT (display), (gpointer) &display);
return success;
}
static void
gimp_clipboard_send_buffer (GtkClipboard *clipboard,
GtkSelectionData *selection_data,
guint info,
Gimp *gimp)
{
GimpClipboard *gimp_clip = gimp_clipboard_get (gimp);
GdkPixbuf *pixbuf;
gimp_set_busy (gimp);
pixbuf = gimp_viewable_get_pixbuf (GIMP_VIEWABLE (gimp_clip->buffer),
gimp_get_user_context (gimp),
gimp_buffer_get_width (gimp_clip->buffer),
gimp_buffer_get_height (gimp_clip->buffer));
if (pixbuf)
{
if (gimp->be_verbose)
g_printerr ("clipboard: sending pixbuf data as '%s'\n",
gimp_clip->target_entries[info].target);
gtk_selection_data_set_pixbuf (selection_data, pixbuf);
}
else
{
g_warning ("%s: gimp_viewable_get_pixbuf() failed", G_STRFUNC);
}
gimp_unset_busy (gimp);
}
void
tool_manager_exit (Gimp *gimp)
{
GimpToolManager *tool_manager;
GimpContext *user_context;
g_return_if_fail (GIMP_IS_GIMP (gimp));
tool_manager = tool_manager_get (gimp);
tool_manager_set (gimp, NULL);
user_context = gimp_get_user_context (gimp);
g_signal_handlers_disconnect_by_func (user_context,
tool_manager_tool_changed,
tool_manager);
g_signal_handlers_disconnect_by_func (user_context,
tool_manager_preset_changed,
tool_manager);
gimp_container_remove_handler (gimp->images,
tool_manager->image_clean_handler_id);
gimp_container_remove_handler (gimp->images,
tool_manager->image_dirty_handler_id);
if (tool_manager->active_tool)
g_object_unref (tool_manager->active_tool);
g_slice_free (GimpToolManager, tool_manager);
}
static void
plug_in_procedure_execute (GimpPlugInProcedure *procedure,
Gimp *gimp,
GimpDisplay *display,
GimpValueArray *args,
gint n_args)
{
GError *error = NULL;
gimp_value_array_truncate (args, n_args);
/* run the plug-in procedure */
gimp_procedure_execute_async (GIMP_PROCEDURE (procedure), gimp,
gimp_get_user_context (gimp),
GIMP_PROGRESS (display), args,
GIMP_OBJECT (display), &error);
if (error)
{
gimp_message_literal (gimp,
G_OBJECT (display), GIMP_MESSAGE_ERROR,
error->message);
g_error_free (error);
}
else
{
/* remember only image plug-ins */
if (GIMP_PROCEDURE (procedure)->num_args >= 2 &&
GIMP_IS_PARAM_SPEC_IMAGE_ID (GIMP_PROCEDURE (procedure)->args[1]))
{
gimp_plug_in_manager_history_add (gimp->plug_in_manager, procedure);
}
}
}
void
tool_options_actions_update (GimpActionGroup *group,
gpointer data)
{
GimpContext *context = gimp_get_user_context (group->gimp);
GimpToolInfo *tool_info = gimp_context_get_tool (context);
SET_VISIBLE ("tool-options-save-preset-menu", tool_info->presets);
SET_VISIBLE ("tool-options-restore-preset-menu", tool_info->presets);
SET_VISIBLE ("tool-options-edit-preset-menu", tool_info->presets);
SET_VISIBLE ("tool-options-delete-preset-menu", tool_info->presets);
tool_options_actions_update_presets (group, "tool-options-save-preset",
G_CALLBACK (tool_options_save_preset_cmd_callback),
GIMP_HELP_TOOL_OPTIONS_SAVE,
tool_info->presets);
tool_options_actions_update_presets (group, "tool-options-restore-preset",
G_CALLBACK (tool_options_restore_preset_cmd_callback),
GIMP_HELP_TOOL_OPTIONS_RESTORE,
tool_info->presets);
tool_options_actions_update_presets (group, "tool-options-edit-preset",
G_CALLBACK (tool_options_edit_preset_cmd_callback),
GIMP_HELP_TOOL_OPTIONS_EDIT,
tool_info->presets);
tool_options_actions_update_presets (group, "tool-options-delete-preset",
G_CALLBACK (tool_options_delete_preset_cmd_callback),
GIMP_HELP_TOOL_OPTIONS_DELETE,
tool_info->presets);
}
static GimpImage *
file_open_dialog_open_image (GtkWidget *open_dialog,
Gimp *gimp,
const gchar *uri,
GimpPlugInProcedure *load_proc)
{
GimpImage *image;
GimpPDBStatusType status;
GError *error = NULL;
image = file_open_with_proc_and_display (gimp,
gimp_get_user_context (gimp),
GIMP_PROGRESS (open_dialog),
uri, uri, FALSE,
load_proc,
&status, &error);
if (! image && status != GIMP_PDB_CANCEL)
{
gchar *filename = file_utils_uri_display_name (uri);
gimp_message (gimp, G_OBJECT (open_dialog), GIMP_MESSAGE_ERROR,
_("Opening '%s' failed:\n\n%s"), filename, error->message);
g_clear_error (&error);
g_free (filename);
}
return image;
}
static void
copy_named_buffer_callback (GtkWidget *widget,
const gchar *name,
gpointer data)
{
GimpImage *image = GIMP_IMAGE (data);
GimpDrawable *drawable = gimp_image_get_active_drawable (image);
GError *error = NULL;
if (! drawable)
{
gimp_message_literal (image->gimp, NULL, GIMP_MESSAGE_WARNING,
_("There is no active layer or channel to copy from."));
return;
}
if (! (name && strlen (name)))
name = _("(Unnamed Buffer)");
if (gimp_edit_named_copy (image, name, drawable,
gimp_get_user_context (image->gimp), &error))
{
gimp_image_flush (image);
}
else
{
gimp_message_literal (image->gimp, NULL, GIMP_MESSAGE_WARNING,
error->message);
g_clear_error (&error);
}
}
void
dialogs_init (Gimp *gimp,
GimpMenuFactory *menu_factory)
{
GimpDialogFactory *factory = NULL;
gint i = 0;
g_return_if_fail (GIMP_IS_GIMP (gimp));
g_return_if_fail (GIMP_IS_MENU_FACTORY (menu_factory));
factory = gimp_dialog_factory_new ("toplevel",
gimp_get_user_context (gimp),
menu_factory);
gimp_dialog_factory_set_singleton (factory);
for (i = 0; i < G_N_ELEMENTS (entries); i++)
gimp_dialog_factory_register_entry (gimp_dialog_factory_get_singleton (),
entries[i].identifier,
gettext (entries[i].name),
gettext (entries[i].blurb),
entries[i].icon_name,
entries[i].help_id,
entries[i].new_func,
entries[i].restore_func,
entries[i].view_size,
entries[i].singleton,
entries[i].session_managed,
entries[i].remember_size,
entries[i].remember_if_open,
entries[i].hideable,
entries[i].image_window,
entries[i].dockable);
global_recent_docks = gimp_list_new (GIMP_TYPE_SESSION_INFO, FALSE);
}
gboolean
gimp_contexts_save (Gimp *gimp,
GError **error)
{
gchar *filename;
gboolean success;
g_return_val_if_fail (GIMP_IS_GIMP (gimp), FALSE);
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
filename = gimp_personal_rc_file ("contextrc");
if (gimp->be_verbose)
g_print ("Writing '%s'\n", gimp_filename_to_utf8 (filename));
success = gimp_config_serialize_to_file (GIMP_CONFIG (gimp_get_user_context (gimp)),
filename,
"GIMP user context",
"end of user context",
NULL, error);
g_free (filename);
return success;
}
gboolean
gimp_contexts_save (Gimp *gimp,
GError **error)
{
GFile *file;
gboolean success;
g_return_val_if_fail (GIMP_IS_GIMP (gimp), FALSE);
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
file = gimp_directory_file ("contextrc", NULL);
if (gimp->be_verbose)
g_print ("Writing '%s'\n", gimp_file_get_utf8_name (file));
success = gimp_config_serialize_to_gfile (GIMP_CONFIG (gimp_get_user_context (gimp)),
file,
"GIMP user context",
"end of user context",
NULL, error);
g_object_unref (file);
return success;
}
static GimpImage *
file_open_dialog_open_image (GtkWidget *dialog,
Gimp *gimp,
GFile *file,
GimpPlugInProcedure *load_proc)
{
GimpImage *image;
GimpPDBStatusType status;
GError *error = NULL;
image = file_open_with_proc_and_display (gimp,
gimp_get_user_context (gimp),
GIMP_PROGRESS (dialog),
file, file, FALSE,
load_proc,
G_OBJECT (gtk_widget_get_screen (dialog)),
gimp_widget_get_monitor (dialog),
&status, &error);
if (! image && status != GIMP_PDB_CANCEL)
{
gimp_message (gimp, G_OBJECT (dialog), GIMP_MESSAGE_ERROR,
_("Opening '%s' failed:\n\n%s"),
gimp_file_get_utf8_name (file), error->message);
g_clear_error (&error);
}
return image;
}
void
items_actions_setup (GimpActionGroup *group,
const gchar *prefix)
{
GEnumClass *enum_class;
GEnumValue *value;
enum_class = g_type_class_ref (GIMP_TYPE_COLOR_TAG);
for (value = enum_class->values; value->value_name; value++)
{
gchar action[32];
g_snprintf (action, sizeof (action),
"%s-color-tag-%s", prefix, value->value_nick);
if (value->value == GIMP_COLOR_TAG_NONE)
{
gimp_action_group_set_action_always_show_image (group, action, TRUE);
}
else
{
GimpRGB color;
gimp_action_group_set_action_context (group, action,
gimp_get_user_context (group->gimp));
gimp_get_color_tag_color (value->value, &color, FALSE);
gimp_action_group_set_action_color (group, action, &color, FALSE);
}
}
g_type_class_unref (enum_class);
}
static void
gimp_controller_list_edit_clicked (GtkWidget *button,
GimpControllerList *list)
{
GtkWidget *dialog;
GtkWidget *editor;
dialog = g_object_get_data (G_OBJECT (list->dest_info),
"gimp-controller-editor-dialog");
if (dialog)
{
gtk_window_present (GTK_WINDOW (dialog));
return;
}
dialog = gimp_dialog_new (_("Configure Input Controller"),
"gimp-controller-editor-dialog",
gtk_widget_get_toplevel (GTK_WIDGET (list)),
GTK_DIALOG_DESTROY_WITH_PARENT,
gimp_standard_help_func,
GIMP_HELP_PREFS_INPUT_CONTROLLERS,
GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE,
NULL);
gimp_dialog_factory_add_foreign (gimp_dialog_factory_get_singleton (),
"gimp-controller-editor-dialog",
dialog);
g_signal_connect (dialog, "response",
G_CALLBACK (gtk_widget_destroy),
NULL);
editor = gimp_controller_editor_new (list->dest_info,
gimp_get_user_context (list->gimp));
gtk_container_set_border_width (GTK_CONTAINER (editor), 12);
gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))),
editor, TRUE, TRUE, 0);
gtk_widget_show (editor);
g_object_set_data (G_OBJECT (list->dest_info), "gimp-controller-editor-dialog",
dialog);
g_signal_connect_object (dialog, "destroy",
G_CALLBACK (gimp_controller_list_edit_destroy),
G_OBJECT (list->dest_info), 0);
g_signal_connect_object (list, "destroy",
G_CALLBACK (gtk_widget_destroy),
G_OBJECT (dialog),
G_CONNECT_SWAPPED);
g_signal_connect_object (list, "unmap",
G_CALLBACK (gtk_widget_destroy),
G_OBJECT (dialog),
G_CONNECT_SWAPPED);
gtk_widget_show (dialog);
}
gboolean
procedure_commands_run_procedure (GimpProcedure *procedure,
Gimp *gimp,
GimpProgress *progress,
GimpRunMode run_mode,
GimpValueArray *args,
GimpDisplay *display)
{
GError *error = NULL;
g_return_val_if_fail (GIMP_IS_PROCEDURE (procedure), FALSE);
g_return_val_if_fail (GIMP_IS_GIMP (gimp), FALSE);
g_return_val_if_fail (progress == NULL || GIMP_IS_PROGRESS (progress), FALSE);
g_return_val_if_fail (display == NULL || GIMP_IS_DISPLAY (display), FALSE);
g_return_val_if_fail (args != NULL, FALSE);
g_value_set_int (gimp_value_array_index (args, 0), run_mode);
gimp_procedure_execute_async (procedure, gimp,
gimp_get_user_context (gimp),
progress, args,
GIMP_OBJECT (display), &error);
if (error)
{
gimp_message_literal (gimp,
G_OBJECT (progress), GIMP_MESSAGE_ERROR,
error->message);
g_clear_error (&error);
return FALSE;
}
return TRUE;
}
void
gimp_image_map_tool_edit_as (GimpImageMapTool *im_tool,
const gchar *new_tool_id,
GimpConfig *config)
{
GimpDisplay *display;
GimpContext *user_context;
GimpToolInfo *tool_info;
GimpTool *new_tool;
g_return_if_fail (GIMP_IS_IMAGE_MAP_TOOL (im_tool));
g_return_if_fail (new_tool_id);
g_return_if_fail (GIMP_IS_CONFIG (config));
display = GIMP_TOOL (im_tool)->display;
user_context = gimp_get_user_context (display->gimp);
tool_info = (GimpToolInfo *)
gimp_container_get_child_by_name (display->gimp->tool_info_list,
new_tool_id);
gimp_context_set_tool (user_context, tool_info);
tool_manager_initialize_active (display->gimp, display);
new_tool = tool_manager_get_active (display->gimp);
GIMP_IMAGE_MAP_TOOL (new_tool)->default_config = g_object_ref (config);
gimp_image_map_tool_reset (GIMP_IMAGE_MAP_TOOL (new_tool));
}
static void
gimp_file_dialog_add_preview (GimpFileDialog *dialog,
Gimp *gimp)
{
if (gimp->config->thumbnail_size <= 0)
return;
gtk_file_chooser_set_use_preview_label (GTK_FILE_CHOOSER (dialog), FALSE);
g_signal_connect (dialog, "selection-changed",
G_CALLBACK (gimp_file_dialog_selection_changed),
dialog);
g_signal_connect (dialog, "update-preview",
G_CALLBACK (gimp_file_dialog_update_preview),
dialog);
dialog->thumb_box = gimp_thumb_box_new (gimp_get_user_context (gimp));
gtk_widget_set_sensitive (GTK_WIDGET (dialog->thumb_box), FALSE);
gtk_file_chooser_set_preview_widget (GTK_FILE_CHOOSER (dialog),
dialog->thumb_box);
gtk_widget_show (dialog->thumb_box);
#ifdef ENABLE_FILE_SYSTEM_ICONS
GIMP_VIEW_RENDERER_IMAGEFILE (GIMP_VIEW (GIMP_THUMB_BOX (dialog->thumb_box)->preview)->renderer)->file_system = _gtk_file_chooser_get_file_system (GTK_FILE_CHOOSER (dialog));
#endif
}
static void
gui_initialize_after_callback (Gimp *gimp,
GimpInitStatusFunc status_callback)
{
const gchar *name = NULL;
g_return_if_fail (GIMP_IS_GIMP (gimp));
if (gimp->be_verbose)
g_print ("INIT: %s\n", G_STRFUNC);
#if defined (GDK_WINDOWING_X11)
name = "DISPLAY";
#elif defined (GDK_WINDOWING_DIRECTFB) || defined (GDK_WINDOWING_FB)
name = "GDK_DISPLAY";
#endif
/* TODO: Need to care about display migration with GTK+ 2.2 at some point */
if (name)
{
gchar *display = gdk_get_display ();
gimp_environ_table_add (gimp->plug_in_manager->environ_table,
name, display, NULL);
g_free (display);
}
gimp_tools_init (gimp);
gimp_context_set_tool (gimp_get_user_context (gimp),
gimp_tool_info_get_standard (gimp));
}
void
tool_presets_save_cmd_callback (GtkAction *action,
gpointer data)
{
GimpContainerEditor *editor = GIMP_CONTAINER_EDITOR (data);
GimpContext *context;
GimpToolPreset *preset;
GimpToolInfo *tool_info;
context = gimp_container_view_get_context (editor->view);
preset = gimp_context_get_tool_preset (context);
tool_info = gimp_context_get_tool (gimp_get_user_context (context->gimp));
if (tool_info && preset)
{
GimpToolInfo *preset_tool;
preset_tool = gimp_context_get_tool (GIMP_CONTEXT (preset->tool_options));
if (tool_info != preset_tool)
{
gimp_message (context->gimp,
G_OBJECT (editor), GIMP_MESSAGE_WARNING,
_("Can't save '%s' tool options to an "
"existing '%s' tool preset."),
tool_info->blurb,
preset_tool->blurb);
return;
}
gimp_config_sync (G_OBJECT (tool_info->tool_options),
G_OBJECT (preset->tool_options), 0);
}
}
static gboolean
gimp_profile_view_query (GimpProfileChooserDialog *dialog)
{
gchar *filename;
filename = gtk_file_chooser_get_preview_filename (GTK_FILE_CHOOSER (dialog));
if (filename)
{
gchar *name = NULL;
gchar *desc = NULL;
gchar *info = NULL;
if (plug_in_icc_profile_file_info (dialog->gimp,
gimp_get_user_context (dialog->gimp),
NULL,
filename,
&name, &desc, &info,
NULL))
{
gsize info_len = info ? strlen (info) : 0;
gsize name_len = strlen (filename);
/* lcms tends to adds the filename at the end of the info string.
* Since this is redundant information here, we remove it.
*/
if (info_len > name_len &&
strcmp (info + info_len - name_len, filename) == 0)
{
info_len -= name_len;
}
gtk_text_buffer_set_text (dialog->buffer, info ? info : "", info_len);
if (desc)
{
dialog->desc = desc;
desc = NULL;
}
else if (name)
{
dialog->desc = name;
name = NULL;
}
dialog->filename = filename;
filename = NULL;
g_free (name);
g_free (desc);
g_free (info);
}
g_free (filename);
}
return FALSE;
}
static void
gimp_device_info_constructed (GObject *object)
{
GimpDeviceInfo *info = GIMP_DEVICE_INFO (object);
Gimp *gimp;
G_OBJECT_CLASS (parent_class)->constructed (object);
g_assert ((info->device == NULL && info->display == NULL) ||
(GDK_IS_DEVICE (info->device) && GDK_IS_DISPLAY (info->display)));
gimp = GIMP_CONTEXT (object)->gimp;
if (info->device)
{
g_object_set_data (G_OBJECT (info->device), GIMP_DEVICE_INFO_DATA_KEY,
info);
gimp_object_set_name (GIMP_OBJECT (info), info->device->name);
info->mode = info->device->mode;
info->n_axes = info->device->num_axes;
info->n_keys = info->device->num_keys;
}
gimp_context_define_properties (GIMP_CONTEXT (object),
GIMP_DEVICE_INFO_CONTEXT_MASK,
FALSE);
gimp_context_copy_properties (gimp_get_user_context (gimp),
GIMP_CONTEXT (object),
GIMP_DEVICE_INFO_CONTEXT_MASK);
gimp_context_set_serialize_properties (GIMP_CONTEXT (object),
GIMP_DEVICE_INFO_CONTEXT_MASK);
/* FIXME: this is ugly and needs to be done via "notify" once
* the contexts' properties are dynamic.
*/
g_signal_connect (object, "foreground-changed",
G_CALLBACK (gimp_device_info_changed),
NULL);
g_signal_connect (object, "background-changed",
G_CALLBACK (gimp_device_info_changed),
NULL);
g_signal_connect (object, "tool-changed",
G_CALLBACK (gimp_device_info_changed),
NULL);
g_signal_connect (object, "brush-changed",
G_CALLBACK (gimp_device_info_changed),
NULL);
g_signal_connect (object, "pattern-changed",
G_CALLBACK (gimp_device_info_changed),
NULL);
g_signal_connect (object, "gradient-changed",
G_CALLBACK (gimp_device_info_changed),
NULL);
}
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);
}
}
/* This function is called for filenames passed on the command-line
* or from the D-Bus service.
*/
gboolean
file_open_from_command_line (Gimp *gimp,
const gchar *filename,
gboolean as_new)
{
GError *error = NULL;
gchar *uri;
gboolean success = FALSE;
g_return_val_if_fail (GIMP_IS_GIMP (gimp), FALSE);
g_return_val_if_fail (filename != NULL, FALSE);
/* we accept URI or filename */
uri = file_utils_any_to_uri (gimp, filename, &error);
if (uri)
{
GimpImage *image;
GimpObject *display = gimp_get_empty_display (gimp);
GimpPDBStatusType status;
image = file_open_with_display (gimp,
gimp_get_user_context (gimp),
GIMP_PROGRESS (display),
uri, as_new,
&status, &error);
if (image)
{
success = TRUE;
g_object_set_data_full (G_OBJECT (gimp), GIMP_FILE_OPEN_LAST_URI_KEY,
uri, (GDestroyNotify) g_free);
}
else if (status != GIMP_PDB_CANCEL)
{
gchar *filename = file_utils_uri_display_name (uri);
gimp_message (gimp, G_OBJECT (display), GIMP_MESSAGE_ERROR,
_("Opening '%s' failed: %s"),
filename, error->message);
g_clear_error (&error);
g_free (filename);
g_free (uri);
}
}
else
{
g_printerr ("conversion filename -> uri failed: %s\n",
error->message);
g_clear_error (&error);
}
return success;
}
static gboolean
gui_get_background_func (GimpRGB *color)
{
g_return_val_if_fail (color != NULL, FALSE);
g_return_val_if_fail (GIMP_IS_GIMP (the_gui_gimp), FALSE);
gimp_context_get_background (gimp_get_user_context (the_gui_gimp), color);
return TRUE;
}
void
debug_dump_attached_data_cmd_callback (GtkAction *action,
gpointer data)
{
Gimp *gimp = action_data_get_gimp (data);
GimpContext *user_context = gimp_get_user_context (gimp);
debug_print_qdata (GIMP_OBJECT (gimp));
debug_print_qdata (GIMP_OBJECT (user_context));
}
void
tool_options_reset_cmd_callback (GtkAction *action,
gpointer data)
{
GimpEditor *editor = GIMP_EDITOR (data);
GimpContext *context = gimp_get_user_context (gimp_editor_get_ui_manager (editor)->gimp);
GimpToolInfo *tool_info = gimp_context_get_tool (context);
gimp_config_reset (GIMP_CONFIG (tool_info->tool_options));
}
void
gimp_devices_restore (Gimp *gimp)
{
GimpDeviceManager *manager;
GimpContext *user_context;
GimpDeviceInfo *current_device;
GList *list;
gchar *filename;
GError *error = NULL;
g_return_if_fail (GIMP_IS_GIMP (gimp));
manager = gimp_devices_get_manager (gimp);
g_return_if_fail (GIMP_IS_DEVICE_MANAGER (manager));
user_context = gimp_get_user_context (gimp);
for (list = GIMP_LIST (manager)->list;
list;
list = g_list_next (list))
{
GimpDeviceInfo *device_info = list->data;
gimp_context_copy_properties (user_context, GIMP_CONTEXT (device_info),
GIMP_DEVICE_INFO_CONTEXT_MASK);
gimp_device_info_set_default_tool (device_info);
}
filename = gimp_personal_rc_file ("devicerc");
if (gimp->be_verbose)
g_print ("Parsing '%s'\n", gimp_filename_to_utf8 (filename));
if (! gimp_config_deserialize_file (GIMP_CONFIG (manager),
filename,
gimp,
&error))
{
if (error->code != GIMP_CONFIG_ERROR_OPEN_ENOENT)
gimp_message_literal (gimp, NULL, GIMP_MESSAGE_ERROR, error->message);
g_error_free (error);
/* don't bail out here */
}
g_free (filename);
current_device = gimp_device_manager_get_current_device (manager);
gimp_context_copy_properties (GIMP_CONTEXT (current_device), user_context,
GIMP_DEVICE_INFO_CONTEXT_MASK);
gimp_context_set_parent (GIMP_CONTEXT (current_device), user_context);
}
static gboolean
gui_exit_callback (Gimp *gimp,
gboolean force)
{
GimpGuiConfig *gui_config = GIMP_GUI_CONFIG (gimp->config);
if (gimp->be_verbose)
g_print ("EXIT: %s\n", G_STRFUNC);
if (! force && gimp_displays_dirty (gimp))
{
GdkScreen *screen;
gint monitor;
monitor = gimp_get_monitor_at_pointer (&screen);
gimp_dialog_factory_dialog_raise (gimp_dialog_factory_get_singleton (),
screen, monitor,
"gimp-quit-dialog", -1);
return TRUE; /* stop exit for now */
}
gimp->message_handler = GIMP_CONSOLE;
gui_unique_exit ();
if (gui_config->save_session_info)
session_save (gimp, FALSE);
color_history_save (gimp);
if (gui_config->save_accels)
menus_save (gimp, FALSE);
if (gui_config->save_device_status)
gimp_devices_save (gimp, FALSE);
if (TRUE /* gui_config->save_controllers */)
gimp_controllers_save (gimp);
g_signal_handlers_disconnect_by_func (gimp_get_user_context (gimp),
gui_display_changed,
gimp);
gimp_displays_delete (gimp);
gimp_tools_save (gimp, gui_config->save_tool_options, FALSE);
gimp_tools_exit (gimp);
gimp_language_store_parser_clean ();
return FALSE; /* continue exiting */
}
static void
gimp_display_shell_dnd_flush (GimpDisplayShell *shell,
GimpImage *image)
{
gtk_window_present (GTK_WINDOW (shell));
gimp_image_flush (image);
gimp_context_set_display (gimp_get_user_context (shell->display->gimp),
shell->display);
}
void
edit_actions_setup (GimpActionGroup *group)
{
GimpContext *context = gimp_get_user_context (group->gimp);
GimpRGB color;
GimpPattern *pattern;
GtkAction *action;
gimp_action_group_add_actions (group, "edit-action",
edit_actions,
G_N_ELEMENTS (edit_actions));
gimp_action_group_add_enum_actions (group, "edit-action",
edit_fill_actions,
G_N_ELEMENTS (edit_fill_actions),
G_CALLBACK (edit_fill_cmd_callback));
action = gtk_action_group_get_action (GTK_ACTION_GROUP (group),
"edit-paste-as-new-short");
gtk_action_set_accel_path (action, "<Actions>/edit/edit-paste-as-new");
action = gtk_action_group_get_action (GTK_ACTION_GROUP (group),
"edit-fill-pattern");
g_object_set (action, "context", context, NULL);
g_signal_connect_object (context, "foreground-changed",
G_CALLBACK (edit_actions_foreground_changed),
group, 0);
g_signal_connect_object (context, "background-changed",
G_CALLBACK (edit_actions_background_changed),
group, 0);
g_signal_connect_object (context, "pattern-changed",
G_CALLBACK (edit_actions_pattern_changed),
group, 0);
gimp_context_get_foreground (context, &color);
edit_actions_foreground_changed (context, &color, group);
gimp_context_get_background (context, &color);
edit_actions_background_changed (context, &color, group);
pattern = gimp_context_get_pattern (context);
edit_actions_pattern_changed (context, pattern, group);
#define SET_ALWAYS_SHOW_IMAGE(action,show) \
gimp_action_group_set_action_always_show_image (group, action, show)
SET_ALWAYS_SHOW_IMAGE ("edit-fill-fg", TRUE);
SET_ALWAYS_SHOW_IMAGE ("edit-fill-bg", TRUE);
SET_ALWAYS_SHOW_IMAGE ("edit-fill-pattern", TRUE);
#undef SET_ALWAYS_SHOW_IMAGE
}