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); }