static void
gimp_container_popup_dialog_clicked (GtkWidget *button,
GimpContainerPopup *popup)
{
gimp_window_strategy_show_dockable_dialog (GIMP_WINDOW_STRATEGY (gimp_get_window_strategy (popup->context->gimp)),
popup->context->gimp,
popup->dialog_factory,
gtk_widget_get_screen (button),
gimp_widget_get_monitor (button),
popup->dialog_identifier);
g_signal_emit_by_name (popup, "confirm");
}
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 void
image_preview_clicked (GtkWidget *widget,
GdkModifierType state,
GimpToolbox *toolbox)
{
GimpContext *context = gimp_toolbox_get_context (toolbox);
gimp_window_strategy_show_dockable_dialog (GIMP_WINDOW_STRATEGY (gimp_get_window_strategy (context->gimp)),
context->gimp,
gimp_dock_get_dialog_factory (GIMP_DOCK (toolbox)),
gimp_widget_get_monitor (widget),
"gimp-image-list|gimp-image-grid");
}
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);
}
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);
}
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_widget_get_monitor (widget),
"gimp-buffer-list|gimp-buffer-grid");
}
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_widget_get_monitor (GTK_WIDGET (shell)),
"gimp-navigation-view");
}
void
view_new_cmd_callback (GtkAction *action,
gpointer data)
{
GimpDisplay *display;
GimpDisplayShell *shell;
return_if_no_display (display, data);
shell = gimp_display_get_shell (display);
gimp_create_display (display->gimp,
gimp_display_get_image (display),
shell->unit, gimp_zoom_model_get_factor (shell->zoom),
G_OBJECT (gtk_widget_get_screen (GTK_WIDGET (shell))),
gimp_widget_get_monitor (GTK_WIDGET (shell)));
}
static gboolean
track_monitor_configure_event (GtkWidget *toplevel,
GdkEvent *event,
TrackMonitorData *track_data)
{
gint monitor = gimp_widget_get_monitor (toplevel);
if (monitor != track_data->monitor)
{
track_data->monitor = monitor;
track_data->callback (track_data->widget, track_data->user_data);
}
return FALSE;
}
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);
}
static void
tool_options_show_preset_editor (Gimp *gimp,
GimpEditor *editor,
GimpToolPreset *preset)
{
GtkWidget *dockable;
dockable =
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 (editor)),
gimp_widget_get_monitor (GTK_WIDGET (editor)),
"gimp-tool-preset-editor");
gimp_data_editor_set_data (GIMP_DATA_EDITOR (gtk_bin_get_child (GTK_BIN (dockable))),
GIMP_DATA (preset));
}
GimpColorProfile *
gimp_widget_get_color_profile (GtkWidget *widget)
{
GdkMonitor *monitor;
g_return_val_if_fail (widget == NULL || GTK_IS_WIDGET (widget), NULL);
if (widget)
{
monitor = gimp_widget_get_monitor (widget);
}
else
{
monitor = gdk_display_get_monitor (gdk_display_get_default (), 0);
}
return gimp_monitor_get_color_profile (monitor);
}
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_SELECTION (gimp_image_get_mask (image)));
gimp_image_flush (image);
gimp_window_strategy_show_dockable_dialog (GIMP_WINDOW_STRATEGY (gimp_get_window_strategy (image->gimp)),
image->gimp,
gimp_dialog_factory_get_singleton (),
gtk_widget_get_screen (widget),
gimp_widget_get_monitor (widget),
"gimp-channel-list");
}
static void
gimp_toolbox_drop_drawable (GtkWidget *widget,
gint x,
gint y,
GimpViewable *viewable,
gpointer data)
{
GimpContext *context = GIMP_CONTEXT (data);
GimpImage *new_image;
if (context->gimp->busy)
return;
new_image = gimp_image_new_from_drawable (context->gimp,
GIMP_DRAWABLE (viewable));
gimp_create_display (context->gimp, new_image, GIMP_UNIT_PIXEL, 1.0,
G_OBJECT (gtk_widget_get_screen (widget)),
gimp_widget_get_monitor (widget));
g_object_unref (new_image);
}
static void
gimp_toolbox_drop_buffer (GtkWidget *widget,
gint x,
gint y,
GimpViewable *viewable,
gpointer data)
{
GimpContext *context = GIMP_CONTEXT (data);
GimpImage *image;
if (context->gimp->busy)
return;
image = gimp_image_new_from_buffer (context->gimp, NULL,
GIMP_BUFFER (viewable));
gimp_create_display (image->gimp, image, GIMP_UNIT_PIXEL, 1.0,
G_OBJECT (gtk_widget_get_screen (widget)),
gimp_widget_get_monitor (widget));
g_object_unref (image);
}
static void
gimp_toolbox_drop_pixbuf (GtkWidget *widget,
gint x,
gint y,
GdkPixbuf *pixbuf,
gpointer data)
{
GimpContext *context = GIMP_CONTEXT (data);
GimpImage *new_image;
if (context->gimp->busy)
return;
new_image = gimp_image_new_from_pixbuf (context->gimp, pixbuf,
_("Dropped Buffer"));
gimp_create_display (new_image->gimp, new_image, GIMP_UNIT_PIXEL, 1.0,
G_OBJECT (gtk_widget_get_screen (widget)),
gimp_widget_get_monitor (widget));
g_object_unref (new_image);
}
void
images_new_view_cmd_callback (GtkAction *action,
gpointer data)
{
GimpContainerEditor *editor = GIMP_CONTAINER_EDITOR (data);
GimpContainer *container;
GimpContext *context;
GimpImage *image;
container = gimp_container_view_get_container (editor->view);
context = gimp_container_view_get_context (editor->view);
image = gimp_context_get_image (context);
if (image && gimp_container_have (container, GIMP_OBJECT (image)))
{
gimp_create_display (image->gimp, image, GIMP_UNIT_PIXEL, 1.0,
G_OBJECT (gtk_widget_get_screen (GTK_WIDGET (editor))),
gimp_widget_get_monitor (GTK_WIDGET (editor)));
}
}
static void
gimp_toolbox_drop_component (GtkWidget *widget,
gint x,
gint y,
GimpImage *image,
GimpChannelType component,
gpointer data)
{
GimpContext *context = GIMP_CONTEXT (data);
GimpImage *new_image;
if (context->gimp->busy)
return;
new_image = gimp_image_new_from_component (context->gimp,
image, component);
gimp_create_display (new_image->gimp, new_image, GIMP_UNIT_PIXEL, 1.0,
G_OBJECT (gtk_widget_get_screen (widget)),
gimp_widget_get_monitor (widget));
g_object_unref (new_image);
}
static void
gimp_toolbox_drop_uri_list (GtkWidget *widget,
gint x,
gint y,
GList *uri_list,
gpointer data)
{
GimpContext *context = GIMP_CONTEXT (data);
GList *list;
if (context->gimp->busy)
return;
for (list = uri_list; list; list = g_list_next (list))
{
GFile *file = g_file_new_for_uri (list->data);
GimpImage *image;
GimpPDBStatusType status;
GError *error = NULL;
image = file_open_with_display (context->gimp, context, NULL,
file, FALSE,
G_OBJECT (gtk_widget_get_screen (widget)),
gimp_widget_get_monitor (widget),
&status, &error);
if (! image && status != GIMP_PDB_CANCEL)
{
gimp_message (context->gimp, G_OBJECT (widget), GIMP_MESSAGE_ERROR,
_("Opening '%s' failed:\n\n%s"),
gimp_file_get_utf8_name (file), error->message);
g_clear_error (&error);
}
g_object_unref (file);
}
}
static void
track_monitor_hierarchy_changed (GtkWidget *widget,
GtkWidget *previous_toplevel,
TrackMonitorData *track_data)
{
GtkWidget *toplevel;
if (previous_toplevel)
{
g_signal_handlers_disconnect_by_func (previous_toplevel,
track_monitor_configure_event,
track_data);
}
toplevel = gtk_widget_get_toplevel (widget);
if (GTK_IS_WINDOW (toplevel))
{
GClosure *closure;
gint monitor;
closure = g_cclosure_new (G_CALLBACK (track_monitor_configure_event),
track_data, NULL);
g_object_watch_closure (G_OBJECT (widget), closure);
g_signal_connect_closure (toplevel, "configure-event", closure, FALSE);
monitor = gimp_widget_get_monitor (toplevel);
if (monitor != track_data->monitor)
{
track_data->monitor = monitor;
track_data->callback (track_data->widget, track_data->user_data);
}
}
}
GimpColorProfile *
gimp_widget_get_color_profile (GtkWidget *widget)
{
GimpColorProfile *profile = NULL;
GdkScreen *screen;
gint monitor;
g_return_val_if_fail (widget == NULL || GTK_IS_WIDGET (widget), NULL);
if (widget)
{
screen = gtk_widget_get_screen (widget);
monitor = gimp_widget_get_monitor (widget);
}
else
{
screen = gdk_screen_get_default ();
monitor = 0;
}
#if defined GDK_WINDOWING_X11
{
GdkAtom type = GDK_NONE;
gint format = 0;
gint nitems = 0;
gchar *atom_name;
guchar *data = NULL;
if (monitor > 0)
atom_name = g_strdup_printf ("_ICC_PROFILE_%d", monitor);
else
atom_name = g_strdup ("_ICC_PROFILE");
if (gdk_property_get (gdk_screen_get_root_window (screen),
gdk_atom_intern (atom_name, FALSE),
GDK_NONE,
0, 64 * 1024 * 1024, FALSE,
&type, &format, &nitems, &data) && nitems > 0)
{
profile = gimp_color_profile_new_from_icc_profile (data, nitems,
NULL);
g_free (data);
}
g_free (atom_name);
}
#elif defined GDK_WINDOWING_QUARTZ
{
CMProfileRef prof = NULL;
CMGetProfileByAVID (monitor, &prof);
if (prof)
{
CFDataRef data;
data = CMProfileCopyICCData (NULL, prof);
CMCloseProfile (prof);
if (data)
{
UInt8 *buffer = g_malloc (CFDataGetLength (data));
/* We cannot use CFDataGetBytesPtr(), because that returns
* a const pointer where cmsOpenProfileFromMem wants a
* non-const pointer.
*/
CFDataGetBytes (data, CFRangeMake (0, CFDataGetLength (data)),
buffer);
profile = gimp_color_profile_new_from_icc_profile (data,
CFDataGetLength (data),
NULL);
g_free (buffer);
CFRelease (data);
}
}
}
#elif defined G_OS_WIN32
{
HDC hdc = GetDC (NULL);
if (hdc)
{
gchar *path;
gint32 len = 0;
GetICMProfile (hdc, &len, NULL);
path = g_new (gchar, len);
if (GetICMProfile (hdc, &len, path))
{
GFile *file = g_file_new_for_path (path);
profile = gimp_color_profile_new_from_file (file, NULL);
g_object_unref (file);
}
g_free (path);
ReleaseDC (NULL, hdc);
}
}
#endif
return profile;
}
static void
gimp_color_tool_real_picked (GimpColorTool *color_tool,
GimpColorPickState pick_state,
gdouble x,
gdouble y,
const Babl *sample_format,
const GimpRGB *color,
gint color_index)
{
GimpTool *tool = GIMP_TOOL (color_tool);
GimpContext *context;
/* use this tool's own options here (NOT color_tool->options) */
context = GIMP_CONTEXT (gimp_tool_get_options (tool));
if (color_tool->pick_mode == GIMP_COLOR_PICK_MODE_FOREGROUND ||
color_tool->pick_mode == GIMP_COLOR_PICK_MODE_BACKGROUND)
{
GtkWidget *widget;
if (babl_format_is_palette (sample_format))
{
widget = gimp_dialog_factory_find_widget (gimp_dialog_factory_get_singleton (),
"gimp-indexed-palette");
if (widget)
{
GimpColormapEditor *editor;
editor = GIMP_COLORMAP_EDITOR (gtk_bin_get_child (GTK_BIN (widget)));
gimp_colormap_editor_set_index (editor, color_index, NULL);
}
}
if (TRUE)
{
widget = gimp_dialog_factory_find_widget (gimp_dialog_factory_get_singleton (),
"gimp-palette-editor");
if (widget)
{
GimpPaletteEditor *editor;
gint index;
editor = GIMP_PALETTE_EDITOR (gtk_bin_get_child (GTK_BIN (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:
{
GimpDisplayShell *shell = gimp_display_get_shell (tool->display);
GdkScreen *screen = gtk_widget_get_screen (GTK_WIDGET (shell));
gint monitor = gimp_widget_get_monitor (GTK_WIDGET (shell));
GtkWidget *dockable;
dockable =
gimp_window_strategy_show_dockable_dialog (GIMP_WINDOW_STRATEGY (gimp_get_window_strategy (tool->display->gimp)),
tool->display->gimp,
gimp_dialog_factory_get_singleton (),
screen,
monitor,
"gimp-palette-editor");
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;
}
}
static void
gimp_display_shell_drop_buffer (GtkWidget *widget,
gint drop_x,
gint drop_y,
GimpViewable *viewable,
gpointer data)
{
GimpDisplayShell *shell = GIMP_DISPLAY_SHELL (data);
GimpImage *image = gimp_display_get_image (shell->display);
GimpDrawable *drawable;
GimpBuffer *buffer;
gint x, y, width, height;
GIMP_LOG (DND, NULL);
if (shell->display->gimp->busy)
return;
if (! image)
{
image = gimp_image_new_from_buffer (shell->display->gimp, NULL,
GIMP_BUFFER (viewable));
gimp_create_display (image->gimp, image, GIMP_UNIT_PIXEL, 1.0,
G_OBJECT (gtk_widget_get_screen (widget)),
gimp_widget_get_monitor (widget));
g_object_unref (image);
return;
}
drawable = gimp_image_get_active_drawable (image);
if (drawable)
{
if (gimp_viewable_get_children (GIMP_VIEWABLE (drawable)))
{
gimp_message_literal (shell->display->gimp, G_OBJECT (shell->display),
GIMP_MESSAGE_ERROR,
_("Cannot modify the pixels of layer groups."));
return;
}
if (gimp_item_is_content_locked (GIMP_ITEM (drawable)))
{
gimp_message_literal (shell->display->gimp, G_OBJECT (shell->display),
GIMP_MESSAGE_ERROR,
_("The active layer's pixels are locked."));
return;
}
}
buffer = GIMP_BUFFER (viewable);
gimp_display_shell_untransform_viewport (shell, &x, &y, &width, &height);
/* FIXME: popup a menu for selecting "Paste Into" */
gimp_edit_paste (image, drawable, buffer, FALSE,
x, y, width, height);
gimp_display_shell_dnd_flush (shell, image);
}
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,
gtk_widget_get_screen (button),
gimp_widget_get_monitor (button));
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
gimp_display_shell_drop_buffer (GtkWidget *widget,
gint drop_x,
gint drop_y,
GimpViewable *viewable,
gpointer data)
{
GimpDisplayShell *shell = GIMP_DISPLAY_SHELL (data);
GimpImage *image = gimp_display_get_image (shell->display);
GimpDrawable *drawable;
GimpBuffer *buffer;
GimpPasteType paste_type;
gint x, y, width, height;
GIMP_LOG (DND, NULL);
if (shell->display->gimp->busy)
return;
if (! image)
{
image = gimp_image_new_from_buffer (shell->display->gimp, NULL,
GIMP_BUFFER (viewable));
gimp_create_display (image->gimp, image, GIMP_UNIT_PIXEL, 1.0,
G_OBJECT (gtk_widget_get_screen (widget)),
gimp_widget_get_monitor (widget));
g_object_unref (image);
return;
}
paste_type = GIMP_PASTE_TYPE_FLOATING;
drawable = gimp_image_get_active_drawable (image);
if (drawable)
{
if (gimp_viewable_get_children (GIMP_VIEWABLE (drawable)))
{
gimp_message_literal (shell->display->gimp, G_OBJECT (shell->display),
GIMP_MESSAGE_INFO,
_("Pasted as new layer because the "
"target is a layer group."));
paste_type = GIMP_PASTE_TYPE_NEW_LAYER;
}
else if (gimp_item_is_content_locked (GIMP_ITEM (drawable)))
{
gimp_message_literal (shell->display->gimp, G_OBJECT (shell->display),
GIMP_MESSAGE_ERROR,
_("Pasted as new layer because the "
"target's pixels are locked."));
paste_type = GIMP_PASTE_TYPE_NEW_LAYER;
}
}
buffer = GIMP_BUFFER (viewable);
gimp_display_shell_untransform_viewport (shell, &x, &y, &width, &height);
/* FIXME: popup a menu for selecting "Paste Into" */
gimp_edit_paste (image, drawable, GIMP_OBJECT (buffer),
paste_type, x, y, width, height);
gimp_display_shell_dnd_flush (shell, image);
}
static void
gimp_display_shell_drop_uri_list (GtkWidget *widget,
gint x,
gint y,
GList *uri_list,
gpointer data)
{
GimpDisplayShell *shell = GIMP_DISPLAY_SHELL (data);
GimpImage *image;
GimpContext *context;
GList *list;
gboolean open_as_layers;
/* If the app is already being torn down, shell->display might be NULL here.
* Play it safe. */
if (! shell->display)
{
return;
}
image = gimp_display_get_image (shell->display);
context = gimp_get_user_context (shell->display->gimp);
GIMP_LOG (DND, NULL);
open_as_layers = (image != NULL);
for (list = uri_list; list; list = g_list_next (list))
{
GFile *file = g_file_new_for_uri (list->data);
GimpPDBStatusType status;
GError *error = NULL;
gboolean warn = FALSE;
if (! shell->display)
{
/* It seems as if GIMP is being torn down for quitting. Bail out. */
g_object_unref (file);
return;
}
if (open_as_layers)
{
GList *new_layers;
new_layers = file_open_layers (shell->display->gimp, context,
GIMP_PROGRESS (shell->display),
image, FALSE,
file, GIMP_RUN_INTERACTIVE, NULL,
&status, &error);
if (new_layers)
{
gint x, y;
gint width, height;
gimp_display_shell_untransform_viewport (shell, &x, &y,
&width, &height);
gimp_image_add_layers (image, new_layers,
GIMP_IMAGE_ACTIVE_PARENT, -1,
x, y, width, height,
_("Drop layers"));
g_list_free (new_layers);
}
else if (status != GIMP_PDB_CANCEL)
{
warn = TRUE;
}
}
else if (gimp_display_get_image (shell->display))
{
/* open any subsequent images in a new display */
GimpImage *new_image;
new_image = file_open_with_display (shell->display->gimp, context,
NULL,
file, FALSE,
G_OBJECT (gtk_widget_get_screen (widget)),
gimp_widget_get_monitor (widget),
&status, &error);
if (! new_image && status != GIMP_PDB_CANCEL)
warn = TRUE;
}
else
{
/* open the first image in the empty display */
image = file_open_with_display (shell->display->gimp, context,
GIMP_PROGRESS (shell->display),
file, FALSE,
G_OBJECT (gtk_widget_get_screen (widget)),
gimp_widget_get_monitor (widget),
&status, &error);
if (! image && status != GIMP_PDB_CANCEL)
warn = TRUE;
}
/* Something above might have run a few rounds of the main loop. Check
* that shell->display is still there, otherwise ignore this as the app
* is being torn down for quitting. */
if (warn && shell->display)
{
gimp_message (shell->display->gimp, G_OBJECT (shell->display),
GIMP_MESSAGE_ERROR,
_("Opening '%s' failed:\n\n%s"),
gimp_file_get_utf8_name (file), error->message);
g_clear_error (&error);
}
g_object_unref (file);
}
if (image)
gimp_display_shell_dnd_flush (shell, image);
}
static void
file_open_location_response (GtkDialog *dialog,
gint response_id,
Gimp *gimp)
{
GtkWidget *entry;
GtkWidget *box;
const gchar *text = NULL;
if (response_id != GTK_RESPONSE_OK)
{
box = g_object_get_data (G_OBJECT (dialog), "progress-box");
if (box && GIMP_PROGRESS_BOX (box)->active)
gimp_progress_cancel (GIMP_PROGRESS (box));
else
gtk_widget_destroy (GTK_WIDGET (dialog));
return;
}
entry = g_object_get_data (G_OBJECT (dialog), "location-entry");
gtk_editable_set_editable (GTK_EDITABLE (entry), FALSE);
gtk_dialog_set_response_sensitive (dialog, GTK_RESPONSE_OK, FALSE);
text = gtk_entry_get_text (GTK_ENTRY (entry));
if (text && strlen (text))
{
GimpImage *image;
gchar *filename;
GFile *file;
GimpPDBStatusType status;
GError *error = NULL;
filename = g_filename_from_uri (text, NULL, NULL);
if (filename)
{
file = g_file_new_for_uri (text);
g_free (filename);
}
else
{
file = file_utils_filename_to_file (gimp, text, &error);
}
box = gimp_progress_box_new ();
gtk_container_set_border_width (GTK_CONTAINER (box), 12);
gtk_box_pack_end (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))),
box, FALSE, FALSE, 0);
g_object_set_data (G_OBJECT (dialog), "progress-box", box);
if (file)
{
GFile *entered_file = g_file_new_for_uri (text);
gtk_widget_show (box);
image = file_open_with_proc_and_display (gimp,
gimp_get_user_context (gimp),
GIMP_PROGRESS (box),
file, entered_file,
FALSE, NULL,
G_OBJECT (gtk_widget_get_screen (entry)),
gimp_widget_get_monitor (entry),
&status, &error);
g_object_unref (entered_file);
if (image == NULL && status != GIMP_PDB_CANCEL)
{
gimp_message (gimp, G_OBJECT (box), GIMP_MESSAGE_ERROR,
_("Opening '%s' failed:\n\n%s"),
gimp_file_get_utf8_name (file), error->message);
g_clear_error (&error);
}
g_object_unref (file);
}
else
{
gimp_message (gimp, G_OBJECT (box), GIMP_MESSAGE_ERROR,
_("Opening '%s' failed:\n\n%s"),
text, error->message);
g_clear_error (&error);
gtk_dialog_set_response_sensitive (dialog, GTK_RESPONSE_OK, TRUE);
gtk_editable_set_editable (GTK_EDITABLE (entry), TRUE);
return;
}
}
gtk_widget_destroy (GTK_WIDGET (dialog));
}
static gboolean
gimp_image_map_tool_initialize (GimpTool *tool,
GimpDisplay *display,
GError **error)
{
GimpImageMapTool *im_tool = GIMP_IMAGE_MAP_TOOL (tool);
GimpToolInfo *tool_info = tool->tool_info;
GimpImage *image = gimp_display_get_image (display);
GimpDrawable *drawable = gimp_image_get_active_drawable (image);
GimpDisplayShell *shell = gimp_display_get_shell (display);
if (! drawable)
return FALSE;
if (gimp_viewable_get_children (GIMP_VIEWABLE (drawable)))
{
g_set_error_literal (error, GIMP_ERROR, GIMP_FAILED,
_("Cannot modify the pixels of layer groups."));
return FALSE;
}
if (gimp_item_is_content_locked (GIMP_ITEM (drawable)))
{
g_set_error_literal (error, GIMP_ERROR, GIMP_FAILED,
_("The active layer's pixels are locked."));
return FALSE;
}
if (! gimp_item_is_visible (GIMP_ITEM (drawable)))
{
g_set_error_literal (error, GIMP_ERROR, GIMP_FAILED,
_("The active layer is not visible."));
return FALSE;
}
if (im_tool->active_picker)
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (im_tool->active_picker),
FALSE);
/* set display so the dialog can be hidden on display destruction */
tool->display = display;
if (im_tool->config)
gimp_config_reset (GIMP_CONFIG (im_tool->config));
if (! im_tool->gui)
{
GimpImageMapToolClass *klass = GIMP_IMAGE_MAP_TOOL_GET_CLASS (im_tool);
GtkWidget *vbox;
GtkWidget *hbox;
GtkWidget *toggle;
gchar *operation_name;
/* disabled for at least GIMP 2.8 */
im_tool->overlay = FALSE;
im_tool->gui =
gimp_tool_gui_new (tool_info,
im_tool->title,
im_tool->description,
im_tool->icon_name,
im_tool->help_id,
gtk_widget_get_screen (GTK_WIDGET (shell)),
gimp_widget_get_monitor (GTK_WIDGET (shell)),
im_tool->overlay,
GIMP_STOCK_RESET, RESPONSE_RESET,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OK, GTK_RESPONSE_OK,
NULL);
gimp_tool_gui_set_default_response (im_tool->gui, GTK_RESPONSE_OK);
gimp_tool_gui_set_alternative_button_order (im_tool->gui,
RESPONSE_RESET,
GTK_RESPONSE_OK,
GTK_RESPONSE_CANCEL,
-1);
vbox = gimp_tool_gui_get_vbox (im_tool->gui);
g_signal_connect_object (im_tool->gui, "response",
G_CALLBACK (gimp_image_map_tool_response),
G_OBJECT (im_tool), 0);
if (im_tool->config && klass->settings_name)
{
GType type = G_TYPE_FROM_INSTANCE (im_tool->config);
GimpContainer *settings;
GFile *settings_file;
GFile *default_folder;
GtkWidget *settings_ui;
settings = gimp_gegl_config_get_container (type);
if (! gimp_list_get_sort_func (GIMP_LIST (settings)))
gimp_list_set_sort_func (GIMP_LIST (settings),
(GCompareFunc) gimp_settings_compare);
settings_file = gimp_tool_info_get_options_file (tool_info,
".settings");
default_folder = gimp_directory_file (klass->settings_name, NULL);
settings_ui = klass->get_settings_ui (im_tool,
settings,
settings_file,
klass->import_dialog_title,
klass->export_dialog_title,
im_tool->help_id,
default_folder,
&im_tool->settings_box);
g_object_unref (default_folder);
g_object_unref (settings_file);
gtk_box_pack_start (GTK_BOX (vbox), settings_ui, FALSE, FALSE, 0);
gtk_widget_show (settings_ui);
}
/* The gamma hack toggle */
toggle = gtk_check_button_new_with_label ("Gamma hack (temp hack, please ignore)");
gtk_box_pack_end (GTK_BOX (vbox), toggle, FALSE, FALSE, 0);
gtk_widget_show (toggle);
g_signal_connect (toggle, "toggled",
G_CALLBACK (gamma_hack),
im_tool);
/* The preview and split view toggles */
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 4);
gtk_box_pack_end (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
gtk_widget_show (hbox);
toggle = gimp_prop_check_button_new (G_OBJECT (tool_info->tool_options),
"preview", NULL);
gtk_box_pack_start (GTK_BOX (hbox), toggle, TRUE, TRUE, 0);
gtk_widget_show (toggle);
toggle = gimp_prop_check_button_new (G_OBJECT (tool_info->tool_options),
"preview-split", NULL);
gtk_box_pack_start (GTK_BOX (hbox), toggle, FALSE, FALSE, 0);
gtk_widget_show (toggle);
g_object_bind_property (G_OBJECT (tool_info->tool_options), "preview",
toggle, "sensitive",
G_BINDING_SYNC_CREATE);
/* The area combo */
gegl_node_get (im_tool->operation,
"operation", &operation_name,
NULL);
im_tool->region_combo =
gimp_prop_enum_combo_box_new (G_OBJECT (tool_info->tool_options),
"region",
0, 0);
gtk_box_pack_end (GTK_BOX (vbox), im_tool->region_combo,
FALSE, FALSE, 0);
if (operation_name &&
gegl_operation_get_key (operation_name, "position-dependent"))
{
gtk_widget_show (im_tool->region_combo);
}
g_free (operation_name);
/* Fill in subclass widgets */
gimp_image_map_tool_dialog (im_tool);
}
else
{
gimp_tool_gui_set_title (im_tool->gui, im_tool->title);
gimp_tool_gui_set_description (im_tool->gui, im_tool->description);
gimp_tool_gui_set_icon_name (im_tool->gui, im_tool->icon_name);
gimp_tool_gui_set_help_id (im_tool->gui, im_tool->help_id);
}
gimp_tool_gui_set_shell (im_tool->gui, shell);
gimp_tool_gui_set_viewable (im_tool->gui, GIMP_VIEWABLE (drawable));
gimp_tool_gui_show (im_tool->gui);
im_tool->drawable = drawable;
gimp_image_map_tool_create_map (im_tool);
gimp_image_map_tool_preview (im_tool);
return TRUE;
}
static void
gimp_operation_tool_add_gui (GimpOperationTool *op_tool)
{
GtkSizeGroup *size_group = NULL;
GtkWidget *options_gui;
GtkWidget *options_box;
GtkWidget *options_sw;
GtkWidget *shell;
GdkRectangle workarea;
GtkRequisition minimum;
GList *list;
gboolean scrolling;
options_gui = g_weak_ref_get (&op_tool->options_gui_ref);
options_box = g_weak_ref_get (&op_tool->options_box_ref);
options_sw = g_weak_ref_get (&op_tool->options_sw_ref);
g_return_if_fail (options_gui && options_box && options_sw);
for (list = op_tool->aux_inputs; list; list = g_list_next (list))
{
AuxInput *input = list->data;
GtkWidget *toggle;
if (! size_group)
size_group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
toggle =
gimp_buffer_source_box_get_toggle (GIMP_BUFFER_SOURCE_BOX (input->box));
gtk_size_group_add_widget (size_group, toggle);
gtk_box_pack_start (GTK_BOX (options_box), input->box,
FALSE, FALSE, 0);
gtk_widget_show (input->box);
}
if (size_group)
g_object_unref (size_group);
gtk_box_pack_start (GTK_BOX (options_box), options_gui, TRUE, TRUE, 0);
gtk_widget_show (options_gui);
shell = GTK_WIDGET (gimp_display_get_shell (GIMP_TOOL (op_tool)->display));
gdk_monitor_get_workarea (gimp_widget_get_monitor (shell), &workarea);
gtk_widget_get_preferred_size (options_box, &minimum, NULL);
scrolling = minimum.height > workarea.height / 2;
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (options_sw),
GTK_POLICY_NEVER,
scrolling ?
GTK_POLICY_AUTOMATIC : GTK_POLICY_NEVER);
if (scrolling)
gtk_widget_set_size_request (options_sw, -1, workarea.height / 2);
else
gtk_widget_set_size_request (options_sw, -1, -1);
g_object_unref (options_gui);
g_object_unref (options_box);
g_object_unref (options_sw);
}
static void
gimp_color_picker_tool_info_create (GimpColorPickerTool *picker_tool)
{
GimpTool *tool = GIMP_TOOL (picker_tool);
GimpDisplayShell *shell;
GtkWidget *hbox;
GtkWidget *frame;
GimpRGB color;
g_return_if_fail (tool->display != NULL);
g_return_if_fail (tool->drawable != NULL);
shell = gimp_display_get_shell (tool->display);
picker_tool->gui = gimp_tool_gui_new (tool->tool_info,
_("Color Picker Information"),
gtk_widget_get_screen (GTK_WIDGET (shell)),
gimp_widget_get_monitor (GTK_WIDGET (shell)),
TRUE,
GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE,
NULL);
gimp_tool_gui_set_auto_overlay (picker_tool->gui, TRUE);
gimp_tool_gui_set_focus_on_map (picker_tool->gui, FALSE);
gimp_tool_gui_set_viewable (picker_tool->gui,
GIMP_VIEWABLE (tool->drawable));
g_signal_connect (picker_tool->gui, "response",
G_CALLBACK (gimp_color_picker_tool_info_response),
picker_tool);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
gtk_box_pack_start (GTK_BOX (gimp_tool_gui_get_vbox (picker_tool->gui)),
hbox, FALSE, FALSE, 0);
gtk_widget_show (hbox);
picker_tool->color_frame1 = gimp_color_frame_new ();
gimp_color_frame_set_mode (GIMP_COLOR_FRAME (picker_tool->color_frame1),
GIMP_COLOR_FRAME_MODE_PIXEL);
gtk_box_pack_start (GTK_BOX (hbox), picker_tool->color_frame1,
FALSE, FALSE, 0);
gtk_widget_show (picker_tool->color_frame1);
picker_tool->color_frame2 = gimp_color_frame_new ();
gimp_color_frame_set_mode (GIMP_COLOR_FRAME (picker_tool->color_frame2),
GIMP_COLOR_FRAME_MODE_RGB);
gtk_box_pack_start (GTK_BOX (hbox), picker_tool->color_frame2,
FALSE, FALSE, 0);
gtk_widget_show (picker_tool->color_frame2);
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
gtk_box_pack_start (GTK_BOX (hbox), frame, TRUE, TRUE, 0);
gtk_widget_show (frame);
gimp_rgba_set (&color, 0.0, 0.0, 0.0, 0.0);
picker_tool->color_area =
gimp_color_area_new (&color,
gimp_drawable_has_alpha (tool->drawable) ?
GIMP_COLOR_AREA_LARGE_CHECKS :
GIMP_COLOR_AREA_FLAT,
GDK_BUTTON1_MASK | GDK_BUTTON2_MASK);
gtk_widget_set_size_request (picker_tool->color_area, 48, -1);
gtk_drag_dest_unset (picker_tool->color_area);
gtk_container_add (GTK_CONTAINER (frame), picker_tool->color_area);
gtk_widget_show (picker_tool->color_area);
}