static void select_grow_callback (GtkWidget *widget, gdouble size, GimpUnit unit, gpointer data) { GimpImage *image = GIMP_IMAGE (data); gdouble radius_x; gdouble radius_y; radius_x = radius_y = select_grow_pixels = ROUND (size); if (unit != GIMP_UNIT_PIXEL) { gdouble xres; gdouble yres; gdouble factor; gimp_image_get_resolution (image, &xres, &yres); factor = (MAX (xres, yres) / MIN (xres, yres)); if (xres == MIN (xres, yres)) radius_y *= factor; else radius_x *= factor; } gimp_channel_grow (gimp_image_get_mask (image), radius_x, radius_y, TRUE); gimp_image_flush (image); }
/** * gimp_display_shell_scale_fill: * @shell: the #GimpDisplayShell * * Sets the scale such that the entire display area is precisely * filled by the image. **/ void gimp_display_shell_scale_fill (GimpDisplayShell *shell) { GimpImage *image; gint image_width; gint image_height; gdouble xres; gdouble yres; gdouble zoom_factor; g_return_if_fail (GIMP_IS_DISPLAY_SHELL (shell)); image = gimp_display_get_image (shell->display); image_width = gimp_image_get_width (image); image_height = gimp_image_get_height (image); gimp_image_get_resolution (image, &xres, &yres); if (! shell->dot_for_dot) { image_width = ROUND (image_width * shell->monitor_xres / xres); image_height = ROUND (image_height * shell->monitor_yres / yres); } zoom_factor = MAX ((gdouble) shell->disp_width / (gdouble) image_width, (gdouble) shell->disp_height / (gdouble) image_height); gimp_display_shell_scale (shell, GIMP_ZOOM_TO, zoom_factor, GIMP_ZOOM_FOCUS_BEST_GUESS); gimp_display_shell_scroll_center_image (shell, TRUE, TRUE); }
void gimp_image_get_preview_size (GimpViewable *viewable, gint size, gboolean is_popup, gboolean dot_for_dot, gint *width, gint *height) { GimpImage *image = GIMP_IMAGE (viewable); gdouble xres; gdouble yres; gimp_image_get_resolution (image, &xres, &yres); gimp_viewable_calc_preview_size (gimp_image_get_width (image), gimp_image_get_height (image), size, size, dot_for_dot, xres, yres, width, height, NULL); }
static void image_scale_callback (GtkWidget *dialog, GimpViewable *viewable, gint width, gint height, GimpUnit unit, GimpInterpolationType interpolation, gdouble xresolution, gdouble yresolution, GimpUnit resolution_unit, gpointer user_data) { GimpImage *image = GIMP_IMAGE (viewable); gdouble xres; gdouble yres; image_scale_unit = unit; image_scale_interp = interpolation; gimp_image_get_resolution (image, &xres, &yres); if (width > 0 && height > 0) { if (width == gimp_image_get_width (image) && height == gimp_image_get_height (image) && xresolution == xres && yresolution == yres && resolution_unit == gimp_image_get_unit (image)) return; gimp_image_undo_group_start (image, GIMP_UNDO_GROUP_IMAGE_SCALE, _("Scale Image")); gimp_image_set_resolution (image, xresolution, yresolution); gimp_image_set_unit (image, resolution_unit); if (width != gimp_image_get_width (image) || height != gimp_image_get_height (image)) { GimpProgress *progress; progress = gimp_progress_start (GIMP_PROGRESS (user_data), _("Scaling"), FALSE); gimp_image_scale (image, width, height, interpolation, progress); if (progress) gimp_progress_end (progress); } gimp_image_undo_group_end (image); gimp_image_flush (image); } else { g_warning ("Scale Error: " "Both width and height must be greater than zero."); } }
void select_grow_cmd_callback (GtkAction *action, gpointer data) { GimpDisplay *display; GimpImage *image; GtkWidget *dialog; gdouble xres; gdouble yres; return_if_no_display (display, data); image = gimp_display_get_image (display); gimp_image_get_resolution (image, &xres, &yres); dialog = gimp_query_size_box (_("Grow Selection"), GTK_WIDGET (gimp_display_get_shell (display)), gimp_standard_help_func, GIMP_HELP_SELECTION_GROW, _("Grow selection by"), select_grow_pixels, 1, 32767, 0, gimp_display_get_shell (display)->unit, MIN (xres, yres), FALSE, G_OBJECT (image), "disconnect", select_grow_callback, image); gtk_widget_show (dialog); }
static void image_print_size_callback (GtkWidget *dialog, GimpImage *image, gdouble xresolution, gdouble yresolution, GimpUnit resolution_unit, gpointer data) { gdouble xres; gdouble yres; gtk_widget_destroy (dialog); gimp_image_get_resolution (image, &xres, &yres); if (xresolution == xres && yresolution == yres && resolution_unit == gimp_image_get_unit (image)) return; gimp_image_undo_group_start (image, GIMP_UNDO_GROUP_IMAGE_SCALE, _("Change Print Size")); gimp_image_set_resolution (image, xresolution, yresolution); gimp_image_set_unit (image, resolution_unit); gimp_image_undo_group_end (image); gimp_image_flush (image); }
void gimp_display_shell_get_constrained_line_params (GimpDisplayShell *shell, gdouble *offset_angle, gdouble *xres, gdouble *yres) { g_return_if_fail (GIMP_IS_DISPLAY_SHELL (shell)); g_return_if_fail (offset_angle != NULL); g_return_if_fail (xres != NULL); g_return_if_fail (yres != NULL); if (shell->flip_horizontally ^ shell->flip_vertically) *offset_angle = +shell->rotate_angle; else *offset_angle = -shell->rotate_angle; *xres = 1.0; *yres = 1.0; if (! shell->dot_for_dot) { GimpImage *image = gimp_display_get_image (shell->display); if (image) gimp_image_get_resolution (image, xres, yres); } }
/* ============================================================================ * gap_image_new_with_layer_of_samesize * ============================================================================ * create empty image * if layer_id is NOT NULL then create one full transparent layer at full image size * and return the layer_id */ gint32 gap_image_new_with_layer_of_samesize(gint32 old_image_id, gint32 *layer_id) { GimpImageBaseType l_type; guint l_width; guint l_height; gint32 new_image_id; gdouble l_xresoulution, l_yresoulution; gint32 l_unit; /* create empty image */ l_width = gimp_image_width(old_image_id); l_height = gimp_image_height(old_image_id); l_type = gimp_image_base_type(old_image_id); l_unit = gimp_image_get_unit(old_image_id); gimp_image_get_resolution(old_image_id, &l_xresoulution, &l_yresoulution); new_image_id = gimp_image_new(l_width, l_height,l_type); gimp_image_set_resolution(new_image_id, l_xresoulution, l_yresoulution); gimp_image_set_unit(new_image_id, l_unit); if(layer_id) { l_type = (l_type * 2); /* convert from GimpImageBaseType to GimpImageType */ *layer_id = gimp_layer_new(new_image_id, "dummy", l_width, l_height, l_type, 0.0, /* Opacity full transparent */ 0); /* NORMAL */ gimp_image_insert_layer(new_image_id, *layer_id, 0, 0); } return (new_image_id); } /* end gap_image_new_with_layer_of_samesize */
static gboolean windows_menu_display_query_tooltip (GtkWidget *widget, gint x, gint y, gboolean keyboard_mode, GtkTooltip *tooltip, GimpAction *action) { GimpImage *image = GIMP_IMAGE (action->viewable); gchar *text; gdouble xres; gdouble yres; gint width; gint height; text = gtk_widget_get_tooltip_text (widget); gtk_tooltip_set_text (tooltip, text); g_free (text); gimp_image_get_resolution (image, &xres, &yres); gimp_viewable_calc_preview_size (gimp_image_get_width (image), gimp_image_get_height (image), GIMP_VIEW_SIZE_HUGE, GIMP_VIEW_SIZE_HUGE, FALSE, xres, yres, &width, &height, NULL); gtk_tooltip_set_icon (tooltip, gimp_viewable_get_pixbuf (action->viewable, action->context, width, height)); return TRUE; }
void gimp_text_tool_editor_position (GimpTextTool *text_tool) { if (text_tool->style_overlay) { GimpTool *tool = GIMP_TOOL (text_tool); GimpDisplayShell *shell = gimp_display_get_shell (tool->display); GtkRequisition requisition; gint x, y; gtk_widget_size_request (text_tool->style_overlay, &requisition); g_object_get (text_tool, "x1", &x, "y1", &y, NULL); gimp_display_shell_move_overlay (shell, text_tool->style_overlay, x, y, GIMP_HANDLE_ANCHOR_SOUTH_WEST, 4, 12); if (text_tool->image) { gdouble xres, yres; gimp_image_get_resolution (text_tool->image, &xres, &yres); g_object_set (text_tool->style_editor, "resolution-x", xres, "resolution-y", yres, NULL); } } }
static void gimp_image_undo_constructed (GObject *object) { GimpImageUndo *image_undo = GIMP_IMAGE_UNDO (object); GimpImage *image; G_OBJECT_CLASS (parent_class)->constructed (object); image = GIMP_UNDO (object)->image; switch (GIMP_UNDO (object)->undo_type) { case GIMP_UNDO_IMAGE_TYPE: image_undo->base_type = gimp_image_get_base_type (image); break; case GIMP_UNDO_IMAGE_PRECISION: image_undo->precision = gimp_image_get_precision (image); break; case GIMP_UNDO_IMAGE_SIZE: image_undo->width = gimp_image_get_width (image); image_undo->height = gimp_image_get_height (image); break; case GIMP_UNDO_IMAGE_RESOLUTION: gimp_image_get_resolution (image, &image_undo->xresolution, &image_undo->yresolution); image_undo->resolution_unit = gimp_image_get_unit (image); break; case GIMP_UNDO_IMAGE_GRID: g_assert (GIMP_IS_GRID (image_undo->grid)); break; case GIMP_UNDO_IMAGE_COLORMAP: image_undo->num_colors = gimp_image_get_colormap_size (image); image_undo->colormap = g_memdup (gimp_image_get_colormap (image), GIMP_IMAGE_COLORMAP_SIZE); break; case GIMP_UNDO_IMAGE_METADATA: image_undo->metadata = gimp_metadata_duplicate (gimp_image_get_metadata (image)); break; case GIMP_UNDO_PARASITE_ATTACH: case GIMP_UNDO_PARASITE_REMOVE: g_assert (image_undo->parasite_name != NULL); image_undo->parasite = gimp_parasite_copy (gimp_image_parasite_find (image, image_undo->parasite_name)); break; default: g_assert_not_reached (); } }
gdouble gimp_paint_options_get_fade (GimpPaintOptions *paint_options, GimpImage *image, gdouble pixel_dist) { GimpFadeOptions *fade_options; g_return_val_if_fail (GIMP_IS_PAINT_OPTIONS (paint_options), GIMP_OPACITY_OPAQUE); g_return_val_if_fail (GIMP_IS_IMAGE (image), GIMP_OPACITY_OPAQUE); fade_options = paint_options->fade_options; if (fade_options->use_fade) { gdouble fade_out = 0.0; gdouble unit_factor; switch (fade_options->fade_unit) { case GIMP_UNIT_PIXEL: fade_out = fade_options->fade_length; break; case GIMP_UNIT_PERCENT: fade_out = (MAX (gimp_image_get_width (image), gimp_image_get_height (image)) * fade_options->fade_length / 100); break; default: { gdouble xres; gdouble yres; gimp_image_get_resolution (image, &xres, &yres); unit_factor = gimp_unit_get_factor (fade_options->fade_unit); fade_out = (fade_options->fade_length * MAX (xres, yres) / unit_factor); } break; } /* factor in the fade out value */ if (fade_out > 0.0) { gdouble x; /* Model the amount of paint left as a gaussian curve */ x = pixel_dist / fade_out; return exp (- x * x * 5.541); /* ln (1/255) */ } return GIMP_OPACITY_TRANSPARENT; } return GIMP_OPACITY_OPAQUE; }
static void gimp_image_duplicate_resolution (GimpImage *image, GimpImage *new_image) { gdouble xres; gdouble yres; gimp_image_get_resolution (image, &xres, &yres); gimp_image_set_resolution (new_image, xres, yres); gimp_image_set_unit (new_image, gimp_image_get_unit (image)); }
void select_border_cmd_callback (GtkAction *action, gpointer data) { GimpDisplay *display; GimpImage *image; GtkWidget *dialog; GtkWidget *button; gdouble xres; gdouble yres; return_if_no_display (display, data); image = gimp_display_get_image (display); gimp_image_get_resolution (image, &xres, &yres); dialog = gimp_query_size_box (_("Border Selection"), GTK_WIDGET (gimp_display_get_shell (display)), gimp_standard_help_func, GIMP_HELP_SELECTION_BORDER, _("Border selection by"), select_border_radius, 1, 32767, 0, gimp_display_get_shell (display)->unit, MIN (xres, yres), FALSE, G_OBJECT (image), "disconnect", select_border_callback, image); /* Feather button */ button = gtk_check_button_new_with_mnemonic (_("_Feather border")); gtk_box_pack_start (GTK_BOX (GIMP_QUERY_BOX_VBOX (dialog)), button, FALSE, FALSE, 0); g_object_set_data (G_OBJECT (dialog), "border-feather-toggle", button); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), select_border_feather); gtk_widget_show (button); /* Edge lock button */ button = gtk_check_button_new_with_mnemonic (_("_Selected areas continue outside the image")); g_object_set_data (G_OBJECT (dialog), "edge-lock-toggle", button); gimp_help_set_help_data (button, _("When bordering, act as if selected areas " "continued outside the image."), NULL); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), select_border_edge_lock); gtk_box_pack_start (GTK_BOX (GIMP_QUERY_BOX_VBOX (dialog)), button, FALSE, FALSE, 0); gtk_widget_show (button); gtk_widget_show (dialog); }
void gimp_text_tool_editor_start (GimpTextTool *text_tool) { GimpTool *tool = GIMP_TOOL (text_tool); GimpTextOptions *options = GIMP_TEXT_TOOL_GET_OPTIONS (text_tool); GimpDisplayShell *shell = gimp_display_get_shell (tool->display); gtk_im_context_set_client_window (text_tool->im_context, gtk_widget_get_window (shell->canvas)); text_tool->needs_im_reset = TRUE; gimp_text_tool_reset_im_context (text_tool); gtk_im_context_focus_in (text_tool->im_context); if (options->use_editor) gimp_text_tool_editor_dialog (text_tool); g_signal_connect (options, "notify::use-editor", G_CALLBACK (gimp_text_tool_options_notify), text_tool); if (! text_tool->style_overlay) { Gimp *gimp = GIMP_CONTEXT (options)->gimp; gdouble xres = 1.0; gdouble yres = 1.0; text_tool->style_overlay = gimp_overlay_frame_new (); gtk_container_set_border_width (GTK_CONTAINER (text_tool->style_overlay), 4); gimp_display_shell_add_overlay (shell, text_tool->style_overlay, 0, 0, GIMP_HANDLE_ANCHOR_CENTER, 0, 0); gimp_overlay_box_set_child_opacity (GIMP_OVERLAY_BOX (shell->canvas), text_tool->style_overlay, 0.7); if (text_tool->image) gimp_image_get_resolution (text_tool->image, &xres, &yres); text_tool->style_editor = gimp_text_style_editor_new (gimp, text_tool->proxy, text_tool->buffer, gimp->fonts, xres, yres); gtk_container_add (GTK_CONTAINER (text_tool->style_overlay), text_tool->style_editor); gtk_widget_show (text_tool->style_editor); } gimp_text_tool_editor_position (text_tool); gtk_widget_show (text_tool->style_overlay); }
static GimpBuffer * gimp_edit_extract (GimpImage *image, GimpPickable *pickable, GimpContext *context, gboolean cut_pixels, GError **error) { GeglBuffer *buffer; gint offset_x; gint offset_y; if (cut_pixels) gimp_image_undo_group_start (image, GIMP_UNDO_GROUP_EDIT_CUT, C_("undo-type", "Cut")); /* Cut/copy the mask portion from the image */ buffer = gimp_selection_extract (GIMP_SELECTION (gimp_image_get_mask (image)), pickable, context, cut_pixels, FALSE, &offset_x, &offset_y, error); if (cut_pixels) gimp_image_undo_group_end (image); if (buffer) { GimpBuffer *gimp_buffer; gdouble res_x; gdouble res_y; gimp_buffer = gimp_buffer_new (buffer, _("Global Buffer"), offset_x, offset_y, FALSE); g_object_unref (buffer); gimp_image_get_resolution (image, &res_x, &res_y); gimp_buffer_set_resolution (gimp_buffer, res_x, res_y); gimp_buffer_set_unit (gimp_buffer, gimp_image_get_unit (image)); if (GIMP_IS_COLOR_MANAGED (pickable)) { GimpColorProfile *profile = gimp_color_managed_get_color_profile (GIMP_COLOR_MANAGED (pickable)); if (profile) gimp_buffer_set_color_profile (gimp_buffer, profile); } return gimp_buffer; } return NULL; }
static void gimp_rotate_tool_prepare (GimpTransformTool *tr_tool) { GimpRotateTool *rotate = GIMP_ROTATE_TOOL (tr_tool); GimpDisplay *display = GIMP_TOOL (tr_tool)->display; GimpImage *image = gimp_display_get_image (display); gdouble xres; gdouble yres; tr_tool->px = (gdouble) (tr_tool->x1 + tr_tool->x2) / 2.0; tr_tool->py = (gdouble) (tr_tool->y1 + tr_tool->y2) / 2.0; tr_tool->trans_info[ANGLE] = 0.0; tr_tool->trans_info[REAL_ANGLE] = 0.0; tr_tool->trans_info[PIVOT_X] = tr_tool->px; tr_tool->trans_info[PIVOT_Y] = tr_tool->py; gimp_image_get_resolution (image, &xres, &yres); g_signal_handlers_block_by_func (rotate->sizeentry, rotate_center_changed, tr_tool); gimp_size_entry_set_unit (GIMP_SIZE_ENTRY (rotate->sizeentry), gimp_display_get_shell (display)->unit); gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (rotate->sizeentry), 0, xres, FALSE); gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (rotate->sizeentry), 1, yres, FALSE); gimp_size_entry_set_refval_boundaries (GIMP_SIZE_ENTRY (rotate->sizeentry), 0, -65536, 65536 + gimp_image_get_width (image)); gimp_size_entry_set_refval_boundaries (GIMP_SIZE_ENTRY (rotate->sizeentry), 1, -65536, 65536 + gimp_image_get_height (image)); gimp_size_entry_set_size (GIMP_SIZE_ENTRY (rotate->sizeentry), 0, tr_tool->x1, tr_tool->x2); gimp_size_entry_set_size (GIMP_SIZE_ENTRY (rotate->sizeentry), 1, tr_tool->y1, tr_tool->y2); g_signal_handlers_unblock_by_func (rotate->sizeentry, rotate_center_changed, tr_tool); }
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); }
void gimp_item_get_preview_size (GimpViewable *viewable, gint size, gboolean is_popup, gboolean dot_for_dot, gint *width, gint *height) { GimpItem *item = GIMP_ITEM (viewable); GimpImage *image = gimp_item_get_image (item); if (image && ! image->gimp->config->layer_previews && ! is_popup) { *width = size; *height = size; return; } if (image && ! is_popup) { gdouble xres; gdouble yres; gimp_image_get_resolution (image, &xres, &yres); gimp_viewable_calc_preview_size (gimp_image_get_width (image), gimp_image_get_height (image), size, size, dot_for_dot, xres, yres, width, height, NULL); } else { gimp_viewable_calc_preview_size (gimp_item_get_width (item), gimp_item_get_height (item), size, size, dot_for_dot, 1.0, 1.0, width, height, NULL); } }
gboolean gimp_item_get_popup_size (GimpViewable *viewable, gint width, gint height, gboolean dot_for_dot, gint *popup_width, gint *popup_height) { GimpItem *item = GIMP_ITEM (viewable); GimpImage *image = gimp_item_get_image (item); if (image && ! image->gimp->config->layer_previews) return FALSE; if (gimp_item_get_width (item) > width || gimp_item_get_height (item) > height) { gboolean scaling_up; gdouble xres = 1.0; gdouble yres = 1.0; if (image) gimp_image_get_resolution (image, &xres, &yres); gimp_viewable_calc_preview_size (gimp_item_get_width (item), gimp_item_get_height (item), width * 2, height * 2, dot_for_dot, xres, yres, popup_width, popup_height, &scaling_up); if (scaling_up) { *popup_width = gimp_item_get_width (item); *popup_height = gimp_item_get_height (item); } return TRUE; } return FALSE; }
void gimp_drawable_stroke_scan_convert (GimpDrawable *drawable, GimpStrokeOptions *options, GimpScanConvert *scan_convert, gboolean push_undo) { gdouble width; GimpUnit unit; g_return_if_fail (GIMP_IS_DRAWABLE (drawable)); g_return_if_fail (gimp_item_is_attached (GIMP_ITEM (drawable))); g_return_if_fail (GIMP_IS_STROKE_OPTIONS (options)); g_return_if_fail (scan_convert != NULL); g_return_if_fail (gimp_fill_options_get_style (GIMP_FILL_OPTIONS (options)) != GIMP_FILL_STYLE_PATTERN || gimp_context_get_pattern (GIMP_CONTEXT (options)) != NULL); if (! gimp_item_mask_intersect (GIMP_ITEM (drawable), NULL, NULL, NULL, NULL)) return; width = gimp_stroke_options_get_width (options); unit = gimp_stroke_options_get_unit (options); if (unit != GIMP_UNIT_PIXEL) { GimpImage *image = gimp_item_get_image (GIMP_ITEM (drawable)); gdouble xres; gdouble yres; gimp_image_get_resolution (image, &xres, &yres); gimp_scan_convert_set_pixel_ratio (scan_convert, yres / xres); width = gimp_units_to_pixels (width, unit, yres); } gimp_scan_convert_stroke (scan_convert, width, gimp_stroke_options_get_join_style (options), gimp_stroke_options_get_cap_style (options), gimp_stroke_options_get_miter_limit (options), gimp_stroke_options_get_dash_offset (options), gimp_stroke_options_get_dash_info (options)); gimp_drawable_fill_scan_convert (drawable, GIMP_FILL_OPTIONS (options), scan_convert, push_undo); }
static void gimp_scale_tool_prepare (GimpTransformTool *tr_tool) { GimpScaleTool *scale = GIMP_SCALE_TOOL (tr_tool); GimpTransformOptions *options = GIMP_TRANSFORM_TOOL_GET_OPTIONS (tr_tool); GimpDisplay *display = GIMP_TOOL (tr_tool)->display; gdouble xres; gdouble yres; tr_tool->trans_info[X0] = (gdouble) tr_tool->x1; tr_tool->trans_info[Y0] = (gdouble) tr_tool->y1; tr_tool->trans_info[X1] = (gdouble) tr_tool->x2; tr_tool->trans_info[Y1] = (gdouble) tr_tool->y2; gimp_image_get_resolution (gimp_display_get_image (display), &xres, &yres); if (scale->box) { g_signal_handlers_disconnect_by_func (scale->box, gimp_scale_tool_size_notify, tr_tool); gtk_widget_destroy (scale->box); } /* Need to create a new GimpSizeBox widget because the initial * width and height is what counts as 100%. */ scale->box = g_object_new (GIMP_TYPE_SIZE_BOX, "width", tr_tool->x2 - tr_tool->x1, "height", tr_tool->y2 - tr_tool->y1, "keep-aspect", options->constrain_scale, "unit", gimp_display_get_shell (display)->unit, "xresolution", xres, "yresolution", yres, NULL); gtk_box_pack_start (GTK_BOX (gimp_tool_gui_get_vbox (tr_tool->gui)), scale->box, FALSE, FALSE, 0); gtk_widget_show (scale->box); g_signal_connect (scale->box, "notify", G_CALLBACK (gimp_scale_tool_size_notify), tr_tool); }
static gboolean jpeg_load_resolution (gint32 image_ID, struct jpeg_decompress_struct *cinfo) { if (cinfo->saw_JFIF_marker && cinfo->X_density != 0 && cinfo->Y_density != 0) { gdouble xresolution = cinfo->X_density; gdouble yresolution = cinfo->Y_density; gdouble asymmetry = 1.0; switch (cinfo->density_unit) { case 0: /* unknown -> set the aspect ratio but use the default * image resolution */ asymmetry = xresolution / yresolution; gimp_image_get_resolution (image_ID, &xresolution, &yresolution); xresolution *= asymmetry; break; case 1: /* dots per inch */ break; case 2: /* dots per cm */ xresolution *= 2.54; yresolution *= 2.54; gimp_image_set_unit (image_ID, GIMP_UNIT_MM); break; default: g_message ("Unknown density unit %d, assuming dots per inch.", cinfo->density_unit); break; } gimp_image_set_resolution (image_ID, xresolution, yresolution); return TRUE; } return FALSE; }
/** * gimp_display_shell_calculate_scale_x_and_y: * @shell: * @scale: * @scale_x: * @scale_y: * **/ static void gimp_display_shell_calculate_scale_x_and_y (GimpDisplayShell *shell, gdouble scale, gdouble *scale_x, gdouble *scale_y) { GimpImage *image = gimp_display_get_image (shell->display); gdouble xres; gdouble yres; gdouble screen_xres; gdouble screen_yres; gimp_image_get_resolution (image, &xres, &yres); gimp_display_shell_scale_get_screen_resolution (shell, &screen_xres, &screen_yres); if (scale_x) *scale_x = scale * screen_xres / xres; if (scale_y) *scale_y = scale * screen_yres / yres; }
static void select_border_callback (GtkWidget *widget, gdouble size, GimpUnit unit, gpointer data) { GimpImage *image = GIMP_IMAGE (data); GtkWidget *feather_button = g_object_get_data (G_OBJECT (widget), "border-feather-toggle"); GtkWidget *edge_lock_button = g_object_get_data (G_OBJECT (widget), "edge-lock-toggle"); gdouble radius_x; gdouble radius_y; radius_x = radius_y = select_border_radius = ROUND (size); select_border_feather = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (feather_button)); select_border_edge_lock = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (edge_lock_button)); if (unit != GIMP_UNIT_PIXEL) { gdouble xres; gdouble yres; gdouble factor; gimp_image_get_resolution (image, &xres, &yres); factor = (MAX (xres, yres) / MIN (xres, yres)); if (xres == MIN (xres, yres)) radius_y *= factor; else radius_x *= factor; } gimp_channel_border (gimp_image_get_mask (image), radius_x, radius_y, select_border_feather, select_border_edge_lock, TRUE); gimp_image_flush (image); }
static void gimp_vectors_export_image_size (const GimpImage *image, GString *str) { GimpUnit unit; const gchar *abbrev; gchar wbuf[G_ASCII_DTOSTR_BUF_SIZE]; gchar hbuf[G_ASCII_DTOSTR_BUF_SIZE]; gdouble xres; gdouble yres; gdouble w, h; gimp_image_get_resolution (image, &xres, &yres); w = (gdouble) gimp_image_get_width (image) / xres; h = (gdouble) gimp_image_get_height (image) / yres; /* FIXME: should probably use the display unit here */ unit = gimp_image_get_unit (image); switch (unit) { case GIMP_UNIT_INCH: abbrev = "in"; break; case GIMP_UNIT_MM: abbrev = "mm"; break; case GIMP_UNIT_POINT: abbrev = "pt"; break; case GIMP_UNIT_PICA: abbrev = "pc"; break; default: abbrev = "cm"; unit = GIMP_UNIT_MM; w /= 10.0; h /= 10.0; break; } g_ascii_formatd (wbuf, sizeof (wbuf), "%g", w * _gimp_unit_get_factor (image->gimp, unit)); g_ascii_formatd (hbuf, sizeof (hbuf), "%g", h * _gimp_unit_get_factor (image->gimp, unit)); g_string_append_printf (str, "width=\"%s%s\" height=\"%s%s\"", wbuf, abbrev, hbuf, abbrev); }
static void gimp_display_shell_scale_get_screen_resolution (GimpDisplayShell *shell, gdouble *xres, gdouble *yres) { gdouble x, y; if (shell->dot_for_dot) { gimp_image_get_resolution (gimp_display_get_image (shell->display), &x, &y); } else { x = shell->monitor_xres; y = shell->monitor_yres; } if (xres) *xres = x; if (yres) *yres = y; }
void gimp_display_shell_get_screen_resolution (GimpDisplayShell *shell, gdouble *xres, gdouble *yres) { gdouble x, y; g_return_if_fail (GIMP_IS_DISPLAY_SHELL (shell)); if (shell->dot_for_dot) { gimp_image_get_resolution (gimp_display_get_image (shell->display), &x, &y); } else { x = shell->monitor_xres; y = shell->monitor_yres; } if (xres) *xres = x; if (yres) *yres = y; }
/** * gimp_display_shell_calculate_scale_x_and_y: * @shell: * @scale: * @scale_x: * @scale_y: * **/ void gimp_display_shell_calculate_scale_x_and_y (GimpDisplayShell *shell, gdouble scale, gdouble *scale_x, gdouble *scale_y) { GimpImage *image; gdouble xres; gdouble yres; gdouble screen_xres; gdouble screen_yres; g_return_if_fail (GIMP_IS_DISPLAY_SHELL (shell)); image = gimp_display_get_image (shell->display); g_return_if_fail (GIMP_IS_IMAGE (image)); gimp_image_get_resolution (image, &xres, &yres); gimp_display_shell_get_screen_resolution (shell, &screen_xres, &screen_yres); if (scale_x) *scale_x = scale * screen_xres / xres; if (scale_y) *scale_y = scale * screen_yres / yres; }
static gboolean pixelize_dialog (GimpDrawable *drawable) { GtkWidget *dialog; GtkWidget *main_vbox; GtkWidget *preview; GtkWidget *sizeentry; guint32 image_id; GimpUnit unit; gdouble xres, yres; gboolean run; gimp_ui_init (PLUG_IN_BINARY, FALSE); dialog = gimp_dialog_new (_("Pixelize"), PLUG_IN_BINARY, NULL, 0, gimp_standard_help_func, PIXELIZE_PROC, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1); gimp_window_set_transient (GTK_WINDOW (dialog)); main_vbox = gtk_vbox_new (FALSE, 12); gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12); gtk_container_add (GTK_CONTAINER (GTK_DIALOG (dialog)->vbox), main_vbox); gtk_widget_show (main_vbox); preview = gimp_drawable_preview_new (drawable, NULL); gtk_box_pack_start_defaults (GTK_BOX (main_vbox), preview); gtk_widget_show (preview); g_signal_connect_swapped (preview, "invalidated", G_CALLBACK (pixelize), drawable); image_id = gimp_drawable_get_image (drawable->drawable_id); unit = gimp_image_get_unit (image_id); gimp_image_get_resolution (image_id, &xres, &yres); sizeentry = gimp_coordinates_new (unit, "%a", TRUE, TRUE, ENTRY_WIDTH, GIMP_SIZE_ENTRY_UPDATE_SIZE, TRUE, FALSE, _("Pixel _width:"), pvals.pixelwidth, xres, 1, drawable->width, 1, drawable->width, _("Pixel _height:"), pvals.pixelheight, yres, 1, drawable->height, 1, drawable->height); gtk_box_pack_start (GTK_BOX (main_vbox), sizeentry, FALSE, FALSE, 0); gtk_widget_show (sizeentry); g_signal_connect (sizeentry, "value-changed", G_CALLBACK (update_pixelsize), preview); g_signal_connect (sizeentry, "refval-changed", G_CALLBACK (update_pixelsize), preview); gtk_widget_show (dialog); run = (gimp_dialog_run (GIMP_DIALOG (dialog)) == GTK_RESPONSE_OK); gtk_widget_destroy (dialog); return run; }