static GimpPaletteEditor *
context_get_palette_editor (void)
{
GimpSessionInfo *info = NULL;
g_return_val_if_fail (GIMP_IS_DIALOG_FACTORY (gimp_dialog_factory_get_singleton ()), NULL);
info = gimp_dialog_factory_find_session_info (gimp_dialog_factory_get_singleton (),
"gimp-palette-editor");
if (info && gimp_session_info_get_widget (info))
return GIMP_PALETTE_EDITOR (gtk_bin_get_child (GTK_BIN (gimp_session_info_get_widget (info))));
return NULL;
}
static GimpPaletteEditor *
context_get_palette_editor (void)
{
GtkWidget *widget;
g_return_val_if_fail (GIMP_IS_DIALOG_FACTORY (gimp_dialog_factory_get_singleton ()), NULL);
widget = gimp_dialog_factory_find_widget (gimp_dialog_factory_get_singleton (),
"gimp-palette-editor");
if (widget)
return GIMP_PALETTE_EDITOR (gtk_bin_get_child (GTK_BIN (widget)));
return NULL;
}
static GimpColormapEditor *
context_get_colormap_editor (void)
{
GimpSessionInfo *info = NULL;
g_return_val_if_fail (GIMP_IS_DIALOG_FACTORY (gimp_dialog_factory_get_singleton ()), NULL);
info = gimp_dialog_factory_find_session_info (gimp_dialog_factory_get_singleton (),
"gimp-indexed-palette");
if (info && gimp_session_info_get_widget (info))
return GIMP_COLORMAP_EDITOR (gtk_bin_get_child (GTK_BIN (gimp_session_info_get_widget (info))));
return NULL;
}
static GimpColormapEditor *
context_get_colormap_editor (void)
{
GtkWidget *widget;
g_return_val_if_fail (GIMP_IS_DIALOG_FACTORY (gimp_dialog_factory_get_singleton ()), NULL);
widget = gimp_dialog_factory_find_widget (gimp_dialog_factory_get_singleton (),
"gimp-indexed-palette");
if (widget)
return GIMP_COLORMAP_EDITOR (gtk_bin_get_child (GTK_BIN (widget)));
return NULL;
}
static gboolean
dialogs_actions_toolbox_exists (Gimp *gimp)
{
GimpDialogFactory *factory = gimp_dialog_factory_get_singleton ();
GimpSessionInfo *info = NULL;
GList *windows = gimp ? gimp_get_image_windows (gimp) : NULL;
gboolean toolbox_found = FALSE;
GList *iter;
/* First look in session managed windows */
info = gimp_dialog_factory_find_session_info (factory, "gimp-toolbox-window");
toolbox_found = info && gimp_session_info_get_widget (info);
/* Then in image windows */
if (! toolbox_found)
{
for (iter = windows; iter; iter = g_list_next (iter))
{
GimpImageWindow *window = GIMP_IMAGE_WINDOW (windows->data);
if (gimp_image_window_has_toolbox (window))
{
toolbox_found = TRUE;
break;
}
}
}
return toolbox_found;
}
gboolean
dialogs_actions_toolbox_exists (Gimp *gimp)
{
GimpDialogFactory *factory = gimp_dialog_factory_get_singleton ();
gboolean toolbox_found = FALSE;
GList *iter;
/* First look in session managed windows */
toolbox_found =
gimp_dialog_factory_find_widget (factory, "gimp-toolbox-window") != NULL;
/* Then in image windows */
if (! toolbox_found)
{
GList *windows = gimp ? gimp_get_image_windows (gimp) : NULL;
for (iter = windows; iter; iter = g_list_next (iter))
{
GimpImageWindow *window = GIMP_IMAGE_WINDOW (windows->data);
if (gimp_image_window_has_toolbox (window))
{
toolbox_found = TRUE;
break;
}
}
g_list_free (windows);
}
return toolbox_found;
}
static void
file_open_dialog_show (Gimp *gimp,
GtkWidget *parent,
const gchar *title,
GimpImage *image,
const gchar *uri,
gboolean open_as_layers)
{
GtkWidget *dialog;
dialog = gimp_dialog_factory_dialog_new (gimp_dialog_factory_get_singleton (),
gtk_widget_get_screen (parent),
NULL /*ui_manager*/,
"gimp-file-open-dialog", -1, FALSE);
if (dialog)
{
if (! uri && image)
uri = gimp_image_get_uri (image);
if (! uri)
uri = g_object_get_data (G_OBJECT (gimp), GIMP_FILE_OPEN_LAST_URI_KEY);
if (uri)
gtk_file_chooser_set_uri (GTK_FILE_CHOOSER (dialog), uri);
gimp_file_dialog_set_open_image (GIMP_FILE_DIALOG (dialog),
image, open_as_layers);
gtk_window_set_transient_for (GTK_WINDOW (dialog),
GTK_WINDOW (gtk_widget_get_toplevel (parent)));
gtk_window_present (GTK_WINDOW (dialog));
}
}
void
session_restore (Gimp *gimp)
{
g_return_if_fail (GIMP_IS_GIMP (gimp));
gimp_dialog_factory_restore (gimp_dialog_factory_get_singleton ());
}
void
gimp_display_shell_clear_software_cursor (GimpDisplayShell *shell)
{
GimpStatusbar *statusbar;
GimpSessionInfo *session_info;
g_return_if_fail (GIMP_IS_DISPLAY_SHELL (shell));
gimp_canvas_item_set_visible (shell->cursor, FALSE);
statusbar = gimp_display_shell_get_statusbar (shell);
gimp_statusbar_clear_cursor (statusbar);
session_info = gimp_dialog_factory_find_session_info (gimp_dialog_factory_get_singleton (),
"gimp-cursor-view");
if (session_info && gimp_session_info_get_widget (session_info))
{
GtkWidget *cursor_view;
cursor_view = gtk_bin_get_child (GTK_BIN (gimp_session_info_get_widget (session_info)));
if (cursor_view)
gimp_cursor_view_clear_cursor (GIMP_CURSOR_VIEW (cursor_view));
}
}
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);
}
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);
}
static void
gui_unset_busy (Gimp *gimp)
{
gimp_displays_unset_busy (gimp);
gimp_dialog_factory_unset_busy (gimp_dialog_factory_get_singleton ());
gdk_flush ();
}
void
windows_open_recent_cmd_callback (GtkAction *action,
gpointer data)
{
GimpSessionInfo *info = g_object_get_data (G_OBJECT (action), "info");
g_object_ref (info);
gimp_container_remove (global_recent_docks, GIMP_OBJECT (info));
gimp_dialog_factory_add_session_info (gimp_dialog_factory_get_singleton (),
info);
gimp_session_info_restore (info, gimp_dialog_factory_get_singleton ());
g_object_unref (info);
}
static gboolean
gui_message_error_console (Gimp *gimp,
GimpMessageSeverity severity,
const gchar *domain,
const gchar *message)
{
GtkWidget *dockable = NULL;
/* try to avoid raising the error console for not so severe messages */
if (severity < GIMP_MESSAGE_ERROR)
{
GtkWidget *widget =
gimp_dialog_factory_find_widget (gimp_dialog_factory_get_singleton (),
"gimp-error-console");
if (GIMP_IS_DOCKABLE (widget))
dockable = widget;
}
if (! dockable)
{
GdkScreen *screen;
gint monitor;
monitor = gimp_get_monitor_at_pointer (&screen);
dockable =
gimp_window_strategy_show_dockable_dialog (GIMP_WINDOW_STRATEGY (gimp_get_window_strategy (gimp)),
gimp,
gimp_dialog_factory_get_singleton (),
screen, monitor,
"gimp-error-console");
}
if (dockable)
{
GtkWidget *child = gtk_bin_get_child (GTK_BIN (dockable));
gimp_error_console_add (GIMP_ERROR_CONSOLE (child),
severity, domain, message);
return TRUE;
}
return FALSE;
}
GtkWidget *
dialogs_get_toolbox (void)
{
GList *list;
g_return_val_if_fail (GIMP_IS_DIALOG_FACTORY (gimp_dialog_factory_get_singleton ()), NULL);
for (list = gimp_dialog_factory_get_open_dialogs (gimp_dialog_factory_get_singleton ());
list;
list = g_list_next (list))
{
if (GIMP_IS_DOCK_WINDOW (list->data) &&
gimp_dock_window_has_toolbox (list->data))
return list->data;
}
return NULL;
}
static void
color_area_color_clicked (GimpFgBgEditor *editor,
GimpActiveColor active_color,
GimpContext *context)
{
GimpRGB color;
const gchar *title;
if (! color_dialog_active)
{
gimp_context_get_foreground (context, &revert_fg);
gimp_context_get_background (context, &revert_bg);
}
if (active_color == GIMP_ACTIVE_COLOR_FOREGROUND)
{
gimp_context_get_foreground (context, &color);
title = _("Change Foreground Color");
}
else
{
gimp_context_get_background (context, &color);
title = _("Change Background Color");
}
edit_color = active_color;
if (! color_dialog)
{
color_dialog = gimp_color_dialog_new (NULL, context,
NULL, NULL, NULL,
GTK_WIDGET (editor),
gimp_dialog_factory_get_singleton (),
"gimp-toolbox-color-dialog",
&color,
TRUE, FALSE);
g_signal_connect_object (color_dialog, "update",
G_CALLBACK (color_area_dialog_update),
G_OBJECT (context), 0);
g_signal_connect_object (context, "foreground-changed",
G_CALLBACK (color_area_foreground_changed),
G_OBJECT (color_dialog), 0);
g_signal_connect_object (context, "background-changed",
G_CALLBACK (color_area_background_changed),
G_OBJECT (color_dialog), 0);
}
gtk_window_set_title (GTK_WINDOW (color_dialog), title);
gimp_color_dialog_set_color (GIMP_COLOR_DIALOG (color_dialog), &color);
gtk_window_present (GTK_WINDOW (color_dialog));
color_dialog_active = TRUE;
}
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 */
}
void
file_open_location_cmd_callback (GtkAction *action,
gpointer data)
{
GtkWidget *widget;
return_if_no_widget (widget, data);
gimp_dialog_factory_dialog_new (gimp_dialog_factory_get_singleton (),
gtk_widget_get_screen (widget),
NULL /*ui_manager*/,
"gimp-file-open-location-dialog", -1, TRUE);
}
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
palettes_import_cmd_callback (GtkAction *action,
gpointer data)
{
GtkWidget *widget;
return_if_no_widget (widget, data);
gimp_dialog_factory_dialog_new (gimp_dialog_factory_get_singleton (),
gtk_widget_get_screen (widget),
gimp_widget_get_monitor (widget),
NULL /*ui_manager*/,
"gimp-palette-import-dialog", -1, TRUE);
}
static GtkWidget *
file_save_dialog_show (Gimp *gimp,
GimpImage *image,
GtkWidget *parent,
const gchar *title,
gboolean save_a_copy,
gboolean close_after_saving,
GimpDisplay *display)
{
GtkWidget *dialog;
dialog = g_object_get_data (G_OBJECT (image), "gimp-file-save-dialog");
if (! dialog)
{
dialog = gimp_dialog_factory_dialog_new (gimp_dialog_factory_get_singleton (),
gtk_widget_get_screen (parent),
NULL /*ui_manager*/,
"gimp-file-save-dialog",
-1, FALSE);
if (dialog)
{
gtk_window_set_transient_for (GTK_WINDOW (dialog),
GTK_WINDOW (gtk_widget_get_toplevel (parent)));
g_object_set_data_full (G_OBJECT (image),
"gimp-file-save-dialog", dialog,
(GDestroyNotify) gtk_widget_destroy);
g_signal_connect (dialog, "response",
G_CALLBACK (file_save_dialog_response),
image);
g_signal_connect (dialog, "destroy",
G_CALLBACK (file_save_dialog_destroyed),
image);
}
}
if (dialog)
{
gtk_window_set_title (GTK_WINDOW (dialog), title);
gimp_file_dialog_set_save_image (GIMP_FILE_DIALOG (dialog),
gimp, image, save_a_copy, FALSE,
close_after_saving, GIMP_OBJECT (display));
gtk_window_present (GTK_WINDOW (dialog));
}
return dialog;
}
static void
gimp_viewable_box_edit_clicked (GtkWidget *widget,
GimpViewableButton *button)
{
const gchar *editor_id = g_object_get_data (G_OBJECT (button),
"gimp-viewable-box-editor");
gimp_window_strategy_show_dockable_dialog (GIMP_WINDOW_STRATEGY (gimp_get_window_strategy (button->context->gimp)),
button->context->gimp,
gimp_dialog_factory_get_singleton (),
gtk_widget_get_screen (widget),
gimp_widget_get_monitor (widget),
editor_id);
}
static GtkWidget *
global_error_dialog (void)
{
GdkScreen *screen;
gint monitor;
monitor = gimp_get_monitor_at_pointer (&screen);
return gimp_dialog_factory_dialog_new (gimp_dialog_factory_get_singleton (),
screen, monitor,
NULL /*ui_manager*/,
"gimp-error-dialog", -1,
FALSE);
}
void
view_navigation_window_cmd_callback (GtkAction *action,
gpointer data)
{
Gimp *gimp;
GimpDisplayShell *shell;
return_if_no_gimp (gimp, data);
return_if_no_shell (shell, data);
gimp_window_strategy_show_dockable_dialog (GIMP_WINDOW_STRATEGY (gimp_get_window_strategy (gimp)),
gimp,
gimp_dialog_factory_get_singleton (),
gtk_widget_get_screen (GTK_WIDGET (shell)),
"gimp-navigation-view");
}
void
edit_named_paste_cmd_callback (GtkAction *action,
gpointer data)
{
Gimp *gimp;
GtkWidget *widget;
return_if_no_gimp (gimp, data);
return_if_no_widget (widget, data);
gimp_window_strategy_show_dockable_dialog (GIMP_WINDOW_STRATEGY (gimp_get_window_strategy (gimp)),
gimp,
gimp_dialog_factory_get_singleton (),
gtk_widget_get_screen (widget),
"gimp-buffer-list|gimp-buffer-grid");
}
void
dialogs_create_toplevel_cmd_callback (GtkAction *action,
const gchar *value,
gpointer data)
{
GtkWidget *widget;
return_if_no_widget (widget, data);
if (value)
gimp_dialog_factory_dialog_new (gimp_dialog_factory_get_singleton (),
gimp_widget_get_monitor (widget),
NULL /*ui_manager*/,
widget,
value, -1, TRUE);
}
static void
gimp_text_tool_editor_dialog (GimpTextTool *text_tool)
{
GimpTool *tool = GIMP_TOOL (text_tool);
GimpTextOptions *options = GIMP_TEXT_TOOL_GET_OPTIONS (text_tool);
GimpDialogFactory *dialog_factory;
GtkWindow *parent = NULL;
gdouble xres = 1.0;
gdouble yres = 1.0;
if (text_tool->editor_dialog)
{
gtk_window_present (GTK_WINDOW (text_tool->editor_dialog));
return;
}
dialog_factory = gimp_dialog_factory_get_singleton ();
if (tool->display)
{
GimpDisplayShell *shell = gimp_display_get_shell (tool->display);
parent = GTK_WINDOW (gtk_widget_get_toplevel (GTK_WIDGET (shell)));
}
if (text_tool->image)
gimp_image_get_resolution (text_tool->image, &xres, &yres);
text_tool->editor_dialog =
gimp_text_options_editor_new (parent, tool->tool_info->gimp, options,
gimp_dialog_factory_get_menu_factory (dialog_factory),
_("GIMP Text Editor"),
text_tool->proxy, text_tool->buffer,
xres, yres);
g_object_add_weak_pointer (G_OBJECT (text_tool->editor_dialog),
(gpointer) &text_tool->editor_dialog);
gimp_dialog_factory_add_foreign (dialog_factory,
"gimp-text-tool-dialog",
text_tool->editor_dialog);
g_signal_connect (text_tool->editor_dialog, "destroy",
G_CALLBACK (gimp_text_tool_editor_destroy),
text_tool);
gtk_widget_show (text_tool->editor_dialog);
}
static void
dialogs_ensure_factory_entry_on_recent_dock (GimpSessionInfo *info)
{
if (! gimp_session_info_get_factory_entry (info))
{
GimpDialogFactoryEntry *entry = NULL;
/* The recent docks container only contains session infos for
* dock windows
*/
entry = gimp_dialog_factory_find_entry (gimp_dialog_factory_get_singleton (),
"gimp-dock-window");
gimp_session_info_set_factory_entry (info, entry);
}
}
void
palette_editor_edit_color_cmd_callback (GtkAction *action,
gpointer data)
{
GimpPaletteEditor *editor = GIMP_PALETTE_EDITOR (data);
GimpDataEditor *data_editor = GIMP_DATA_EDITOR (data);
GimpPalette *palette;
if (! (data_editor->data_editable && editor->color))
return;
palette = GIMP_PALETTE (data_editor->data);
if (! editor->color_dialog)
{
editor->color_dialog =
gimp_color_dialog_new (GIMP_VIEWABLE (palette),
data_editor->context,
_("Edit Palette Color"),
GIMP_STOCK_PALETTE,
_("Edit Color Palette Entry"),
GTK_WIDGET (editor),
gimp_dialog_factory_get_singleton (),
"gimp-palette-editor-color-dialog",
&editor->color->color,
FALSE, FALSE);
g_signal_connect (editor->color_dialog, "destroy",
G_CALLBACK (gtk_widget_destroyed),
&editor->color_dialog);
g_signal_connect (editor->color_dialog, "update",
G_CALLBACK (palette_editor_edit_color_update),
editor);
}
else
{
gimp_viewable_dialog_set_viewable (GIMP_VIEWABLE_DIALOG (editor->color_dialog),
GIMP_VIEWABLE (palette),
data_editor->context);
gimp_color_dialog_set_color (GIMP_COLOR_DIALOG (editor->color_dialog),
&editor->color->color);
}
gtk_window_present (GTK_WINDOW (editor->color_dialog));
}
void
dialogs_create_dockable_cmd_callback (GtkAction *action,
const gchar *value,
gpointer data)
{
Gimp *gimp;
GtkWidget *widget;
return_if_no_gimp (gimp, data);
return_if_no_widget (widget, data);
if (value)
gimp_window_strategy_show_dockable_dialog (GIMP_WINDOW_STRATEGY (gimp_get_window_strategy (gimp)),
gimp,
gimp_dialog_factory_get_singleton (),
gimp_widget_get_monitor (widget),
value);
}
