static GValueArray * unit_get_factor_invoker (GimpProcedure *procedure, Gimp *gimp, GimpContext *context, GimpProgress *progress, const GValueArray *args, GError **error) { gboolean success = TRUE; GValueArray *return_vals; GimpUnit unit_id; gdouble factor = 0.0; unit_id = g_value_get_int (&args->values[0]); if (success) { factor = _gimp_unit_get_factor (gimp, unit_id); } return_vals = gimp_procedure_get_return_values (procedure, success, error ? *error : NULL); if (success) g_value_set_double (&return_vals->values[1], factor); return return_vals; }
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_unit_def_init (GimpUnitDef *unit_def, GimpUnit unit) { unit_def->factor = _gimp_unit_get_factor (unit); unit_def->digits = _gimp_unit_get_digits (unit); unit_def->identifier = _gimp_unit_get_identifier (unit); unit_def->symbol = _gimp_unit_get_symbol (unit); unit_def->abbreviation = _gimp_unit_get_abbreviation (unit); unit_def->singular = _gimp_unit_get_singular (unit); unit_def->plural = _gimp_unit_get_plural (unit); }
static gdouble gimp_units_unit_get_factor (GimpUnit unit) { return _gimp_unit_get_factor (the_unit_gimp, unit); }
void gimp_unitrc_save (Gimp *gimp) { GimpConfigWriter *writer; GFile *file; gint i; GError *error = NULL; g_return_if_fail (GIMP_IS_GIMP (gimp)); file = gimp_directory_file ("unitrc", NULL); if (gimp->be_verbose) g_print ("Writing '%s'\n", gimp_file_get_utf8_name (file)); writer = gimp_config_writer_new_gfile (file, TRUE, "GIMP units\n\n" "This file contains the user unit database. " "You can edit this list with the unit " "editor. You are not supposed to edit it " "manually, but of course you can do.\n" "This file will be entirely rewritten each " "time you exit.", NULL); g_object_unref (file); if (!writer) return; /* save user defined units */ for (i = _gimp_unit_get_number_of_built_in_units (gimp); i < _gimp_unit_get_number_of_units (gimp); i++) { if (_gimp_unit_get_deletion_flag (gimp, i) == FALSE) { gchar buf[G_ASCII_DTOSTR_BUF_SIZE]; gimp_config_writer_open (writer, "unit-info"); gimp_config_writer_string (writer, _gimp_unit_get_identifier (gimp, i)); gimp_config_writer_open (writer, "factor"); gimp_config_writer_print (writer, g_ascii_formatd (buf, sizeof (buf), "%f", _gimp_unit_get_factor (gimp, i)), -1); gimp_config_writer_close (writer); gimp_config_writer_open (writer, "digits"); gimp_config_writer_printf (writer, "%d", _gimp_unit_get_digits (gimp, i)); gimp_config_writer_close (writer); gimp_config_writer_open (writer, "symbol"); gimp_config_writer_string (writer, _gimp_unit_get_symbol (gimp, i)); gimp_config_writer_close (writer); gimp_config_writer_open (writer, "abbreviation"); gimp_config_writer_string (writer, _gimp_unit_get_abbreviation (gimp, i)); gimp_config_writer_close (writer); gimp_config_writer_open (writer, "singular"); gimp_config_writer_string (writer, _gimp_unit_get_singular (gimp, i)); gimp_config_writer_close (writer); gimp_config_writer_open (writer, "plural"); gimp_config_writer_string (writer, _gimp_unit_get_plural (gimp, i)); gimp_config_writer_close (writer); gimp_config_writer_close (writer); } } if (! gimp_config_writer_finish (writer, "end of units", &error)) { gimp_message_literal (gimp, NULL, GIMP_MESSAGE_ERROR, error->message); g_clear_error (&error); } }
void gimp_cursor_view_update_cursor (GimpCursorView *view, GimpImage *image, GimpUnit unit, gdouble x, gdouble y) { gboolean in_image; gdouble unit_factor; gint unit_digits; const gchar *unit_str; gchar format_buf[32]; gchar buf[32]; GimpImageType sample_type; GimpRGB color; gint color_index; g_return_if_fail (GIMP_IS_CURSOR_VIEW (view)); g_return_if_fail (GIMP_IS_IMAGE (image)); if (unit == GIMP_UNIT_PIXEL) unit = gimp_image_get_unit (image); in_image = (x >= 0.0 && x < gimp_image_get_width (image) && y >= 0.0 && y < gimp_image_get_height (image)); unit_factor = _gimp_unit_get_factor (image->gimp, unit); unit_digits = _gimp_unit_get_digits (image->gimp, unit); unit_str = _gimp_unit_get_abbreviation (image->gimp, unit); #define FORMAT_STRING(s) (in_image ? (s) : "("s")") g_snprintf (buf, sizeof (buf), FORMAT_STRING ("%d"), (gint) floor (x)); gtk_label_set_text (GTK_LABEL (view->pixel_x_label), buf); g_snprintf (buf, sizeof (buf), FORMAT_STRING ("%d"), (gint) floor (y)); gtk_label_set_text (GTK_LABEL (view->pixel_y_label), buf); g_snprintf (format_buf, sizeof (format_buf), FORMAT_STRING ("%%.%df %s"), unit_digits, unit_str); g_snprintf (buf, sizeof (buf), format_buf, x * unit_factor / image->xresolution); gtk_label_set_text (GTK_LABEL (view->unit_x_label), buf); g_snprintf (buf, sizeof (buf), format_buf, y * unit_factor / image->yresolution); gtk_label_set_text (GTK_LABEL (view->unit_y_label), buf); if (gimp_image_pick_color (image, NULL, (gint) floor (x), (gint) floor (y), view->sample_merged, FALSE, 0.0, &sample_type, &color, &color_index)) { gimp_color_frame_set_color (GIMP_COLOR_FRAME (view->color_frame_1), sample_type, &color, color_index); gimp_color_frame_set_color (GIMP_COLOR_FRAME (view->color_frame_2), sample_type, &color, color_index); } else { gimp_color_frame_set_invalid (GIMP_COLOR_FRAME (view->color_frame_1)); gimp_color_frame_set_invalid (GIMP_COLOR_FRAME (view->color_frame_2)); } }
static void gimp_drawable_stroke_scan_convert (GimpDrawable *drawable, GimpStrokeOptions *options, GimpScanConvert *scan_convert) { GimpContext *context = GIMP_CONTEXT (options); GimpImage *image; gdouble width; TileManager *base; TileManager *mask; gint x, y, w, h; gint bytes; gint off_x, off_y; guchar bg[1] = { 0, }; PixelRegion maskPR, basePR; image = gimp_item_get_image (GIMP_ITEM (drawable)); /* must call gimp_channel_is_empty() instead of relying on * gimp_drawable_mask_intersect() because the selection pretends to * be empty while it is being stroked, to prevent masking itself. */ if (gimp_channel_is_empty (gimp_image_get_mask (image))) { x = 0; y = 0; w = gimp_item_width (GIMP_ITEM (drawable)); h = gimp_item_height (GIMP_ITEM (drawable)); } else if (! gimp_drawable_mask_intersect (drawable, &x, &y, &w, &h)) { return; } gimp_item_offsets (GIMP_ITEM (drawable), &off_x, &off_y); width = options->width; if (options->unit != GIMP_UNIT_PIXEL) { gimp_scan_convert_set_pixel_ratio (scan_convert, image->yresolution / image->xresolution); width *= (image->yresolution / _gimp_unit_get_factor (image->gimp, options->unit)); } gimp_scan_convert_stroke (scan_convert, width, options->join_style, options->cap_style, options->miter_limit, options->dash_offset, options->dash_info); /* fill a 1-bpp Tilemanager with black, this will describe the shape * of the stroke. */ mask = tile_manager_new (w, h, 1); pixel_region_init (&maskPR, mask, 0, 0, w, h, TRUE); color_region (&maskPR, bg); /* render the stroke into it */ gimp_scan_convert_render (scan_convert, mask, x + off_x, y + off_y, options->antialias); bytes = gimp_drawable_bytes_with_alpha (drawable); base = tile_manager_new (w, h, bytes); pixel_region_init (&basePR, base, 0, 0, w, h, TRUE); pixel_region_init (&maskPR, mask, 0, 0, w, h, FALSE); switch (options->style) { case GIMP_STROKE_STYLE_SOLID: { guchar tmp_col[MAX_CHANNELS] = { 0, }; guchar col[MAX_CHANNELS] = { 0, }; gimp_rgb_get_uchar (&context->foreground, &tmp_col[RED_PIX], &tmp_col[GREEN_PIX], &tmp_col[BLUE_PIX]); gimp_image_transform_color (image, gimp_drawable_type (drawable), col, GIMP_RGB, tmp_col); col[bytes - 1] = OPAQUE_OPACITY; color_region_mask (&basePR, &maskPR, col); } break; case GIMP_STROKE_STYLE_PATTERN: { GimpPattern *pattern; TempBuf *pat_buf; gboolean new_buf; pattern = gimp_context_get_pattern (context); pat_buf = gimp_image_transform_temp_buf (image, gimp_drawable_type (drawable), pattern->mask, &new_buf); pattern_region (&basePR, &maskPR, pat_buf, x, y); if (new_buf) temp_buf_free (pat_buf); } break; } /* Apply to drawable */ pixel_region_init (&basePR, base, 0, 0, w, h, FALSE); gimp_drawable_apply_region (drawable, &basePR, TRUE, _("Render Stroke"), gimp_context_get_opacity (context), gimp_context_get_paint_mode (context), NULL, x, y); tile_manager_unref (mask); tile_manager_unref (base); gimp_drawable_update (drawable, x, y, w, h); }
static void gimp_display_shell_format_title (GimpDisplayShell *shell, gchar *title, gint title_len, const gchar *format) { Gimp *gimp; GimpImage *image; gint num, denom; gint i = 0; g_return_if_fail (GIMP_IS_DISPLAY_SHELL (shell)); image = shell->display->image; gimp = image->gimp; gimp_zoom_model_get_fraction (shell->zoom, &num, &denom); while (i < title_len && *format) { switch (*format) { case '%': format++; switch (*format) { case 0: /* format string ends within %-sequence, print literal '%' */ case '%': title[i++] = '%'; break; case 'f': /* pruned filename */ { const gchar *uri = gimp_image_get_uri (image); gchar *basename; basename = file_utils_uri_display_basename (uri); i += print (title, title_len, i, "%s", basename); g_free (basename); } break; case 'F': /* full filename */ { gchar *filename; const gchar *uri = gimp_image_get_uri (image); filename = file_utils_uri_display_name (uri); i += print (title, title_len, i, "%s", filename); g_free (filename); } break; case 'p': /* PDB id */ i += print (title, title_len, i, "%d", gimp_image_get_ID (image)); break; case 'i': /* instance */ i += print (title, title_len, i, "%d", shell->display->instance); break; case 't': /* type */ { const gchar *image_type_str = NULL; gboolean empty = gimp_image_is_empty (image); switch (gimp_image_base_type (image)) { case GIMP_RGB: image_type_str = empty ? _("RGB-empty") : _("RGB"); break; case GIMP_GRAY: image_type_str = empty ? _("grayscale-empty") : _("grayscale"); break; case GIMP_INDEXED: image_type_str = empty ? _("indexed-empty") : _("indexed"); break; default: g_assert_not_reached (); break; } i += print (title, title_len, i, "%s", image_type_str); } break; case 's': /* user source zoom factor */ i += print (title, title_len, i, "%d", denom); break; case 'd': /* user destination zoom factor */ i += print (title, title_len, i, "%d", num); break; case 'z': /* user zoom factor (percentage) */ { gdouble scale = gimp_zoom_model_get_factor (shell->zoom); i += print (title, title_len, i, scale >= 0.15 ? "%.0f" : "%.2f", 100.0 * scale); } break; case 'D': /* dirty flag */ if (format[1] == 0) { /* format string ends within %D-sequence, print literal '%D' */ i += print (title, title_len, i, "%%D"); break; } if (image->dirty) title[i++] = format[1]; format++; break; case 'C': /* clean flag */ if (format[1] == 0) { /* format string ends within %C-sequence, print literal '%C' */ i += print (title, title_len, i, "%%C"); break; } if (! image->dirty) title[i++] = format[1]; format++; break; case 'B': /* dirty flag (long) */ if (image->dirty) i += print (title, title_len, i, "%s", _("(modified)")); break; case 'A': /* clean flag (long) */ if (! image->dirty) i += print (title, title_len, i, "%s", _("(clean)")); break; case 'm': /* memory used by image */ { GimpObject *object = GIMP_OBJECT (image); gchar *str; str = gimp_memsize_to_string (gimp_object_get_memsize (object, NULL)); i += print (title, title_len, i, "%s", str); g_free (str); } break; case 'l': /* number of layers */ i += print (title, title_len, i, "%d", gimp_container_num_children (image->layers)); break; case 'L': /* number of layers (long) */ { gint num = gimp_container_num_children (image->layers); i += print (title, title_len, i, ngettext ("%d layer", "%d layers", num), num); } break; case 'n': /* active drawable name */ { GimpDrawable *drawable = gimp_image_get_active_drawable (image); if (drawable) i += print (title, title_len, i, "%s", gimp_object_get_name (GIMP_OBJECT (drawable))); else i += print (title, title_len, i, "%s", _("(none)")); } break; case 'P': /* active drawable PDB id */ { GimpDrawable *drawable = gimp_image_get_active_drawable (image); if (drawable) i += print (title, title_len, i, "%d", gimp_item_get_ID (GIMP_ITEM (drawable))); else i += print (title, title_len, i, "%s", _("(none)")); } break; case 'W': /* width in real-world units */ if (shell->unit != GIMP_UNIT_PIXEL) { gchar unit_format[8]; g_snprintf (unit_format, sizeof (unit_format), "%%.%df", _gimp_unit_get_digits (gimp, shell->unit) + 1); i += print (title, title_len, i, unit_format, (image->width * _gimp_unit_get_factor (gimp, shell->unit) / image->xresolution)); break; } /* else fallthru */ case 'w': /* width in pixels */ i += print (title, title_len, i, "%d", image->width); break; case 'H': /* height in real-world units */ if (shell->unit != GIMP_UNIT_PIXEL) { gchar unit_format[8]; g_snprintf (unit_format, sizeof (unit_format), "%%.%df", _gimp_unit_get_digits (gimp, shell->unit) + 1); i += print (title, title_len, i, unit_format, (image->height * _gimp_unit_get_factor (gimp, shell->unit) / image->yresolution)); break; } /* else fallthru */ case 'h': /* height in pixels */ i += print (title, title_len, i, "%d", image->height); break; case 'u': /* unit symbol */ i += print (title, title_len, i, "%s", _gimp_unit_get_symbol (gimp, shell->unit)); break; case 'U': /* unit abbreviation */ i += print (title, title_len, i, "%s", _gimp_unit_get_abbreviation (gimp, shell->unit)); break; /* Other cool things to be added: * %r = xresolution * %R = yresolution * %ø = image's fractal dimension * %þ = the answer to everything */ default: /* format string contains unknown %-sequence, print it literally */ i += print (title, title_len, i, "%%%c", *format); break; } break; default: title[i++] = *format; break; } format++; } title[MIN (i, title_len - 1)] = '\0'; }