/**
* dialogs_restore_dialog:
* @factory:
* @screen:
* @monitor:
* @info:
*
* Creates a top level widget based on the given session info object
* in which other widgets later can be be put, typically also restored
* from the same session info object.
*
* Returns:
**/
static GtkWidget *
dialogs_restore_dialog (GimpDialogFactory *factory,
GdkScreen *screen,
gint monitor,
GimpSessionInfo *info)
{
GtkWidget *dialog;
GimpCoreConfig *config = gimp_dialog_factory_get_context (factory)->gimp->config;
GIMP_LOG (DIALOG_FACTORY, "restoring toplevel \"%s\" (info %p)",
gimp_session_info_get_factory_entry (info)->identifier,
info);
dialog =
gimp_dialog_factory_dialog_new (factory, screen, monitor,
NULL /*ui_manager*/,
gimp_session_info_get_factory_entry (info)->identifier,
gimp_session_info_get_factory_entry (info)->view_size,
! GIMP_GUI_CONFIG (config)->hide_docks);
g_object_set_data (G_OBJECT (dialog), GIMP_DIALOG_VISIBILITY_KEY,
GINT_TO_POINTER (GIMP_GUI_CONFIG (config)->hide_docks ?
GIMP_DIALOG_VISIBILITY_HIDDEN :
GIMP_DIALOG_VISIBILITY_VISIBLE));
return dialog;
}
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));
}
}
static GtkWidget *
global_error_dialog (void)
{
return gimp_dialog_factory_dialog_new (global_dialog_factory,
gdk_screen_get_default (),
"gimp-error-dialog", -1,
FALSE);
}
/**
* gimp_dock_with_window_new:
* @factory: a #GimpDialogFacotry
* @screen: the #GdkScreen the dock window should appear on
* @toolbox: if %TRUE; gives a "gimp-toolbox-window" with a
* "gimp-toolbox", "gimp-dock-window"+"gimp-dock"
* otherwise
*
* Returns: the newly created #GimpDock with the #GimpDockWindow
**/
GtkWidget *
gimp_dock_with_window_new (GimpDialogFactory *factory,
GdkScreen *screen,
gboolean toolbox)
{
GtkWidget *dock_window;
GimpDockContainer *dock_container;
GtkWidget *dock;
GimpUIManager *ui_manager;
g_return_val_if_fail (GIMP_IS_DIALOG_FACTORY (factory), NULL);
g_return_val_if_fail (GDK_IS_SCREEN (screen), NULL);
/* Create a dock window to put the dock in. We need to create the
* dock window before the dock because the dock has a dependency to
* the ui manager in the dock window
*/
dock_window = gimp_dialog_factory_dialog_new (factory, screen,
NULL /*ui_manager*/,
(toolbox ?
"gimp-toolbox-window" :
"gimp-dock-window"),
-1 /*view_size*/,
FALSE /*present*/);
dock_container = GIMP_DOCK_CONTAINER (dock_window);
ui_manager = gimp_dock_container_get_ui_manager (dock_container);
dock = gimp_dialog_factory_dialog_new (factory,
screen,
ui_manager,
(toolbox ?
"gimp-toolbox" :
"gimp-dock"),
-1 /*view_size*/,
FALSE /*present*/);
if (dock)
gimp_dock_window_add_dock (GIMP_DOCK_WINDOW (dock_window),
GIMP_DOCK (dock),
-1);
return dock;
}
void
file_open_location_cmd_callback (GtkAction *action,
gpointer data)
{
GtkWidget *widget;
return_if_no_widget (widget, data);
gimp_dialog_factory_dialog_new (global_dialog_factory,
gtk_widget_get_screen (widget),
"gimp-file-open-location-dialog", -1, TRUE);
}
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
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 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
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 GtkWidget *
file_export_dialog_show (Gimp *gimp,
GimpImage *image,
GtkWidget *parent)
{
GtkWidget *dialog;
dialog = g_object_get_data (G_OBJECT (image), "gimp-file-export-dialog");
if (! dialog)
{
dialog = gimp_dialog_factory_dialog_new (gimp_dialog_factory_get_singleton (),
gtk_widget_get_screen (parent),
NULL /*ui_manager*/,
"gimp-file-export-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-export-dialog", dialog,
(GDestroyNotify) gtk_widget_destroy);
g_signal_connect (dialog, "response",
G_CALLBACK (file_export_dialog_response),
image);
g_signal_connect (dialog, "destroy",
G_CALLBACK (file_export_dialog_destroyed),
image);
}
}
if (dialog)
{
gimp_file_dialog_set_save_image (GIMP_FILE_DIALOG (dialog),
gimp, image, FALSE, TRUE,
FALSE, NULL);
gtk_window_present (GTK_WINDOW (dialog));
}
return dialog;
}
static void
file_save_dialog_show (GimpImage *image,
GtkWidget *parent,
const gchar *title,
gboolean save_a_copy,
gboolean close_after_saving)
{
GtkWidget *dialog;
dialog = g_object_get_data (G_OBJECT (image), "gimp-file-save-dialog");
if (! dialog)
{
dialog = gimp_dialog_factory_dialog_new (global_dialog_factory,
gtk_widget_get_screen (parent),
"gimp-file-save-dialog",
-1, FALSE);
if (dialog)
{
gtk_window_set_transient_for (GTK_WINDOW (dialog),
GTK_WINDOW (parent));
g_object_set_data_full (G_OBJECT (image),
"gimp-file-save-dialog", dialog,
(GDestroyNotify) gtk_widget_destroy);
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_image (GIMP_FILE_DIALOG (dialog),
image, save_a_copy, close_after_saving);
gtk_window_present (GTK_WINDOW (dialog));
}
}
void
image_new_cmd_callback (GtkAction *action,
gpointer data)
{
GtkWidget *widget;
GtkWidget *dialog;
return_if_no_widget (widget, data);
dialog = gimp_dialog_factory_dialog_new (global_dialog_factory,
gtk_widget_get_screen (widget),
"gimp-image-new-dialog", -1, FALSE);
if (dialog)
{
GimpImage *image = action_data_get_image (data);
image_new_dialog_set (dialog, image, NULL);
gtk_window_present (GTK_WINDOW (dialog));
}
}
static void
file_open_dialog_show (GtkWidget *parent,
GimpImage *image,
const gchar *uri,
gboolean open_as_layers)
{
GtkWidget *dialog;
dialog = gimp_dialog_factory_dialog_new (global_dialog_factory,
gtk_widget_get_screen (parent),
"gimp-file-open-dialog", -1, FALSE);
if (dialog)
{
if (uri)
gtk_file_chooser_set_uri (GTK_FILE_CHOOSER (dialog), uri);
if (open_as_layers)
{
gtk_window_set_title (GTK_WINDOW (dialog), _("Open Image as Layers"));
GIMP_FILE_DIALOG (dialog)->image = image;
}
else
{
gtk_window_set_title (GTK_WINDOW (dialog), _("Open Image"));
GIMP_FILE_DIALOG (dialog)->image = NULL;
}
parent = gtk_widget_get_toplevel (parent);
if (GTK_IS_WINDOW (parent))
gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (parent));
gtk_window_present (GTK_WINDOW (dialog));
}
}
static GtkWidget *
gimp_single_window_strategy_show_dockable_dialog (GimpWindowStrategy *strategy,
Gimp *gimp,
GimpDialogFactory *factory,
GdkMonitor *monitor,
const gchar *identifiers)
{
GList *windows = gimp_get_image_windows (gimp);
GtkWidget *widget = NULL;
GimpImageWindow *window;
g_return_val_if_fail (windows != NULL, NULL);
/* In single-window mode, there should only be one window... */
window = GIMP_IMAGE_WINDOW (windows->data);
if (strcmp ("gimp-toolbox", identifiers) == 0)
{
/* Only allow one toolbox... */
if (! gimp_image_window_has_toolbox (window))
{
GimpDockColumns *columns;
GimpUIManager *ui_manager = gimp_image_window_get_ui_manager (window);
widget = gimp_dialog_factory_dialog_new (factory, monitor,
ui_manager,
GTK_WIDGET (window),
"gimp-toolbox",
-1 /*view_size*/,
FALSE /*present*/);
gtk_widget_show (widget);
columns = gimp_image_window_get_left_docks (window);
gimp_dock_columns_add_dock (columns,
GIMP_DOCK (widget),
-1 /*index*/);
}
}
else if (gimp_dialog_factory_find_widget (factory, identifiers))
{
/* if the dialog is already open, simply raise it */
return gimp_dialog_factory_dialog_raise (factory, monitor,
GTK_WIDGET (window),
identifiers, -1);
}
else
{
GtkWidget *dockbook;
dockbook = gimp_image_window_get_default_dockbook (window);
if (! dockbook)
{
GimpDockColumns *dock_columns;
/* No dock, need to add one */
dock_columns = gimp_image_window_get_right_docks (window);
gimp_dock_columns_prepare_dockbook (dock_columns,
-1 /*index*/,
&dockbook);
}
widget = gimp_dockbook_add_from_dialog_factory (GIMP_DOCKBOOK (dockbook),
identifiers);
}
g_list_free (windows);
return widget;
}
GimpDock *
gimp_session_info_dock_restore (GimpSessionInfoDock *dock_info,
GimpDialogFactory *factory,
GdkScreen *screen,
gint monitor,
GimpDockContainer *dock_container)
{
gint n_books = 0;
GtkWidget *dock;
GList *iter;
GimpUIManager *ui_manager;
g_return_val_if_fail (GIMP_IS_DIALOG_FACTORY (factory), NULL);
g_return_val_if_fail (GDK_IS_SCREEN (screen), NULL);
ui_manager = gimp_dock_container_get_ui_manager (dock_container);
dock = gimp_dialog_factory_dialog_new (factory,
screen,
monitor,
ui_manager,
dock_info->dock_type,
-1 /*view_size*/,
FALSE /*present*/);
g_return_val_if_fail (GIMP_IS_DOCK (dock), NULL);
/* Add the dock to the dock window immediately so the stuff in the
* dock has access to e.g. a dialog factory
*/
gimp_dock_container_add_dock (dock_container,
GIMP_DOCK (dock),
dock_info);
/* Note that if it is a toolbox, we will get here even though we
* don't have any books
*/
for (iter = dock_info->books;
iter;
iter = g_list_next (iter))
{
GimpSessionInfoBook *book_info = iter->data;
GtkWidget *dockbook;
dockbook = GTK_WIDGET (gimp_session_info_book_restore (book_info,
GIMP_DOCK (dock)));
if (dockbook)
{
GtkWidget *parent = gtk_widget_get_parent (dockbook);
n_books++;
if (GTK_IS_PANED (parent))
{
GtkPaned *paned = GTK_PANED (parent);
if (dockbook == gtk_paned_get_child2 (paned))
gtk_paned_set_position (paned, book_info->position);
}
}
}
/* Now remove empty dockbooks from the list, check the comment in
* gimp_session_info_book_restore() which explains why the dock
* can contain empty dockbooks at all
*/
if (dock_info->books)
{
GList *books;
books = g_list_copy (gimp_dock_get_dockbooks (GIMP_DOCK (dock)));
while (books)
{
GtkContainer *dockbook = books->data;
GList *children = gtk_container_get_children (dockbook);
if (children)
{
g_list_free (children);
}
else
{
g_object_ref (dockbook);
gimp_dock_remove_book (GIMP_DOCK (dock), GIMP_DOCKBOOK (dockbook));
gtk_widget_destroy (GTK_WIDGET (dockbook));
g_object_unref (dockbook);
n_books--;
}
books = g_list_remove (books, dockbook);
}
}
/* if we removed all books again, the dock was destroyed, so bail out */
if (dock_info->books && n_books == 0)
{
return NULL;
}
gtk_widget_show (dock);
return GIMP_DOCK (dock);
}
