void
select_save_cmd_callback (GtkAction *action,
gpointer data)
{
GimpImage *image;
GtkWidget *widget;
return_if_no_image (image, data);
return_if_no_widget (widget, data);
gimp_selection_save (gimp_image_get_mask (image));
gimp_image_flush (image);
gimp_dialog_factory_dialog_raise (global_dock_factory,
gtk_widget_get_screen (widget),
"gimp-channel-list", -1);
}
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))
{
gimp_dialog_factory_dialog_raise (gimp_dialog_factory_get_singleton (),
gdk_screen_get_default (),
"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);
return FALSE; /* continue exiting */
}
void
file_close_all_cmd_callback (GtkAction *action,
gpointer data)
{
Gimp *gimp;
return_if_no_gimp (gimp, data);
if (! gimp_displays_dirty (gimp))
{
gimp_displays_close (gimp);
}
else
{
GtkWidget *widget;
return_if_no_widget (widget, data);
gimp_dialog_factory_dialog_raise (gimp_dialog_factory_get_singleton (),
gtk_widget_get_screen (widget),
"gimp-close-all-dialog", -1);
}
}
static gboolean
gui_message_error_console (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)
{
GimpSessionInfo *info;
info = gimp_dialog_factory_find_session_info (global_dock_factory,
"gimp-error-console");
if (info && GIMP_IS_DOCKABLE (info->widget))
dockable = info->widget;
}
if (! dockable)
dockable = gimp_dialog_factory_dialog_raise (global_dock_factory,
gdk_screen_get_default (),
"gimp-error-console", -1);
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;
}
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;
}
static void
gimp_color_tool_real_picked (GimpColorTool *color_tool,
GimpColorPickState pick_state,
GimpImageType sample_type,
GimpRGB *color,
gint color_index)
{
GimpTool *tool = GIMP_TOOL (color_tool);
GimpContext *context;
GimpDialogFactory *dialog_factory;
/* use this tool's own options here (NOT color_tool->options) */
context = GIMP_CONTEXT (gimp_tool_get_options (tool));
dialog_factory = gimp_dialog_factory_from_name ("dock");
if (color_tool->pick_mode == GIMP_COLOR_PICK_MODE_FOREGROUND ||
color_tool->pick_mode == GIMP_COLOR_PICK_MODE_BACKGROUND)
{
GimpSessionInfo *info;
if (GIMP_IMAGE_TYPE_IS_INDEXED (sample_type))
{
info = gimp_dialog_factory_find_session_info (dialog_factory,
"gimp-indexed-palette");
if (info && info->widget)
{
GimpColormapEditor *editor;
editor = GIMP_COLORMAP_EDITOR (gtk_bin_get_child (GTK_BIN (info->widget)));
gimp_colormap_editor_set_index (editor, color_index, NULL);
}
}
if (TRUE)
{
info = gimp_dialog_factory_find_session_info (dialog_factory,
"gimp-palette-editor");
if (info && info->widget)
{
GimpPaletteEditor *editor;
gint index;
editor = GIMP_PALETTE_EDITOR (gtk_bin_get_child (GTK_BIN (info->widget)));
index = gimp_palette_editor_get_index (editor, color);
if (index != -1)
gimp_palette_editor_set_index (editor, index, NULL);
}
}
}
switch (color_tool->pick_mode)
{
case GIMP_COLOR_PICK_MODE_NONE:
break;
case GIMP_COLOR_PICK_MODE_FOREGROUND:
gimp_context_set_foreground (context, color);
break;
case GIMP_COLOR_PICK_MODE_BACKGROUND:
gimp_context_set_background (context, color);
break;
case GIMP_COLOR_PICK_MODE_PALETTE:
{
GdkScreen *screen;
GtkWidget *dockable;
screen = gtk_widget_get_screen (tool->display->shell);
dockable = gimp_dialog_factory_dialog_raise (dialog_factory, screen,
"gimp-palette-editor",
-1);
if (dockable)
{
GtkWidget *palette_editor;
GimpData *data;
/* don't blink like mad when updating */
if (pick_state == GIMP_COLOR_PICK_STATE_UPDATE)
gimp_dockable_blink_cancel (GIMP_DOCKABLE (dockable));
palette_editor = gtk_bin_get_child (GTK_BIN (dockable));
data = gimp_data_editor_get_data (GIMP_DATA_EDITOR (palette_editor));
if (! data)
{
data = GIMP_DATA (gimp_context_get_palette (context));
gimp_data_editor_set_data (GIMP_DATA_EDITOR (palette_editor),
data);
}
gimp_palette_editor_pick_color (GIMP_PALETTE_EDITOR (palette_editor),
color, pick_state);
}
}
break;
}
}
