void
tool_manager_oper_update_active (Gimp *gimp,
const GimpCoords *coords,
GdkModifierType state,
gboolean proximity,
GimpDisplay *display)
{
GimpToolManager *tool_manager;
g_return_if_fail (GIMP_IS_GIMP (gimp));
tool_manager = tool_manager_get (gimp);
if (tool_manager->active_tool)
{
gimp_tool_oper_update (tool_manager->active_tool,
coords, state, proximity,
display);
}
}
GimpImage *
gimp_edit_paste_as_new_image (Gimp *gimp,
GimpObject *paste)
{
GimpImage *image = NULL;
g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);
g_return_val_if_fail (GIMP_IS_IMAGE (paste) || GIMP_IS_BUFFER (paste), NULL);
if (GIMP_IS_IMAGE (paste))
{
image = gimp_image_duplicate (GIMP_IMAGE (paste));
}
else if (GIMP_IS_BUFFER (paste))
{
image = gimp_image_new_from_buffer (gimp, GIMP_BUFFER (paste));
}
return image;
}
gboolean
tool_manager_key_release_active (Gimp *gimp,
GdkEventKey *kevent,
GimpDisplay *display)
{
GimpToolManager *tool_manager;
g_return_val_if_fail (GIMP_IS_GIMP (gimp), FALSE);
tool_manager = tool_manager_get (gimp);
if (tool_manager->active_tool)
{
return gimp_tool_key_release (tool_manager->active_tool,
kevent,
display);
}
return FALSE;
}
void
gimp_filter_history_remove (Gimp *gimp,
GimpProcedure *procedure)
{
GList *link;
g_return_if_fail (GIMP_IS_GIMP (gimp));
g_return_if_fail (GIMP_IS_PROCEDURE (procedure));
link = g_list_find_custom (gimp->filter_history, procedure,
(GCompareFunc) gimp_filter_history_compare);
if (link)
{
g_object_unref (link->data);
gimp->filter_history = g_list_delete_link (gimp->filter_history, link);
gimp_filter_history_changed (gimp);
}
}
void
tool_manager_cursor_update_active (Gimp *gimp,
const GimpCoords *coords,
GdkModifierType state,
GimpDisplay *display)
{
GimpToolManager *tool_manager;
g_return_if_fail (GIMP_IS_GIMP (gimp));
tool_manager = tool_manager_get (gimp);
if (tool_manager->active_tool &&
! gimp_tool_control_is_active (tool_manager->active_tool->control))
{
gimp_tool_cursor_update (tool_manager->active_tool,
coords, state,
display);
}
}
GtkWidget *
file_open_dialog_new (Gimp *gimp)
{
GtkWidget *dialog;
g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);
dialog = gimp_open_dialog_new (gimp);
gtk_file_chooser_set_select_multiple (GTK_FILE_CHOOSER (dialog), TRUE);
gimp_file_dialog_load_state (GIMP_FILE_DIALOG (dialog),
"gimp-file-open-dialog-state");
g_signal_connect (dialog, "response",
G_CALLBACK (file_open_dialog_response),
gimp);
return dialog;
}
void
tool_manager_button_release_active (Gimp *gimp,
const GimpCoords *coords,
guint32 time,
GdkModifierType state,
GimpDisplay *display)
{
GimpToolManager *tool_manager;
g_return_if_fail (GIMP_IS_GIMP (gimp));
tool_manager = tool_manager_get (gimp);
if (tool_manager->active_tool)
{
gimp_tool_button_release (tool_manager->active_tool,
coords, time, state,
display);
}
}
void
gimp_set_global_buffer (Gimp *gimp,
GimpBuffer *buffer)
{
g_return_if_fail (GIMP_IS_GIMP (gimp));
g_return_if_fail (buffer == NULL || GIMP_IS_BUFFER (buffer));
if (buffer == gimp->global_buffer)
return;
if (gimp->global_buffer)
g_object_unref (gimp->global_buffer);
gimp->global_buffer = buffer;
if (gimp->global_buffer)
g_object_ref (gimp->global_buffer);
g_signal_emit (gimp, gimp_signals[BUFFER_CHANGED], 0);
}
GimpDisplay *
gimp_display_get_by_ID (Gimp *gimp,
gint ID)
{
GList *list;
g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);
for (list = GIMP_LIST (gimp->displays)->list;
list;
list = g_list_next (list))
{
GimpDisplay *display = list->data;
if (display->ID == ID)
return display;
}
return NULL;
}
void
dialogs_exit (Gimp *gimp)
{
g_return_if_fail (GIMP_IS_GIMP (gimp));
if (global_dialog_factory)
{
g_object_unref (global_dialog_factory);
global_dialog_factory = NULL;
}
/* destroy the "global_toolbox_factory" _before_ destroying the
* "global_dock_factory" because the "global_toolbox_factory" owns
* dockables which were created by the "global_dock_factory". This
* way they are properly removed from the "global_dock_factory", which
* would complain about stale entries otherwise.
*/
if (global_toolbox_factory)
{
g_object_unref (global_toolbox_factory);
global_toolbox_factory = NULL;
}
if (global_dock_factory)
{
g_object_unref (global_dock_factory);
global_dock_factory = NULL;
}
if (global_display_factory)
{
g_object_unref (global_display_factory);
global_display_factory = NULL;
}
if (global_recent_docks)
{
g_object_unref (global_recent_docks);
global_recent_docks = NULL;
}
}
void
tool_manager_init (Gimp *gimp)
{
GimpToolManager *tool_manager;
GimpContext *user_context;
g_return_if_fail (GIMP_IS_GIMP (gimp));
tool_manager = g_slice_new0 (GimpToolManager);
tool_manager->active_tool = NULL;
tool_manager->tool_stack = NULL;
tool_manager->image_clean_handler_id = 0;
tool_manager->image_dirty_handler_id = 0;
tool_manager_set (gimp, tool_manager);
tool_manager->image_clean_handler_id =
gimp_container_add_handler (gimp->images, "clean",
G_CALLBACK (tool_manager_image_clean_dirty),
tool_manager);
tool_manager->image_dirty_handler_id =
gimp_container_add_handler (gimp->images, "dirty",
G_CALLBACK (tool_manager_image_clean_dirty),
tool_manager);
user_context = gimp_get_user_context (gimp);
tool_manager->shared_paint_options = g_object_new (GIMP_TYPE_PAINT_OPTIONS,
"gimp", gimp,
"name", "tmp",
NULL);
g_signal_connect (user_context, "tool-changed",
G_CALLBACK (tool_manager_tool_changed),
tool_manager);
g_signal_connect (user_context, "tool-preset-changed",
G_CALLBACK (tool_manager_preset_changed),
tool_manager);
}
void
tool_manager_pop_tool (Gimp *gimp)
{
GimpToolManager *tool_manager;
g_return_if_fail (GIMP_IS_GIMP (gimp));
tool_manager = tool_manager_get (gimp);
if (tool_manager->tool_stack)
{
GimpTool *tool = tool_manager->tool_stack->data;
tool_manager->tool_stack = g_slist_remove (tool_manager->tool_stack,
tool);
tool_manager_select_tool (gimp, tool);
g_object_unref (tool);
}
}
gboolean
file_remote_upload_image_finish (Gimp *gimp,
GFile *file,
GFile *local_file,
GimpProgress *progress,
GError **error)
{
g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);
g_return_val_if_fail (G_IS_FILE (file), NULL);
g_return_val_if_fail (G_IS_FILE (local_file), NULL);
g_return_val_if_fail (progress == NULL || GIMP_IS_PROGRESS (progress), NULL);
g_return_val_if_fail (error == NULL || *error == NULL, NULL);
if (! file_remote_copy_file (gimp, local_file, file, UPLOAD,
progress, error))
{
return FALSE;
}
return TRUE;
}
void
gimp_contexts_init (Gimp *gimp)
{
GimpContext *context;
g_return_if_fail (GIMP_IS_GIMP (gimp));
/* the default context contains the user's saved preferences
*
* TODO: load from disk
*/
context = gimp_context_new (gimp, "Default", NULL);
gimp_set_default_context (gimp, context);
g_object_unref (context);
/* the initial user_context is a straight copy of the default context
*/
context = gimp_context_new (gimp, "User", context);
gimp_set_user_context (gimp, context);
g_object_unref (context);
}
gboolean
gimp_progress_message (GimpProgress *progress,
Gimp *gimp,
GimpMessageSeverity severity,
const gchar *domain,
const gchar *message)
{
GimpProgressInterface *progress_iface;
g_return_val_if_fail (GIMP_IS_PROGRESS (progress), FALSE);
g_return_val_if_fail (GIMP_IS_GIMP (gimp), FALSE);
g_return_val_if_fail (domain != NULL, FALSE);
g_return_val_if_fail (message != NULL, FALSE);
progress_iface = GIMP_PROGRESS_GET_INTERFACE (progress);
if (progress_iface->message)
return progress_iface->message (progress, gimp, severity, domain, message);
return FALSE;
}
GtkWidget *
gimp_error_console_new (Gimp *gimp,
GimpMenuFactory *menu_factory)
{
GimpErrorConsole *console;
g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);
g_return_val_if_fail (GIMP_IS_MENU_FACTORY (menu_factory), NULL);
console = g_object_new (GIMP_TYPE_ERROR_CONSOLE,
"menu-factory", menu_factory,
"menu-identifier", "<ErrorConsole>",
"ui-path", "/error-console-popup",
NULL);
console->gimp = gimp;
console->gimp->message_handler = GIMP_ERROR_CONSOLE;
return GTK_WIDGET (console);
}
void
menus_save (Gimp *gimp,
gboolean always_save)
{
gchar *filename;
g_return_if_fail (GIMP_IS_GIMP (gimp));
if (menurc_deleted && ! always_save)
return;
filename = gimp_personal_rc_file ("menurc");
if (gimp->be_verbose)
g_print ("Writing '%s'\n", gimp_filename_to_utf8 (filename));
gtk_accel_map_save (filename);
g_free (filename);
menurc_deleted = FALSE;
}
/**
* gimp_clipboard_set_text:
* @gimp: pointer to #Gimp
* @text: a %NULL-terminated string in UTF-8 encoding
*
* Offers @text in %GDK_SELECTION_CLIPBOARD and %GDK_SELECTION_PRIMARY.
**/
void
gimp_clipboard_set_text (Gimp *gimp,
const gchar *text)
{
GtkClipboard *clipboard;
g_return_if_fail (GIMP_IS_GIMP (gimp));
g_return_if_fail (text != NULL);
gimp_clipboard_clear (gimp_clipboard_get (gimp));
clipboard = gtk_clipboard_get_for_display (gdk_display_get_default (),
GDK_SELECTION_CLIPBOARD);
if (clipboard)
gtk_clipboard_set_text (clipboard, text, -1);
clipboard = gtk_clipboard_get_for_display (gdk_display_get_default (),
GDK_SELECTION_PRIMARY);
if (clipboard)
gtk_clipboard_set_text (clipboard, text, -1);
}
GtkWidget *
gimp_export_dialog_new (Gimp *gimp)
{
g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);
return g_object_new (GIMP_TYPE_EXPORT_DIALOG,
"gimp", gimp,
"title", _("Export Image"),
"role", "gimp-file-export",
"help-id", GIMP_HELP_FILE_EXPORT_AS,
"ok-button-label", _("_Export"),
"automatic-label", _("By Extension"),
"automatic-help-id", GIMP_HELP_FILE_SAVE_BY_EXTENSION,
"action", GTK_FILE_CHOOSER_ACTION_SAVE,
"file-procs", GIMP_FILE_PROCEDURE_GROUP_EXPORT,
"file-procs-all-images", GIMP_FILE_PROCEDURE_GROUP_SAVE,
"file-filter-label", _("All export images"),
NULL);
}
void
dialogs_exit (Gimp *gimp)
{
g_return_if_fail (GIMP_IS_GIMP (gimp));
if (gimp_dialog_factory_get_singleton ())
{
/* run dispose manually so the factory destroys its dialogs, which
* might in turn directly or indirectly ref the factory
*/
g_object_run_dispose (G_OBJECT (gimp_dialog_factory_get_singleton ()));
g_object_unref (gimp_dialog_factory_get_singleton ());
gimp_dialog_factory_set_singleton (NULL);
}
if (global_recent_docks)
{
g_object_unref (global_recent_docks);
global_recent_docks = NULL;
}
}
void
gimp_wait (Gimp *gimp,
GimpWaitable *waitable,
const gchar *format,
...)
{
va_list args;
gchar *message;
g_return_if_fail (GIMP_IS_GIMP (gimp));
g_return_if_fail (GIMP_IS_WAITABLE (waitable));
g_return_if_fail (format != NULL);
if (gimp_waitable_wait_for (waitable, 0.5 * G_TIME_SPAN_SECOND))
return;
va_start (args, format);
message = g_strdup_vprintf (format, args);
va_end (args);
if (! gimp->console_messages &&
gimp->gui.wait &&
gimp->gui.wait (gimp, waitable, message))
{
return;
}
/* Translator: This message is displayed while GIMP is waiting for
* some operation to finish. The %s argument is a message describing
* the operation.
*/
g_printerr (_("Please wait: %s\n"), message);
gimp_waitable_wait (waitable);
g_free (message);
}
GimpColorProfilePolicy
gimp_query_profile_policy (Gimp *gimp,
GimpImage *image,
GimpContext *context,
GimpColorProfile **dest_profile,
GimpColorRenderingIntent *intent,
gboolean *bpc,
gboolean *dont_ask)
{
g_return_val_if_fail (GIMP_IS_GIMP (gimp), GIMP_COLOR_PROFILE_POLICY_KEEP);
g_return_val_if_fail (GIMP_IS_IMAGE (image), GIMP_COLOR_PROFILE_POLICY_KEEP);
g_return_val_if_fail (GIMP_IS_CONTEXT (context), GIMP_COLOR_PROFILE_POLICY_KEEP);
g_return_val_if_fail (dest_profile != NULL, GIMP_COLOR_PROFILE_POLICY_KEEP);
if (gimp->gui.query_profile_policy)
return gimp->gui.query_profile_policy (gimp, image, context,
dest_profile,
intent, bpc,
dont_ask);
return GIMP_COLOR_PROFILE_POLICY_KEEP;
}
/**
* gimp_clipboard_has_svg:
* @gimp: pointer to #Gimp
*
* Tests if there's SVG data in %GDK_SELECTION_CLIPBOARD.
* This is done in a main-loop similar to
* gtk_clipboard_wait_is_text_available(). The same caveats apply here.
*
* Return value: %TRUE if there's SVG data in the clipboard, %FALSE otherwise
**/
gboolean
gimp_clipboard_has_svg (Gimp *gimp)
{
GimpClipboard *gimp_clip;
GtkClipboard *clipboard;
g_return_val_if_fail (GIMP_IS_GIMP (gimp), FALSE);
clipboard = gtk_clipboard_get_for_display (gdk_display_get_default (),
GDK_SELECTION_CLIPBOARD);
if (clipboard &&
gtk_clipboard_get_owner (clipboard) != G_OBJECT (gimp) &&
gimp_clipboard_wait_for_svg (gimp) != GDK_NONE)
{
return TRUE;
}
gimp_clip = gimp_clipboard_get (gimp);
return (gimp_clip->svg != NULL);
}
void
themes_init (Gimp *gimp)
{
GimpGuiConfig *config;
gchar *themerc;
g_return_if_fail (GIMP_IS_GIMP (gimp));
config = GIMP_GUI_CONFIG (gimp->config);
themes_hash = g_hash_table_new_full (g_str_hash,
g_str_equal,
g_free,
g_free);
if (config->theme_path)
{
gchar *path;
path = gimp_config_path_expand (config->theme_path, TRUE, NULL);
gimp_datafiles_read_directories (path,
G_FILE_TEST_IS_DIR,
themes_directories_foreach,
gimp);
g_free (path);
}
themes_apply_theme (gimp, config->theme);
themerc = gimp_personal_rc_file ("themerc");
gtk_rc_parse (themerc);
g_free (themerc);
g_signal_connect (config, "notify::theme",
G_CALLBACK (themes_theme_change_notify),
gimp);
}
void
gimp_load_config (Gimp *gimp,
GFile *alternate_system_gimprc,
GFile *alternate_gimprc)
{
GimpRc *gimprc;
g_return_if_fail (GIMP_IS_GIMP (gimp));
g_return_if_fail (alternate_system_gimprc == NULL ||
G_IS_FILE (alternate_system_gimprc));
g_return_if_fail (alternate_gimprc == NULL ||
G_IS_FILE (alternate_gimprc));
g_return_if_fail (gimp->config == NULL);
g_return_if_fail (gimp->edit_config == NULL);
if (gimp->be_verbose)
g_print ("INIT: %s\n", G_STRFUNC);
/* this needs to be done before gimprc loading because gimprc can
* use user defined units
*/
gimp_unitrc_load (gimp);
gimprc = gimp_rc_new (alternate_system_gimprc,
alternate_gimprc,
gimp->be_verbose);
gimp->config = GIMP_CORE_CONFIG (gimprc);
gimp->edit_config = gimp_config_duplicate (GIMP_CONFIG (gimp->config));
g_signal_connect_object (gimp->config, "notify",
G_CALLBACK (gimp_global_config_notify),
gimp->edit_config, 0);
g_signal_connect_object (gimp->edit_config, "notify",
G_CALLBACK (gimp_edit_config_notify),
gimp->config, 0);
}
void
themes_init (Gimp *gimp)
{
GimpGuiConfig *config;
g_return_if_fail (GIMP_IS_GIMP (gimp));
config = GIMP_GUI_CONFIG (gimp->config);
/* Check for theme extensions. */
themes_theme_paths_notify (gimp->extension_manager, NULL, gimp);
g_signal_connect (gimp->extension_manager, "notify::theme-paths",
G_CALLBACK (themes_theme_paths_notify),
gimp);
themes_style_provider = GTK_STYLE_PROVIDER (gtk_css_provider_new ());
/* Use GTK_STYLE_PROVIDER_PRIORITY_APPLICATION + 1 so theme files
* override default styles provided by widgets themselves.
*/
gtk_style_context_add_provider_for_screen (gdk_screen_get_default (),
themes_style_provider,
GTK_STYLE_PROVIDER_PRIORITY_APPLICATION + 1);
g_object_unref (themes_style_provider);
g_signal_connect (config, "notify::theme",
G_CALLBACK (themes_theme_change_notify),
gimp);
g_signal_connect (config, "notify::prefer-dark-theme",
G_CALLBACK (themes_theme_change_notify),
gimp);
g_signal_connect (config, "notify::prefer-symbolic-icons",
G_CALLBACK (themes_theme_change_notify),
gimp);
themes_theme_change_notify (config, NULL, gimp);
}
/**
* gimp_clipboard_set_buffer:
* @gimp: pointer to #Gimp
* @buffer: a #GimpBuffer, or %NULL.
*
* Offers the buffer in %GDK_SELECTION_CLIPBOARD.
**/
void
gimp_clipboard_set_buffer (Gimp *gimp,
GimpBuffer *buffer)
{
GimpClipboard *gimp_clip;
GtkClipboard *clipboard;
g_return_if_fail (GIMP_IS_GIMP (gimp));
g_return_if_fail (buffer == NULL || GIMP_IS_BUFFER (buffer));
clipboard = gtk_clipboard_get_for_display (gdk_display_get_default (),
GDK_SELECTION_CLIPBOARD);
if (! clipboard)
return;
gimp_clip = gimp_clipboard_get (gimp);
gimp_clipboard_clear (gimp_clip);
if (buffer)
{
gimp_clip->buffer = g_object_ref (buffer);
gtk_clipboard_set_with_owner (clipboard,
gimp_clip->target_entries,
gimp_clip->n_target_entries,
(GtkClipboardGetFunc) gimp_clipboard_send_buffer,
(GtkClipboardClearFunc) NULL,
G_OBJECT (gimp));
/* mark the first entry (image/png) as suitable for storing */
gtk_clipboard_set_can_store (clipboard, gimp_clip->target_entries, 1);
}
else if (gtk_clipboard_get_owner (clipboard) == G_OBJECT (gimp))
{
gtk_clipboard_clear (clipboard);
}
}
void
gimp_filter_history_add (Gimp *gimp,
GimpProcedure *procedure)
{
GList *link;
g_return_if_fail (GIMP_IS_GIMP (gimp));
g_return_if_fail (GIMP_IS_PROCEDURE (procedure));
/* return early if the procedure is already at the top */
if (gimp->filter_history &&
gimp_filter_history_compare (gimp->filter_history->data, procedure) == 0)
return;
/* ref new first then unref old, they might be the same */
g_object_ref (procedure);
link = g_list_find_custom (gimp->filter_history, procedure,
(GCompareFunc) gimp_filter_history_compare);
if (link)
{
g_object_unref (link->data);
gimp->filter_history = g_list_delete_link (gimp->filter_history, link);
}
gimp->filter_history = g_list_prepend (gimp->filter_history, procedure);
link = g_list_nth (gimp->filter_history, gimp_filter_history_size (gimp));
if (link)
{
g_object_unref (link->data);
gimp->filter_history = g_list_delete_link (gimp->filter_history, link);
}
gimp_filter_history_changed (gimp);
}
GtkWidget *
input_devices_dialog_new (Gimp *gimp)
{
GtkWidget *dialog;
GtkWidget *content_area;
GtkWidget *editor;
g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);
dialog = gimp_dialog_new (_("Configure Input Devices"),
"gimp-input-devices-dialog",
NULL, 0,
gimp_standard_help_func,
GIMP_HELP_INPUT_DEVICES,
GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE,
GTK_STOCK_SAVE, GTK_RESPONSE_OK,
NULL);
gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog),
GTK_RESPONSE_OK,
GTK_RESPONSE_CLOSE,
-1);
g_signal_connect (dialog, "response",
G_CALLBACK (input_devices_dialog_response),
gimp);
content_area = gtk_dialog_get_content_area (GTK_DIALOG (dialog));
editor = gimp_device_editor_new (gimp);
gtk_container_set_border_width (GTK_CONTAINER (editor), 12);
gtk_box_pack_start (GTK_BOX (content_area), editor, TRUE, TRUE, 0);
gtk_widget_show (editor);
return dialog;
}
/* Search all history actions which match "keyword" with function
* match_func(action, keyword).
*
* @return a list of GtkAction*, to free with:
* g_list_free_full (result, (GDestroyNotify) g_object_unref);
*/
GList *
gimp_action_history_search (Gimp *gimp,
GimpActionMatchFunc match_func,
const gchar *keyword)
{
GimpGuiConfig *config;
GimpUIManager *manager;
GList *actions;
GList *result = NULL;
gint i;
g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);
g_return_val_if_fail (match_func != NULL, NULL);
config = GIMP_GUI_CONFIG (gimp->config);
manager = gimp_ui_managers_from_name ("<Image>")->data;
for (actions = history.items, i = 0;
actions && i < config->action_history_size;
actions = g_list_next (actions), i++)
{
GimpActionHistoryItem *item = actions->data;
GtkAction *action;
action = gimp_ui_manager_find_action (manager, NULL, item->action_name);
if (action == NULL)
continue;
if (! gtk_action_is_sensitive (action) &&
! config->search_show_unavailable)
continue;
if (match_func (action, keyword, NULL, gimp))
result = g_list_prepend (result, g_object_ref (action));
}
return g_list_reverse (result);
}
