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