void
gth_image_info_set_image (GthImageInfo *image_info,
cairo_surface_t *image)
{
int thumb_w;
int thumb_h;
g_return_if_fail (image != NULL);
_cairo_clear_surface (&image_info->image);
_cairo_clear_surface (&image_info->thumbnail_original);
_cairo_clear_surface (&image_info->thumbnail);
_cairo_clear_surface (&image_info->thumbnail_active);
image_info->image = cairo_surface_reference (image);
thumb_w = image_info->original_width = image_info->image_width = cairo_image_surface_get_width (image);
thumb_h = image_info->original_height = image_info->image_height = cairo_image_surface_get_height (image);
if (scale_keeping_ratio (&thumb_w, &thumb_h, THUMBNAIL_SIZE, THUMBNAIL_SIZE, FALSE))
image_info->thumbnail_original = _cairo_image_surface_scale (image,
thumb_w,
thumb_h,
SCALE_FILTER_BEST,
NULL);
else
image_info->thumbnail_original = cairo_surface_reference (image_info->image);
image_info->thumbnail = cairo_surface_reference (image_info->thumbnail_original);
image_info->thumbnail_active = _cairo_image_surface_color_shift (image_info->thumbnail, 30);
}
static void
update_preview_image (GthPreviewTool *self)
{
cairo_surface_t *image;
int width;
int height;
GtkAllocation allocation;
int max_size;
if (self->priv->preview_image != NULL) {
cairo_surface_destroy (self->priv->preview_image);
self->priv->preview_image = NULL;
}
image = gth_image_viewer_get_current_image (GTH_IMAGE_VIEWER (self->priv->viewer));
if (image == NULL)
return;
width = cairo_image_surface_get_width (image);
height = cairo_image_surface_get_height (image);
gtk_widget_get_allocation (GTK_WIDGET (self->priv->viewer), &allocation);
max_size = MAX (allocation.width, allocation.height) / G_SQRT2 + 2;
if (scale_keeping_ratio (&width, &height, max_size, max_size, FALSE))
self->priv->preview_image = _cairo_image_surface_scale_bilinear (image, width, height);
else
self->priv->preview_image = cairo_surface_reference (image);
self->priv->preview_image_area.width = width;
self->priv->preview_image_area.height = height;
self->priv->preview_image_area.x = MAX ((allocation.width - self->priv->preview_image_area.width) / 2 - 0.5, 0);
self->priv->preview_image_area.y = MAX ((allocation.height - self->priv->preview_image_area.height) / 2 - 0.5, 0);
}
GdkPixbuf *
_g_icon_get_pixbuf (GIcon *icon,
int size,
GtkIconTheme *theme)
{
GdkPixbuf *pixbuf;
int w, h;
if (icon == NULL)
return NULL;
pixbuf = NULL;
if (G_IS_THEMED_ICON (icon))
pixbuf = get_themed_icon_pixbuf (G_THEMED_ICON (icon), size, theme);
if (G_IS_FILE_ICON (icon))
pixbuf = get_file_icon_pixbuf (G_FILE_ICON (icon), size);
if (pixbuf == NULL)
return NULL;
w = gdk_pixbuf_get_width (pixbuf);
h = gdk_pixbuf_get_height (pixbuf);
if (scale_keeping_ratio (&w, &h, size, size, FALSE)) {
GdkPixbuf *scaled;
scaled = gdk_pixbuf_scale_simple (pixbuf, w, h, GDK_INTERP_BILINEAR);
g_object_unref (pixbuf);
pixbuf = scaled;
}
return pixbuf;
}
static void
pixbuf_loader_size_prepared_cb (GdkPixbufLoader *loader,
int width,
int height,
gpointer user_data)
{
ScaleData *scale_data = user_data;
scale_data->original_width = width;
scale_data->original_height = height;
scale_data->loader_width = width;
scale_data->loader_height = height;
if (scale_data->requested_size == -1)
return;
if (scale_keeping_ratio (&scale_data->loader_width,
&scale_data->loader_height,
scale_data->requested_size,
scale_data->requested_size,
FALSE))
{
gdk_pixbuf_loader_set_size (loader,
scale_data->loader_width,
scale_data->loader_height);
}
}
static gpointer
exec_resize (GthAsyncTask *task,
gpointer user_data)
{
ResizeData *resize_data = user_data;
cairo_surface_t *source;
cairo_surface_t *destination;
int w, h;
int new_w, new_h;
int max_w, max_h;
GthImage *destination_image;
source = gth_image_get_cairo_surface (gth_image_task_get_source (GTH_IMAGE_TASK (task)));
w = cairo_image_surface_get_width (source);
h = cairo_image_surface_get_height (source);
if (resize_data->allow_swap
&& (((h > w) && (resize_data->width > resize_data->height))
|| ((h < w) && (resize_data->width < resize_data->height))))
{
max_w = resize_data->height;
max_h = resize_data->width;
}
else {
max_w = resize_data->width;
max_h = resize_data->height;
}
if (resize_data->unit == GTH_UNIT_PERCENTAGE) {
new_w = w * ((double) max_w / 100.0);
new_h = h * ((double) max_h / 100.0);
}
else if (resize_data->keep_aspect_ratio) {
new_w = w;
new_h = h;
scale_keeping_ratio (&new_w, &new_h, max_w, max_h, TRUE);
}
else {
new_w = max_w;
new_h = max_h;
}
if ((new_w > 1) && (new_h > 1))
destination = _cairo_image_surface_scale (source, new_w, new_h, SCALE_FILTER_BEST, task);
else
destination = NULL;
destination_image = gth_image_new_for_surface (destination);
gth_image_task_set_destination (GTH_IMAGE_TASK (task), destination_image);
_g_object_unref (destination_image);
cairo_surface_destroy (destination);
cairo_surface_destroy (source);
return NULL;
}
static void
update_image_surface (GthImageRotator *self)
{
GtkAllocation allocation;
cairo_surface_t *image;
int max_size;
int width;
int height;
cairo_surface_t *preview_image;
if (self->priv->preview_image != NULL) {
cairo_surface_destroy (self->priv->preview_image);
self->priv->preview_image = NULL;
}
image = gth_image_viewer_get_current_image (GTH_IMAGE_VIEWER (self->priv->viewer));
if (image == NULL)
return;
self->priv->original_width = cairo_image_surface_get_width (image);
self->priv->original_height = cairo_image_surface_get_height (image);
width = self->priv->original_width;
height = self->priv->original_height;
gtk_widget_get_allocation (GTK_WIDGET (self->priv->viewer), &allocation);
max_size = MAX (allocation.width, allocation.height) / G_SQRT2 + 2;
if (scale_keeping_ratio (&width, &height, max_size, max_size, FALSE))
preview_image = _cairo_image_surface_scale_bilinear (image, width, height);
else
preview_image = cairo_surface_reference (image);
self->priv->preview_zoom = (double) width / self->priv->original_width;
self->priv->preview_image = preview_image;
self->priv->preview_image_area.width = width;
self->priv->preview_image_area.height = height;
self->priv->preview_image_area.x = MAX ((allocation.width - self->priv->preview_image_area.width) / 2 - 0.5, 0);
self->priv->preview_image_area.y = MAX ((allocation.height - self->priv->preview_image_area.height) / 2 - 0.5, 0);
_gth_image_rotator_update_tranformation_matrix (self);
}
cairo_surface_t *
_cairo_create_dnd_icon (cairo_surface_t *image,
int icon_size,
ItemStyle style,
gboolean multi_dnd)
{
cairo_rectangle_int_t thumbnail_rect;
cairo_surface_t *thumbnail;
cairo_rectangle_int_t icon_rect;
int icon_padding;
cairo_rectangle_int_t frame_rect;
cairo_surface_t *icon;
cairo_t *cr;
thumbnail_rect.width = cairo_image_surface_get_width (image);
thumbnail_rect.height = cairo_image_surface_get_height (image);
if (scale_keeping_ratio (&thumbnail_rect.width, &thumbnail_rect.height, icon_size, icon_size, FALSE))
thumbnail = _cairo_image_surface_scale_fast (image, thumbnail_rect.width, thumbnail_rect.height);
else
thumbnail = cairo_surface_reference (image);
switch (style) {
case ITEM_STYLE_ICON:
icon_padding = 8;
icon_rect.width = icon_size + icon_padding;
icon_rect.height = icon_size + icon_padding;
thumbnail_rect.x = round ((double) (icon_rect.width - thumbnail_rect.width) / 2.0);
thumbnail_rect.y = round ((double) (icon_rect.height - thumbnail_rect.height) / 2.0);
frame_rect.x = 0;
frame_rect.y = 0;
frame_rect.width = icon_rect.width;
frame_rect.height = icon_rect.height;
break;
case ITEM_STYLE_IMAGE:
icon_padding = 8; /* padding for the frame border */
icon_rect.width = thumbnail_rect.width + icon_padding;
icon_rect.height = thumbnail_rect.height + icon_padding;
thumbnail_rect.x = 3;
thumbnail_rect.y = 3;
frame_rect.x = 0;
frame_rect.y = 0;
frame_rect.width = thumbnail_rect.width + icon_padding - 2;
frame_rect.height = thumbnail_rect.height + icon_padding - 2;
break;
case ITEM_STYLE_VIDEO:
icon_padding = 4; /* padding for the drop shadow effect */
icon_rect.width = thumbnail_rect.width + icon_padding;
icon_rect.height = icon_size + icon_padding;
thumbnail_rect.x = 0;
thumbnail_rect.y = round ((double) (icon_size - thumbnail_rect.height) / 2.0);
frame_rect.x = thumbnail_rect.x;
frame_rect.y = 0;
frame_rect.width = thumbnail_rect.width;
frame_rect.height = icon_size;
break;
}
if (multi_dnd) {
icon_rect.width += DRAG_ICON_THUMBNAIL_OFFSET;
icon_rect.height += DRAG_ICON_THUMBNAIL_OFFSET;
}
icon = _cairo_image_surface_create (CAIRO_FORMAT_ARGB32, icon_rect.width, icon_rect.height);
cr = cairo_create (icon);
switch (style) {
case ITEM_STYLE_ICON:
cairo_save (cr);
cairo_set_source_rgba (cr, 1.0, 1.0, 1.0, 0.2);
_cairo_draw_rounded_box (cr, frame_rect.x, frame_rect.y, frame_rect.width, frame_rect.height, 4);
cairo_fill (cr);
cairo_restore (cr);
break;
case ITEM_STYLE_IMAGE:
if (multi_dnd)
_cairo_draw_thumbnail_frame (cr, frame_rect.x + DRAG_ICON_THUMBNAIL_OFFSET, frame_rect.y + DRAG_ICON_THUMBNAIL_OFFSET, frame_rect.width, frame_rect.height);
_cairo_draw_thumbnail_frame (cr, frame_rect.x, frame_rect.y, frame_rect.width, frame_rect.height);
break;
case ITEM_STYLE_VIDEO:
_cairo_draw_film_background (cr, frame_rect.x, frame_rect.y, frame_rect.width, frame_rect.height);
break;
}
cairo_save (cr);
cairo_set_antialias (cr, CAIRO_ANTIALIAS_NONE);
cairo_set_source_surface (cr, thumbnail, thumbnail_rect.x, thumbnail_rect.y);
cairo_pattern_set_filter (cairo_get_source (cr), CAIRO_FILTER_FAST);
cairo_rectangle (cr, thumbnail_rect.x, thumbnail_rect.y, thumbnail_rect.width, thumbnail_rect.height);
cairo_fill (cr);
cairo_restore (cr);
if (style == ITEM_STYLE_VIDEO)
_cairo_draw_film_foreground (cr, frame_rect.x, frame_rect.y, frame_rect.width, frame_rect.height, icon_size);
cairo_surface_set_device_offset (icon, -icon_rect.width / 2, -icon_rect.height / 2);
cairo_surface_destroy (thumbnail);
cairo_destroy (cr);
return icon;
}
static GtkWidget *
gth_file_tool_adjust_contrast_get_options (GthFileTool *base)
{
GthFileToolAdjustContrast *self;
GtkWidget *window;
GtkWidget *viewer_page;
GtkWidget *viewer;
cairo_surface_t *source;
GtkWidget *options;
int width, height;
GtkAllocation allocation;
GtkWidget *filter_grid;
self = (GthFileToolAdjustContrast *) base;
window = gth_file_tool_get_window (base);
viewer_page = gth_browser_get_viewer_page (GTH_BROWSER (window));
if (! GTH_IS_IMAGE_VIEWER_PAGE (viewer_page))
return NULL;
_cairo_clear_surface (&self->priv->preview);
_cairo_clear_surface (&self->priv->destination);
viewer = gth_image_viewer_page_get_image_viewer (GTH_IMAGE_VIEWER_PAGE (viewer_page));
source = gth_image_viewer_page_tool_get_source (GTH_IMAGE_VIEWER_PAGE_TOOL (self));
if (source == NULL)
return NULL;
width = cairo_image_surface_get_width (source);
height = cairo_image_surface_get_height (source);
gtk_widget_get_allocation (GTK_WIDGET (viewer), &allocation);
if (scale_keeping_ratio (&width, &height, PREVIEW_SIZE * allocation.width, PREVIEW_SIZE * allocation.height, FALSE))
self->priv->preview = _cairo_image_surface_scale_fast (source, width, height);
else
self->priv->preview = cairo_surface_reference (source);
self->priv->destination = cairo_surface_reference (self->priv->preview);
self->priv->apply_to_original = FALSE;
self->priv->closing = FALSE;
self->priv->builder = _gtk_builder_new_from_file ("adjust-contrast-options.ui", "file_tools");
options = _gtk_builder_get_widget (self->priv->builder, "options");
gtk_widget_show (options);
filter_grid = gth_filter_grid_new ();
gth_filter_grid_add_filter (GTH_FILTER_GRID (filter_grid),
METHOD_STRETCH_0_5,
get_image_task_for_method (METHOD_STRETCH_0_5),
_("Stretch"),
_("Stretch the histogram trimming the 0.5%"));
gth_filter_grid_add_filter (GTH_FILTER_GRID (filter_grid),
METHOD_EQUALIZE_SQUARE_ROOT,
get_image_task_for_method (METHOD_EQUALIZE_SQUARE_ROOT),
_("Equalize"),
_("Equalize the histogram using the square root function"));
gth_filter_grid_add_filter (GTH_FILTER_GRID (filter_grid),
METHOD_EQUALIZE_LINEAR,
get_image_task_for_method (METHOD_EQUALIZE_LINEAR),
_("Uniform"),
_("Equalize the histogram using the linear function"));
g_signal_connect (filter_grid,
"activated",
G_CALLBACK (filter_grid_activated_cb),
self);
gtk_widget_show (filter_grid);
gtk_box_pack_start (GTK_BOX (GET_WIDGET ("filter_grid_box")), filter_grid, TRUE, FALSE, 0);
self->priv->preview_tool = gth_preview_tool_new ();
gth_preview_tool_set_image (GTH_PREVIEW_TOOL (self->priv->preview_tool), self->priv->preview);
gth_image_viewer_set_tool (GTH_IMAGE_VIEWER (viewer), self->priv->preview_tool);
gth_filter_grid_activate (GTH_FILTER_GRID (filter_grid), METHOD_STRETCH_0_5);
gth_filter_grid_generate_previews (GTH_FILTER_GRID (filter_grid), source);
return options;
}
GthImage *
_cairo_image_surface_create_from_webp (GInputStream *istream,
GthFileData *file_data,
int requested_size,
int *original_width,
int *original_height,
gboolean *loaded_original,
gpointer user_data,
GCancellable *cancellable,
GError **error)
{
GthImage *image;
WebPDecoderConfig config;
guchar *buffer;
gssize bytes_read;
int width, height;
cairo_surface_t *surface;
cairo_surface_metadata_t *metadata;
WebPIDecoder *idec;
image = gth_image_new ();
if (! WebPInitDecoderConfig (&config))
return image;
buffer = g_new (guchar, BUFFER_SIZE);
bytes_read = g_input_stream_read (istream,
buffer,
BUFFER_SIZE,
cancellable,
error);
if (WebPGetFeatures (buffer, bytes_read, &config.input) != VP8_STATUS_OK) {
g_free (buffer);
return image;
}
width = config.input.width;
height = config.input.height;
if (original_width != NULL)
*original_width = width;
if (original_height != NULL)
*original_height = height;
#if SCALING_WORKS
if (requested_size > 0)
scale_keeping_ratio (&width, &height, requested_size, requested_size, FALSE);
#endif
surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, width, height);
metadata = _cairo_image_surface_get_metadata (surface);
_cairo_metadata_set_has_alpha (metadata, config.input.has_alpha);
config.options.no_fancy_upsampling = 1;
#if SCALING_WORKS
if (requested_size > 0) {
config.options.use_scaling = 1;
config.options.scaled_width = width;
config.options.scaled_height = height;
}
#endif
#if G_BYTE_ORDER == G_LITTLE_ENDIAN
config.output.colorspace = MODE_BGRA;
#elif G_BYTE_ORDER == G_BIG_ENDIAN
config.output.colorspace = MODE_ARGB;
#endif
config.output.u.RGBA.rgba = (uint8_t *) _cairo_image_surface_flush_and_get_data (surface);
config.output.u.RGBA.stride = cairo_image_surface_get_stride (surface);
config.output.u.RGBA.size = cairo_image_surface_get_stride (surface) * height;
config.output.is_external_memory = 1;
idec = WebPINewDecoder (&config.output);
if (idec == NULL) {
g_free (buffer);
return image;
}
do {
VP8StatusCode status = WebPIAppend (idec, buffer, bytes_read);
if ((status != VP8_STATUS_OK) && (status != VP8_STATUS_SUSPENDED))
break;
}
while ((bytes_read = g_input_stream_read (istream,
buffer,
BUFFER_SIZE,
cancellable,
error)) > 0);
cairo_surface_mark_dirty (surface);
if (cairo_surface_status (surface) == CAIRO_STATUS_SUCCESS)
gth_image_set_cairo_surface (image, surface);
WebPIDelete (idec);
WebPFreeDecBuffer (&config.output);
g_free (buffer);
return image;
}
static GtkWidget *
gth_file_tool_grayscale_get_options (GthFileTool *base)
{
GthFileToolGrayscale *self;
GtkWidget *window;
GtkWidget *viewer_page;
GtkWidget *viewer;
cairo_surface_t *source;
GtkWidget *options;
int width, height;
GtkAllocation allocation;
self = (GthFileToolGrayscale *) base;
window = gth_file_tool_get_window (base);
viewer_page = gth_browser_get_viewer_page (GTH_BROWSER (window));
if (! GTH_IS_IMAGE_VIEWER_PAGE (viewer_page))
return NULL;
cairo_surface_destroy (self->priv->destination);
cairo_surface_destroy (self->priv->preview);
viewer = gth_image_viewer_page_get_image_viewer (GTH_IMAGE_VIEWER_PAGE (viewer_page));
source = gth_image_viewer_page_tool_get_source (GTH_IMAGE_VIEWER_PAGE_TOOL (self));
if (source == NULL)
return NULL;
width = cairo_image_surface_get_width (source);
height = cairo_image_surface_get_height (source);
gtk_widget_get_allocation (GTK_WIDGET (viewer), &allocation);
if (scale_keeping_ratio (&width, &height, PREVIEW_SIZE * allocation.width, PREVIEW_SIZE * allocation.height, FALSE))
self->priv->preview = _cairo_image_surface_scale_bilinear (source, width, height);
else
self->priv->preview = cairo_surface_reference (source);
self->priv->destination = cairo_surface_reference (self->priv->preview);
self->priv->apply_to_original = FALSE;
self->priv->closing = FALSE;
self->priv->builder = _gtk_builder_new_from_file ("grayscale-options.ui", "file_tools");
options = _gtk_builder_get_widget (self->priv->builder, "options");
gtk_widget_show (options);
g_signal_connect (GET_WIDGET ("ok_button"),
"clicked",
G_CALLBACK (ok_button_clicked_cb),
self);
g_signal_connect_swapped (GET_WIDGET ("cancel_button"),
"clicked",
G_CALLBACK (gth_file_tool_cancel),
self);
g_signal_connect (GET_WIDGET ("brightness_radiobutton"),
"clicked",
G_CALLBACK (method_changed_cb),
self);
g_signal_connect (GET_WIDGET ("saturation_radiobutton"),
"clicked",
G_CALLBACK (method_changed_cb),
self);
g_signal_connect (GET_WIDGET ("average_radiobutton"),
"clicked",
G_CALLBACK (method_changed_cb),
self);
g_signal_connect (GET_WIDGET ("preview_checkbutton"),
"toggled",
G_CALLBACK (preview_checkbutton_toggled_cb),
self);
self->priv->preview_tool = gth_preview_tool_new ();
gth_preview_tool_set_image (GTH_PREVIEW_TOOL (self->priv->preview_tool), self->priv->preview);
gth_image_viewer_set_tool (GTH_IMAGE_VIEWER (viewer), self->priv->preview_tool);
apply_changes (self);
return options;
}
static GtkWidget *
gth_file_tool_resize_get_options (GthFileTool *base)
{
GthFileToolResize *self = (GthFileToolResize *) base;
cairo_surface_t *source;
GtkWidget *window;
GtkWidget *viewer_page;
GtkWidget *viewer;
GtkAllocation allocation;
int preview_width;
int preview_height;
GtkWidget *options;
char *text;
source = gth_image_viewer_page_tool_get_source (GTH_IMAGE_VIEWER_PAGE_TOOL (self));
if (source == NULL)
return NULL;
self->priv->original_width = cairo_image_surface_get_width (source);
self->priv->original_height = cairo_image_surface_get_height (source);
window = gth_file_tool_get_window (base);
viewer_page = gth_browser_get_viewer_page (GTH_BROWSER (window));
viewer = gth_image_viewer_page_get_image_viewer (GTH_IMAGE_VIEWER_PAGE (viewer_page));
gtk_widget_get_allocation (GTK_WIDGET (viewer), &allocation);
preview_width = self->priv->original_width;
preview_height = self->priv->original_height;
if (scale_keeping_ratio (&preview_width, &preview_height, allocation.width, allocation.height, FALSE))
self->priv->preview = _cairo_image_surface_scale_fast (source, preview_width, preview_height);
else
self->priv->preview = cairo_surface_reference (source);
_gtk_widget_get_screen_size (window, &self->priv->screen_width, &self->priv->screen_height);
self->priv->new_image = NULL;
self->priv->new_width = self->priv->original_width;
self->priv->new_height = self->priv->original_height;
self->priv->high_quality = g_settings_get_boolean (self->priv->settings, PREF_RESIZE_HIGH_QUALITY);
self->priv->unit = g_settings_get_enum (self->priv->settings, PREF_RESIZE_UNIT);
self->priv->builder = _gtk_builder_new_from_file ("resize-options.ui", "file_tools");
self->priv->apply_to_original = FALSE;
update_dimensione_info_label (self,
"original_dimensions_label",
self->priv->original_width,
self->priv->original_height,
TRUE);
options = _gtk_builder_get_widget (self->priv->builder, "options");
gtk_widget_show (options);
if (self->priv->unit == GTH_UNIT_PIXELS) {
gtk_spin_button_set_digits (GTK_SPIN_BUTTON (GET_WIDGET ("resize_width_spinbutton")), 0);
gtk_spin_button_set_digits (GTK_SPIN_BUTTON (GET_WIDGET ("resize_height_spinbutton")), 0);
gtk_spin_button_set_value (GTK_SPIN_BUTTON (GET_WIDGET ("resize_width_spinbutton")),
g_settings_get_double (self->priv->settings, PREF_RESIZE_WIDTH));
gtk_spin_button_set_value (GTK_SPIN_BUTTON (GET_WIDGET ("resize_height_spinbutton")),
g_settings_get_double (self->priv->settings, PREF_RESIZE_HEIGHT));
}
else if (self->priv->unit == GTH_UNIT_PERCENTAGE) {
gtk_spin_button_set_digits (GTK_SPIN_BUTTON (GET_WIDGET ("resize_width_spinbutton")), 2);
gtk_spin_button_set_digits (GTK_SPIN_BUTTON (GET_WIDGET ("resize_height_spinbutton")), 2);
gtk_spin_button_set_value (GTK_SPIN_BUTTON (GET_WIDGET ("resize_width_spinbutton")),
g_settings_get_double (self->priv->settings, PREF_RESIZE_WIDTH));
gtk_spin_button_set_value (GTK_SPIN_BUTTON (GET_WIDGET ("resize_height_spinbutton")),
g_settings_get_double (self->priv->settings, PREF_RESIZE_HEIGHT));
}
gtk_combo_box_set_active (GTK_COMBO_BOX (GET_WIDGET ("unit_combobox")), self->priv->unit);
self->priv->ratio_combobox = _gtk_combo_box_new_with_texts (_("None"), _("Square"), NULL);
text = g_strdup_printf (_("%d x %d (Image)"), self->priv->original_width, self->priv->original_height);
gtk_label_set_text (GTK_LABEL (GET_WIDGET ("image_size_label")), text);
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (self->priv->ratio_combobox), text);
g_free (text);
text = g_strdup_printf (_("%d x %d (Screen)"), self->priv->screen_width, self->priv->screen_height);
gtk_label_set_text (GTK_LABEL (GET_WIDGET ("screen_size_label")), text);
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (self->priv->ratio_combobox), text);
g_free (text);
_gtk_combo_box_append_texts (GTK_COMBO_BOX_TEXT (self->priv->ratio_combobox),
_("5:4"),
_("4:3 (DVD, Book)"),
_("7:5"),
_("3:2 (Postcard)"),
_("16:10"),
_("16:9 (DVD)"),
_("1.85:1"),
_("2.39:1"),
_("Custom"),
NULL);
gtk_widget_show (self->priv->ratio_combobox);
gtk_box_pack_start (GTK_BOX (GET_WIDGET ("ratio_combobox_box")), self->priv->ratio_combobox, TRUE, TRUE, 0);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (GET_WIDGET ("high_quality_checkbutton")),
self->priv->high_quality);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (GET_WIDGET ("invert_ratio_checkbutton")),
g_settings_get_boolean (self->priv->settings, PREF_RESIZE_ASPECT_RATIO_INVERT));
gtk_spin_button_set_value (GTK_SPIN_BUTTON (GET_WIDGET ("ratio_w_spinbutton")),
MAX (g_settings_get_int (self->priv->settings, PREF_RESIZE_ASPECT_RATIO_WIDTH), 1));
gtk_spin_button_set_value (GTK_SPIN_BUTTON (GET_WIDGET ("ratio_h_spinbutton")),
MAX (g_settings_get_int (self->priv->settings, PREF_RESIZE_ASPECT_RATIO_HEIGHT), 1));
g_signal_connect_swapped (GET_WIDGET ("options_close_button"),
"clicked",
G_CALLBACK (gtk_widget_hide),
GET_WIDGET ("options_dialog"));
g_signal_connect (GET_WIDGET ("options_dialog"),
"delete-event",
G_CALLBACK (gtk_widget_hide_on_delete),
NULL);
g_signal_connect (GET_WIDGET ("resize_width_spinbutton"),
"value-changed",
G_CALLBACK (selection_width_value_changed_cb),
self);
g_signal_connect (GET_WIDGET ("resize_height_spinbutton"),
"value-changed",
G_CALLBACK (selection_height_value_changed_cb),
self);
g_signal_connect (GET_WIDGET ("high_quality_checkbutton"),
"toggled",
G_CALLBACK (high_quality_checkbutton_toggled_cb),
self);
g_signal_connect (GET_WIDGET ("unit_combobox"),
"changed",
G_CALLBACK (unit_combobox_changed_cb),
self);
g_signal_connect (self->priv->ratio_combobox,
"changed",
G_CALLBACK (ratio_combobox_changed_cb),
self);
g_signal_connect (GET_WIDGET ("ratio_w_spinbutton"),
"value_changed",
G_CALLBACK (ratio_value_changed_cb),
self);
g_signal_connect (GET_WIDGET ("ratio_h_spinbutton"),
"value_changed",
G_CALLBACK (ratio_value_changed_cb),
self);
g_signal_connect (GET_WIDGET ("invert_ratio_checkbutton"),
"toggled",
G_CALLBACK (invert_ratio_changed_cb),
self);
g_signal_connect (GET_WIDGET ("image_size_button"),
"clicked",
G_CALLBACK (image_size_button_clicked_cb),
self);
g_signal_connect (GET_WIDGET ("screen_size_button"),
"clicked",
G_CALLBACK (screen_size_button_clicked_cb),
self);
gtk_combo_box_set_active (GTK_COMBO_BOX (self->priv->ratio_combobox),
g_settings_get_enum (self->priv->settings, PREF_RESIZE_ASPECT_RATIO));
gth_image_viewer_set_zoom_quality (GTH_IMAGE_VIEWER (viewer), GTH_ZOOM_QUALITY_HIGH);
return options;
}
gboolean
_g_buffer_resize_image (void *buffer,
gsize count,
GthFileData *file_data,
int max_width,
int max_height,
void **resized_buffer,
gsize *resized_count,
GCancellable *cancellable,
GError **error)
{
GInputStream *istream;
const char *mime_type;
GthImageLoaderFunc loader_func;
GthImage *image;
int width;
int height;
cairo_surface_t *surface;
cairo_surface_t *scaled;
gboolean result;
if ((max_width == -1) || (max_height == -1)) {
*error = NULL;
return FALSE;
}
istream = g_memory_input_stream_new_from_data (buffer, count, NULL);
mime_type = _g_content_type_get_from_stream (istream, (file_data != NULL ? file_data->file : NULL), cancellable, NULL);
if (mime_type == NULL) {
g_set_error (error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED, "%s", _("No suitable loader available for this file type"));
return FALSE;
}
loader_func = gth_main_get_image_loader_func (mime_type, GTH_IMAGE_FORMAT_CAIRO_SURFACE);
if (loader_func == NULL) {
g_set_error (error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED, "%s", _("No suitable loader available for this file type"));
g_object_unref (istream);
return FALSE;
}
image = loader_func (istream,
NULL,
-1,
&width,
&height,
NULL,
cancellable,
error);
if (image == NULL) {
g_object_unref (istream);
return FALSE;
}
if (! scale_keeping_ratio (&width, &height, max_width, max_height, FALSE)) {
error = NULL;
g_object_unref (image);
g_object_unref (istream);
return FALSE;
}
surface = gth_image_get_cairo_surface (image);
scaled = _cairo_image_surface_scale (surface, width, height, SCALE_FILTER_BEST, NULL);
gth_image_set_cairo_surface (image, scaled);
result = gth_image_save_to_buffer (image,
mime_type,
file_data,
(char **) resized_buffer,
resized_count,
cancellable,
error);
cairo_surface_destroy (scaled);
cairo_surface_destroy (surface);
g_object_unref (image);
g_object_unref (istream);
return result;
}
