*
* Copyright 2025 Alexander Vanhee
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*
* SPDX-License-Identifier: GPL-3.0-or-later
*/
#include "config.h"
#include "bz-screenshot-page.h"
#include "bz-screenshot.h"
#include "bz-zoom.h"
#include <glib/gi18n.h>
#define MOUSE_BACK_BUTTON 8
#define SPRING_DAMPING_RATIO 1.05
#define SPRING_MASS 1.0
#define SPRING_STIFFNESS 1000.0
#define FADE_DURATION_MS 350
struct _BzScreenshotPage
{
AdwBin parent_instance;
AdwCarousel *carousel;
AdwToastOverlay *toast_overlay;
GListModel *screenshots;
GListModel *captions;
guint current_index;
guint initial_index;
gboolean is_zoomed;
gboolean reduce_motion;
GtkWidget *source_widget;
GdkTexture *source_texture;
graphene_rect_t source_bounds_at_map;
AdwAnimation *animation;
double animation_progress;
gboolean closing;
};
G_DEFINE_FINAL_TYPE (BzScreenshotPage, bz_screenshot_page, ADW_TYPE_BIN)
enum
{
PROP_0,
PROP_SCREENSHOTS,
PROP_CURRENT_INDEX,
PROP_CURRENT_CAPTION,
PROP_IS_ZOOMED,
LAST_PROP
};
static GParamSpec *props[LAST_PROP] = { 0 };
static GdkTexture *render_widget_to_texture (GtkWidget *widget);
static void on_animation_value (AdwAnimation *animation,
GParamSpec *pspec,
BzScreenshotPage *self);
static void on_fade_animation_value (AdwAnimation *animation,
GParamSpec *pspec,
BzScreenshotPage *self);
static void on_close_animation_done (AdwAnimation *animation,
BzScreenshotPage *self);
static void on_zoom_level_changed (BzZoom *zoom,
GParamSpec *pspec,
BzScreenshotPage *self);
static void update_is_zoomed (BzScreenshotPage *self);
static BzZoom *get_current_zoom (BzScreenshotPage *self,
GtkScrolledWindow **scrolled_window);
static void populate_carousel (BzScreenshotPage *self);
static void on_button_pressed (GtkGestureClick *gesture,
int n_press,
double x,
double y,
BzScreenshotPage *self);
static void on_swipe (BzScreenshotPage *self,
gdouble vel_x,
gdouble vel_y);
static gboolean on_scroll (BzScreenshotPage *self,
gdouble dx,
gdouble dy,
GtkEventControllerScroll *controller);
static void
bz_screenshot_page_map (GtkWidget *widget)
{
BzScreenshotPage *self = BZ_SCREENSHOT_PAGE (widget);
AdwAnimationTarget *target = NULL;
AdwSpringParams *params = NULL;
GtkSettings *settings = NULL;
GtkReducedMotion reduced_motion = GTK_REDUCED_MOTION_NO_PREFERENCE;
GTK_WIDGET_CLASS (bz_screenshot_page_parent_class)->map (widget);
gtk_widget_child_focus (widget, GTK_DIR_TAB_FORWARD);
settings = gtk_widget_get_settings (widget);
g_object_get (settings, "gtk-interface-reduced-motion", &reduced_motion, NULL);
self->reduce_motion = reduced_motion != GTK_REDUCED_MOTION_NO_PREFERENCE;
self->closing = FALSE;
if (self->reduce_motion)
{
self->animation_progress = 1.0;
g_clear_object (&self->source_texture);
gtk_widget_set_opacity (widget, 0.0);
target = adw_callback_animation_target_new (
(AdwAnimationTargetFunc) gtk_widget_queue_draw, self, NULL);
self->animation = adw_timed_animation_new (widget, 0.0, 1.0, FADE_DURATION_MS, target);
g_signal_connect (self->animation, "notify::value",
G_CALLBACK (on_fade_animation_value), self);
adw_animation_play (self->animation);
return;
}
if (self->source_widget != NULL)
{
self->source_texture = render_widget_to_texture (self->source_widget);
if (!gtk_widget_compute_bounds (self->source_widget, widget, &self->source_bounds_at_map))
graphene_rect_init (&self->source_bounds_at_map, 0, 0,
gtk_widget_get_width (widget), gtk_widget_get_height (widget));
gtk_widget_set_opacity (self->source_widget, 0.0);
}
self->animation_progress = 0.0;
target = adw_callback_animation_target_new ((AdwAnimationTargetFunc) gtk_widget_queue_draw, self, NULL);
params = adw_spring_params_new (SPRING_DAMPING_RATIO, SPRING_MASS, SPRING_STIFFNESS);
self->animation = adw_spring_animation_new (widget, 0.0, 1.0, params, target);
adw_spring_animation_set_clamp (ADW_SPRING_ANIMATION (self->animation), TRUE);
adw_spring_animation_set_epsilon (ADW_SPRING_ANIMATION (self->animation), 0.0001);
adw_spring_animation_set_initial_velocity (ADW_SPRING_ANIMATION (self->animation), -1.2);
g_signal_connect (self->animation, "notify::value", G_CALLBACK (on_animation_value), self);
adw_animation_play (self->animation);
}
static void
bz_screenshot_page_unmap (GtkWidget *widget)
{
BzScreenshotPage *self = BZ_SCREENSHOT_PAGE (widget);
if (self->source_widget != NULL && !self->closing)
gtk_widget_set_opacity (self->source_widget, 1.0);
GTK_WIDGET_CLASS (bz_screenshot_page_parent_class)->unmap (widget);
}
static void
bz_screenshot_page_snapshot (GtkWidget *widget, GtkSnapshot *snapshot)
{
BzScreenshotPage *self = BZ_SCREENSHOT_PAGE (widget);
double progress = 0.0;
int width = 0;
int height = 0;
float rev = 0.0f;
float x = 0.0f;
float y = 0.0f;
float w = 0.0f;
float h = 0.0f;
graphene_rect_t lerped;
graphene_rect_t source_bounds;
progress = self->animation_progress;
width = gtk_widget_get_width (widget);
height = gtk_widget_get_height (widget);
if (self->source_texture == NULL || progress >= 1.0)
{
GTK_WIDGET_CLASS (bz_screenshot_page_parent_class)->snapshot (widget, snapshot);
return;
}
if (self->source_widget != NULL &&
!gtk_widget_compute_bounds (self->source_widget, widget, &source_bounds))
source_bounds = self->source_bounds_at_map;
else if (self->source_widget == NULL)
source_bounds = self->source_bounds_at_map;
rev = (float) (1.0 - progress);
x = source_bounds.origin.x * rev + 0.0f * (float) progress;
y = source_bounds.origin.y * rev + 0.0f * (float) progress;
w = source_bounds.size.width * rev + (float) width * (float) progress;
h = source_bounds.size.height * rev + (float) height * (float) progress;
graphene_rect_init (&lerped, x, y, w, h);
gtk_snapshot_push_clip (snapshot, &lerped);
gtk_snapshot_push_cross_fade (snapshot, progress);
gtk_snapshot_save (snapshot);
gtk_snapshot_translate (snapshot, &GRAPHENE_POINT_INIT (x, y));
gtk_snapshot_scale (snapshot,
w / source_bounds.size.width,
h / source_bounds.size.height);
gdk_paintable_snapshot (GDK_PAINTABLE (self->source_texture), snapshot,
source_bounds.size.width,
source_bounds.size.height);
gtk_snapshot_restore (snapshot);
gtk_snapshot_pop (snapshot);
gtk_snapshot_save (snapshot);
gtk_snapshot_translate (snapshot, &GRAPHENE_POINT_INIT (x, y));
gtk_snapshot_scale (snapshot,
w / (float) width,
h / (float) height);
GTK_WIDGET_CLASS (bz_screenshot_page_parent_class)->snapshot (widget, snapshot);
gtk_snapshot_restore (snapshot);
gtk_snapshot_pop (snapshot);
gtk_snapshot_pop (snapshot);
}
static void
back_clicked (BzScreenshotPage *self)
{
AdwAnimationTarget *target = NULL;
AdwSpringParams *params = NULL;
GtkWidget *parent = NULL;
if (self->closing)
return;
if (self->source_widget != NULL)
{
self->closing = TRUE;
gtk_widget_set_can_target (GTK_WIDGET (self), FALSE);
if (self->animation != NULL)
{
g_signal_handlers_disconnect_by_func (self->animation, on_animation_value, self);
g_signal_handlers_disconnect_by_func (self->animation, on_fade_animation_value, self);
g_clear_object (&self->animation);
}
target = adw_callback_animation_target_new (
(AdwAnimationTargetFunc) gtk_widget_queue_draw, self, NULL);
if (self->reduce_motion)
{
self->animation = adw_timed_animation_new (
GTK_WIDGET (self), gtk_widget_get_opacity (GTK_WIDGET (self)), 0.0,
FADE_DURATION_MS, target);
g_signal_connect (self->animation, "notify::value",
G_CALLBACK (on_fade_animation_value), self);
}
else
{
params = adw_spring_params_new (SPRING_DAMPING_RATIO, SPRING_MASS, SPRING_STIFFNESS);
self->animation = adw_spring_animation_new (
GTK_WIDGET (self), self->animation_progress, 0.0, params, target);
adw_spring_animation_set_clamp (ADW_SPRING_ANIMATION (self->animation), TRUE);
adw_spring_animation_set_epsilon (ADW_SPRING_ANIMATION (self->animation), 0.0001);
adw_spring_animation_set_initial_velocity (ADW_SPRING_ANIMATION (self->animation), -1.2);
g_signal_connect (self->animation, "notify::value", G_CALLBACK (on_animation_value), self);
}
g_signal_connect (self->animation, "done", G_CALLBACK (on_close_animation_done), self);
adw_animation_play (self->animation);
}
else
{
if (self->source_widget != NULL)
gtk_widget_set_opacity (self->source_widget, 1.0);
parent = gtk_widget_get_parent (GTK_WIDGET (self));
if (parent != NULL)
gtk_overlay_remove_overlay (GTK_OVERLAY (parent), GTK_WIDGET (self));
}
}
static void
zoom_in_clicked (GtkWidget *widget,
const char *action_name,
GVariant *parameter)
{
BzScreenshotPage *self = BZ_SCREENSHOT_PAGE (widget);
BzZoom *zoom = NULL;
zoom = get_current_zoom (self, NULL);
if (zoom != NULL)
bz_zoom_zoom_in (zoom);
}
static void
zoom_out_clicked (GtkWidget *widget,
const char *action_name,
GVariant *parameter)
{
BzScreenshotPage *self = BZ_SCREENSHOT_PAGE (widget);
BzZoom *zoom = NULL;
zoom = get_current_zoom (self, NULL);
if (zoom != NULL)
bz_zoom_zoom_out (zoom);
}
static void
reset_zoom_clicked (GtkWidget *widget,
const char *action_name,
GVariant *parameter)
{
BzScreenshotPage *self = BZ_SCREENSHOT_PAGE (widget);
BzZoom *zoom = NULL;
zoom = get_current_zoom (self, NULL);
if (zoom != NULL)
bz_zoom_reset (zoom);
}
static void
previous_clicked (GtkWidget *widget,
const char *action_name,
GVariant *parameter)
{
BzScreenshotPage *self = BZ_SCREENSHOT_PAGE (widget);
guint n_pages = 0;
GtkWidget *page = NULL;
n_pages = adw_carousel_get_n_pages (self->carousel);
if (n_pages == 0)
return;
if (self->current_index > 0)
page = adw_carousel_get_nth_page (self->carousel, self->current_index - 1);
else
page = adw_carousel_get_nth_page (self->carousel, n_pages - 1);
if (page != NULL)
adw_carousel_scroll_to (self->carousel, page, TRUE);
}
static void
next_clicked (GtkWidget *widget,
const char *action_name,
GVariant *parameter)
{
BzScreenshotPage *self = BZ_SCREENSHOT_PAGE (widget);
guint n_pages = 0;
GtkWidget *page = NULL;
n_pages = adw_carousel_get_n_pages (self->carousel);
if (n_pages == 0)
return;
if (self->current_index < n_pages - 1)
page = adw_carousel_get_nth_page (self->carousel, self->current_index + 1);
else
page = adw_carousel_get_nth_page (self->carousel, 0);
if (page != NULL)
adw_carousel_scroll_to (self->carousel, page, TRUE);
}
static void
on_carousel_position_changed (AdwCarousel *carousel,
GParamSpec *pspec,
BzScreenshotPage *self)
{
GtkScrolledWindow *old_scrolled_window = NULL;
BzZoom *old_zoom = NULL;
BzZoom *new_zoom = NULL;
guint new_index = 0;
guint n_pages = 0;
new_index = (guint) round (adw_carousel_get_position (carousel));
n_pages = adw_carousel_get_n_pages (carousel);
if (new_index == self->current_index || new_index >= n_pages)
return;
old_zoom = get_current_zoom (self, &old_scrolled_window);
if (old_zoom != NULL)
{
g_signal_handlers_disconnect_by_func (old_zoom, on_zoom_level_changed, self);
bz_zoom_reset (old_zoom);
gtk_scrolled_window_set_policy (old_scrolled_window, GTK_POLICY_NEVER, GTK_POLICY_NEVER);
}
self->current_index = new_index;
new_zoom = get_current_zoom (self, NULL);
g_assert (new_zoom != NULL);
g_signal_connect (new_zoom, "notify::zoom-level",
G_CALLBACK (on_zoom_level_changed), self);
update_is_zoomed (self);
g_object_notify_by_pspec (G_OBJECT (self), props[PROP_CURRENT_INDEX]);
g_object_notify_by_pspec (G_OBJECT (self), props[PROP_CURRENT_CAPTION]);
}
static void
copy_clicked (GtkWidget *widget,
const char *action_name,
GVariant *parameter)
{
BzScreenshotPage *self = BZ_SCREENSHOT_PAGE (widget);
g_autoptr (BzAsyncTexture) async_texture = NULL;
g_autoptr (GdkTexture) texture = NULL;
GdkClipboard *clipboard = NULL;
AdwToast *toast = NULL;
guint n_items = 0;
guint actual_index = 0;
if (self->screenshots == NULL)
return;
n_items = g_list_model_get_n_items (self->screenshots);
if (n_items == 0)
return;
actual_index = (self->initial_index + self->current_index) % n_items;
async_texture = g_list_model_get_item (self->screenshots, actual_index);
if (async_texture == NULL)
return;
texture = bz_async_texture_dup_texture (async_texture);
if (texture == NULL)
return;
clipboard = gdk_display_get_clipboard (gdk_display_get_default ());
gdk_clipboard_set_texture (clipboard, texture);
toast = adw_toast_new (_ ("Copied!"));
adw_toast_set_timeout (toast, 1);
adw_toast_overlay_add_toast (self->toast_overlay, toast);
}
static void
on_zoom_level_changed (BzZoom *zoom,
GParamSpec *pspec,
BzScreenshotPage *self)
{
update_is_zoomed (self);
}
static gboolean
has_multiple_screenshots (GObject *object,
GListModel *screenshots,
gpointer user_data)
{
if (screenshots == NULL)
return FALSE;
return g_list_model_get_n_items (screenshots) > 1;
}
static gboolean
invert_boolean (gpointer object,
gboolean value)
{
return !value;
}
static gboolean
is_valid_string (gpointer object,
const char *value)
{
return value != NULL && *value != '\0';
}
static void
bz_screenshot_page_dispose (GObject *object)
{
BzScreenshotPage *self = BZ_SCREENSHOT_PAGE (object);
g_clear_object (&self->screenshots);
g_clear_object (&self->captions);
g_clear_object (&self->source_texture);
g_clear_object (&self->animation);
G_OBJECT_CLASS (bz_screenshot_page_parent_class)->dispose (object);
}
static void
bz_screenshot_page_get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
BzScreenshotPage *self = BZ_SCREENSHOT_PAGE (object);
switch (prop_id)
{
case PROP_SCREENSHOTS:
g_value_set_object (value, self->screenshots);
break;
case PROP_CURRENT_INDEX:
g_value_set_uint (value, self->current_index);
break;
case PROP_CURRENT_CAPTION:
{
const char *caption = NULL;
caption = bz_screenshot_page_get_current_caption (self);
g_value_set_string (value, caption);
}
break;
case PROP_IS_ZOOMED:
g_value_set_boolean (value, self->is_zoomed);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
}
}
static void
bz_screenshot_page_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
BzScreenshotPage *self = BZ_SCREENSHOT_PAGE (object);
switch (prop_id)
{
case PROP_SCREENSHOTS:
g_set_object (&self->screenshots, g_value_get_object (value));
break;
case PROP_CURRENT_INDEX:
self->initial_index = g_value_get_uint (value);
break;
case PROP_CURRENT_CAPTION:
case PROP_IS_ZOOMED:
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
}
}
static void
bz_screenshot_page_constructed (GObject *object)
{
BzScreenshotPage *self = BZ_SCREENSHOT_PAGE (object);
BzZoom *first_zoom = NULL;
G_OBJECT_CLASS (bz_screenshot_page_parent_class)->constructed (object);
populate_carousel (self);
self->current_index = 0;
first_zoom = get_current_zoom (self, NULL);
if (first_zoom != NULL)
g_signal_connect (first_zoom, "notify::zoom-level",
G_CALLBACK (on_zoom_level_changed), self);
update_is_zoomed (self);
g_object_notify_by_pspec (G_OBJECT (self), props[PROP_CURRENT_CAPTION]);
}
static void
bz_screenshot_page_class_init (BzScreenshotPageClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
object_class->dispose = bz_screenshot_page_dispose;
object_class->constructed = bz_screenshot_page_constructed;
object_class->get_property = bz_screenshot_page_get_property;
object_class->set_property = bz_screenshot_page_set_property;
widget_class->map = bz_screenshot_page_map;
widget_class->unmap = bz_screenshot_page_unmap;
widget_class->snapshot = bz_screenshot_page_snapshot;
props[PROP_SCREENSHOTS] =
g_param_spec_object (
"screenshots",
NULL, NULL,
G_TYPE_LIST_MODEL,
G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY);
props[PROP_CURRENT_INDEX] =
g_param_spec_uint (
"current-index",
NULL, NULL,
0, G_MAXUINT, 0,
G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY);
props[PROP_CURRENT_CAPTION] =
g_param_spec_string (
"current-caption",
NULL, NULL,
NULL,
G_PARAM_READABLE | G_PARAM_STATIC_STRINGS | G_PARAM_EXPLICIT_NOTIFY);
props[PROP_IS_ZOOMED] =
g_param_spec_boolean (
"is-zoomed",
NULL, NULL,
FALSE,
G_PARAM_READABLE | G_PARAM_STATIC_STRINGS | G_PARAM_EXPLICIT_NOTIFY);
g_object_class_install_properties (object_class, LAST_PROP, props);
g_type_ensure (BZ_TYPE_ZOOM);
gtk_widget_class_set_template_from_resource (widget_class, "/io/github/kolunmi/Bazaar/bz-screenshot-page.ui");
gtk_widget_class_bind_template_child (widget_class, BzScreenshotPage, carousel);
gtk_widget_class_bind_template_child (widget_class, BzScreenshotPage, toast_overlay);
gtk_widget_class_bind_template_callback (widget_class, back_clicked);
gtk_widget_class_bind_template_callback (widget_class, on_carousel_position_changed);
gtk_widget_class_bind_template_callback (widget_class, has_multiple_screenshots);
gtk_widget_class_bind_template_callback (widget_class, invert_boolean);
gtk_widget_class_bind_template_callback (widget_class, is_valid_string);
gtk_widget_class_install_action (widget_class, "screenshot.previous", NULL, previous_clicked);
gtk_widget_class_install_action (widget_class, "screenshot.next", NULL, next_clicked);
gtk_widget_class_install_action (widget_class, "screenshot.zoom-in", NULL, zoom_in_clicked);
gtk_widget_class_install_action (widget_class, "screenshot.zoom-out", NULL, zoom_out_clicked);
gtk_widget_class_install_action (widget_class, "screenshot.zoom-reset", NULL, reset_zoom_clicked);
gtk_widget_class_install_action (widget_class, "screenshot.copy", NULL, copy_clicked);
}
static void
bz_screenshot_page_init (BzScreenshotPage *self)
{
GtkEventController *scroll = NULL;
GtkGesture *swipe = NULL;
GtkGesture *click = NULL;
gtk_widget_init_template (GTK_WIDGET (self));
swipe = gtk_gesture_swipe_new ();
gtk_event_controller_set_propagation_phase (GTK_EVENT_CONTROLLER (swipe), GTK_PHASE_CAPTURE);
g_signal_connect_swapped (swipe, "swipe", G_CALLBACK (on_swipe), self);
gtk_gesture_single_set_touch_only (GTK_GESTURE_SINGLE (swipe), TRUE);
gtk_widget_add_controller (GTK_WIDGET (self), GTK_EVENT_CONTROLLER (swipe));
click = gtk_gesture_click_new ();
gtk_gesture_single_set_button (GTK_GESTURE_SINGLE (click), 0);
gtk_event_controller_set_propagation_phase (GTK_EVENT_CONTROLLER (click), GTK_PHASE_CAPTURE);
g_signal_connect (click, "pressed", G_CALLBACK (on_button_pressed), self);
gtk_widget_add_controller (GTK_WIDGET (self), GTK_EVENT_CONTROLLER (click));
scroll = gtk_event_controller_scroll_new (GTK_EVENT_CONTROLLER_SCROLL_VERTICAL);
gtk_event_controller_set_propagation_phase (scroll, GTK_PHASE_BUBBLE);
g_signal_connect_swapped (scroll, "scroll", G_CALLBACK (on_scroll), self);
gtk_widget_add_controller (GTK_WIDGET (self), scroll);
}
const char *
bz_screenshot_page_get_current_caption (BzScreenshotPage *self)
{
g_autoptr (GtkStringObject) caption_obj = NULL;
guint n_items = 0;
guint actual_index = 0;
g_return_val_if_fail (BZ_IS_SCREENSHOT_PAGE (self), NULL);
if (self->captions == NULL)
return "";
n_items = g_list_model_get_n_items (self->captions);
if (n_items == 0)
return "";
actual_index = (self->initial_index + self->current_index) % n_items;
caption_obj = g_list_model_get_item (self->captions, actual_index);
if (caption_obj == NULL)
return "";
return gtk_string_object_get_string (caption_obj);
}
void
bz_screenshot_page_set_captions (BzScreenshotPage *self,
GListModel *captions)
{
g_return_if_fail (BZ_IS_SCREENSHOT_PAGE (self));
g_set_object (&self->captions, captions);
g_object_notify_by_pspec (G_OBJECT (self), props[PROP_CURRENT_CAPTION]);
}
void
bz_screenshot_page_close (BzScreenshotPage *self)
{
g_return_if_fail (BZ_IS_SCREENSHOT_PAGE (self));
back_clicked (self);
}
gboolean
bz_screenshot_page_is_closing (BzScreenshotPage *self)
{
return self->closing;
}
AdwBin *
bz_screenshot_page_new (GListModel *screenshots,
GListModel *captions,
guint initial_index,
GtkWidget *source_widget)
{
BzScreenshotPage *page = NULL;
page = g_object_new (
BZ_TYPE_SCREENSHOT_PAGE,
"screenshots", screenshots,
"current-index", initial_index,
NULL);
page->source_widget = source_widget;
if (captions != NULL)
bz_screenshot_page_set_captions (page, captions);
return ADW_BIN (page);
}
static GdkTexture *
render_widget_to_texture (GtkWidget *widget)
{
g_autoptr (GtkWidgetPaintable) paintable = NULL;
g_autoptr (GtkSnapshot) snapshot = NULL;
g_autoptr (GskRenderNode) node = NULL;
GtkNative *native = NULL;
GdkTexture *texture = NULL;
paintable = GTK_WIDGET_PAINTABLE (gtk_widget_paintable_new (widget));
snapshot = gtk_snapshot_new ();
gdk_paintable_snapshot (GDK_PAINTABLE (paintable), snapshot,
gdk_paintable_get_intrinsic_width (GDK_PAINTABLE (paintable)),
gdk_paintable_get_intrinsic_height (GDK_PAINTABLE (paintable)));
node = gtk_snapshot_to_node (snapshot);
native = gtk_widget_get_native (widget);
if (node != NULL && native != NULL)
texture = gsk_renderer_render_texture (
gtk_native_get_renderer (native), node, NULL);
return texture;
}
static void
on_animation_value (AdwAnimation *animation,
GParamSpec *pspec,
BzScreenshotPage *self)
{
self->animation_progress = adw_animation_get_value (animation);
gtk_widget_queue_draw (GTK_WIDGET (self));
}
static void
on_fade_animation_value (AdwAnimation *animation,
GParamSpec *pspec,
BzScreenshotPage *self)
{
gtk_widget_set_opacity (GTK_WIDGET (self), adw_animation_get_value (animation));
}
static void
on_close_animation_done (AdwAnimation *animation,
BzScreenshotPage *self)
{
GtkWidget *parent = NULL;
if (self->source_widget != NULL)
gtk_widget_set_opacity (self->source_widget, 1.0);
parent = gtk_widget_get_parent (GTK_WIDGET (self));
if (parent != NULL)
gtk_overlay_remove_overlay (GTK_OVERLAY (parent), GTK_WIDGET (self));
}
static void
populate_carousel (BzScreenshotPage *self)
{
guint n_items = 0;
guint i = 0;
if (self->screenshots == NULL)
return;
n_items = g_list_model_get_n_items (self->screenshots);
if (n_items == 0)
return;
for (guint offset = 0; offset < n_items; offset++)
{
g_autoptr (BzAsyncTexture) async_texture = NULL;
GtkWidget *scrolled_window = NULL;
GtkWidget *zoom_widget = NULL;
GtkWidget *screenshot = NULL;
i = (self->initial_index + offset) % n_items;
async_texture = g_list_model_get_item (self->screenshots, i);
if (async_texture == NULL)
continue;
screenshot = bz_screenshot_new ();
bz_screenshot_set_paintable (BZ_SCREENSHOT (screenshot), GDK_PAINTABLE (async_texture));
bz_screenshot_set_rounded_corners (BZ_SCREENSHOT (screenshot), FALSE);
gtk_widget_set_margin_top (screenshot, 25);
gtk_widget_set_margin_bottom (screenshot, 25);
gtk_widget_set_margin_start (screenshot, 25);
gtk_widget_set_margin_end (screenshot, 25);
zoom_widget = bz_zoom_new ();
bz_zoom_set_child (BZ_ZOOM (zoom_widget), screenshot);
scrolled_window = gtk_scrolled_window_new ();
gtk_widget_set_hexpand (scrolled_window, TRUE);
gtk_widget_set_vexpand (scrolled_window, TRUE);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window), GTK_POLICY_NEVER, GTK_POLICY_NEVER);
gtk_scrolled_window_set_child (GTK_SCROLLED_WINDOW (scrolled_window), zoom_widget);
adw_carousel_append (self->carousel, scrolled_window);
}
}
static void
update_is_zoomed (BzScreenshotPage *self)
{
GtkWidget *screenshot = NULL;
BzZoom *zoom = NULL;
GtkScrolledWindow *scrolled_window = NULL;
double zoom_level = 0.0;
gboolean was_zoomed = FALSE;
was_zoomed = self->is_zoomed;
zoom = get_current_zoom (self, &scrolled_window);
if (zoom != NULL)
{
g_object_get (zoom, "zoom-level", &zoom_level, NULL);
screenshot = bz_zoom_get_child (zoom);
if (screenshot != NULL)
bz_screenshot_set_filter (
BZ_SCREENSHOT (screenshot),
zoom_level <= 4.5
? GSK_SCALING_FILTER_TRILINEAR
: GSK_SCALING_FILTER_NEAREST);
}
self->is_zoomed = zoom != NULL && bz_zoom_is_transformed (zoom);
if (was_zoomed != self->is_zoomed)
{
g_object_notify_by_pspec (G_OBJECT (self), props[PROP_IS_ZOOMED]);
if (self->is_zoomed)
gtk_scrolled_window_set_policy (scrolled_window, GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
else
gtk_scrolled_window_set_policy (scrolled_window, GTK_POLICY_NEVER, GTK_POLICY_NEVER);
}
}
static BzZoom *
get_current_zoom (BzScreenshotPage *self,
GtkScrolledWindow **scrolled_window)
{
guint n_pages = 0;
GtkWidget *page = NULL;
GtkWidget *zoom = NULL;
n_pages = adw_carousel_get_n_pages (self->carousel);
if (self->current_index >= n_pages)
return NULL;
page = adw_carousel_get_nth_page (self->carousel, self->current_index);
if (page == NULL)
return NULL;
zoom = gtk_scrolled_window_get_child (GTK_SCROLLED_WINDOW (page));
if (zoom != NULL)
{
if (scrolled_window != NULL)
*scrolled_window = (GtkScrolledWindow *) page;
return BZ_ZOOM (zoom);
}
else
return NULL;
}
static void
on_button_pressed (GtkGestureClick *gesture,
int n_press,
double x,
double y,
BzScreenshotPage *self)
{
if (gtk_gesture_single_get_current_button (GTK_GESTURE_SINGLE (gesture)) == MOUSE_BACK_BUTTON)
back_clicked (self);
}
static void
on_swipe (BzScreenshotPage *self,
gdouble vel_x,
gdouble vel_y)
{
if (vel_y < -500.0 || vel_y > 500.0)
back_clicked (self);
}
static gboolean
on_scroll (BzScreenshotPage *self,
gdouble dx,
gdouble dy,
GtkEventControllerScroll *controller)
{
GdkEvent *event = NULL;
GdkDevice *device = NULL;
GdkInputSource source = 0;
event = gtk_event_controller_get_current_event (GTK_EVENT_CONTROLLER (controller));
device = gdk_event_get_device (event);
source = gdk_device_get_source (device);
if (source == GDK_SOURCE_TOUCHPAD && (dy < -2.0 || dy > 2.0))
back_clicked (self);
return GDK_EVENT_PROPAGATE;
}
