[libadwaita/wip/exalm/tab-overview: 1/2] Add AdwTabOverview
- From: Alexander Mikhaylenko <alexm src gnome org>
- To: commits-list gnome org
- Cc:
- Subject: [libadwaita/wip/exalm/tab-overview: 1/2] Add AdwTabOverview
- Date: Mon, 22 Aug 2022 16:57:47 +0000 (UTC)
commit 2e750a060df45b2b2ab85395c6c71221c50660c6
Author: Alexander Mikhaylenko <alexm gnome org>
Date: Fri Aug 12 03:04:59 2022 +0400
Add AdwTabOverview
src/adw-tab-grid-private.h | 78 +
src/adw-tab-grid.c | 3700 ++++++++++++++++++++
src/adw-tab-overview-private.h | 26 +
src/adw-tab-overview.c | 2320 ++++++++++++
src/adw-tab-overview.h | 112 +
src/adw-tab-overview.ui | 142 +
src/adw-tab-thumbnail-private.h | 56 +
src/adw-tab-thumbnail.c | 874 +++++
src/adw-tab-thumbnail.ui | 136 +
src/adw-tab-view.c | 65 +
src/adw-tab-view.h | 6 +
src/adwaita.gresources.xml | 3 +
src/adwaita.h | 1 +
.../scalable/status/adw-tab-unpin-symbolic.svg | 9 +
src/meson.build | 4 +
src/stylesheet/_colors.scss | 3 +
src/stylesheet/_defaults.scss | 4 +
src/stylesheet/widgets/_tab-view.scss | 84 +-
18 files changed, 7622 insertions(+), 1 deletion(-)
---
diff --git a/src/adw-tab-grid-private.h b/src/adw-tab-grid-private.h
new file mode 100644
index 00000000..d154debd
--- /dev/null
+++ b/src/adw-tab-grid-private.h
@@ -0,0 +1,78 @@
+/*
+ * Copyright (C) 2020 Purism SPC
+ *
+ * SPDX-License-Identifier: LGPL-2.1-or-later
+ *
+ * Author: Alexander Mikhaylenko <alexander mikhaylenko puri sm>
+ */
+
+#pragma once
+
+#if !defined(_ADWAITA_INSIDE) && !defined(ADWAITA_COMPILATION)
+#error "Only <adwaita.h> can be included directly."
+#endif
+
+#include <gtk/gtk.h>
+#include "adw-tab-thumbnail-private.h"
+#include "adw-tab-view.h"
+
+G_BEGIN_DECLS
+
+#define ADW_TYPE_TAB_GRID (adw_tab_grid_get_type())
+
+G_DECLARE_FINAL_TYPE (AdwTabGrid, adw_tab_grid, ADW, TAB_GRID, GtkWidget)
+
+void adw_tab_grid_set_view (AdwTabGrid *self,
+ AdwTabView *view);
+
+void adw_tab_grid_attach_page (AdwTabGrid *self,
+ AdwTabPage *page,
+ int position);
+void adw_tab_grid_detach_page (AdwTabGrid *self,
+ AdwTabPage *page);
+void adw_tab_grid_select_page (AdwTabGrid *self,
+ AdwTabPage *page);
+
+void adw_tab_grid_try_focus_selected_tab (AdwTabGrid *self);
+gboolean adw_tab_grid_is_page_focused (AdwTabGrid *self,
+ AdwTabPage *page);
+
+void adw_tab_grid_setup_extra_drop_target (AdwTabGrid *self,
+ GdkDragAction actions,
+ GType *types,
+ gsize n_types);
+
+gboolean adw_tab_grid_get_inverted (AdwTabGrid *self);
+void adw_tab_grid_set_inverted (AdwTabGrid *self,
+ gboolean inverted);
+
+void adw_tab_grid_set_thumbnail_align (AdwTabGrid *self,
+ float xalign,
+ float yalign);
+
+AdwTabThumbnail *adw_tab_grid_get_transition_thumbnail (AdwTabGrid *self);
+
+void adw_tab_grid_set_visible_range (AdwTabGrid *self,
+ double lower,
+ double upper);
+
+void adw_tab_grid_adjustment_shifted (AdwTabGrid *self,
+ double delta);
+
+double adw_tab_grid_get_scrolled_tab_y (AdwTabGrid *self);
+
+void adw_tab_grid_reset_scrolled_tab (AdwTabGrid *self);
+
+void adw_tab_grid_scroll_to_page (AdwTabGrid *self,
+ AdwTabPage *page,
+ gboolean animate);
+
+void adw_tab_grid_set_hovering (AdwTabGrid *self,
+ gboolean hovering);
+
+void adw_tab_grid_set_search_terms (AdwTabGrid *self,
+ const char *terms);
+
+gboolean adw_tab_grid_get_empty (AdwTabGrid *self);
+
+G_END_DECLS
diff --git a/src/adw-tab-grid.c b/src/adw-tab-grid.c
new file mode 100644
index 00000000..6b6f786b
--- /dev/null
+++ b/src/adw-tab-grid.c
@@ -0,0 +1,3700 @@
+/*
+ * Copyright (C) 2020-2021 Purism SPC
+ *
+ * SPDX-License-Identifier: LGPL-2.1-or-later
+ *
+ * Author: Alexander Mikhaylenko <alexander mikhaylenko puri sm>
+ */
+
+#include "config.h"
+
+#include "adw-tab-grid-private.h"
+
+#include "adw-animation-util.h"
+#include "adw-easing.h"
+#include "adw-gizmo-private.h"
+#include "adw-macros-private.h"
+#include "adw-tab-overview-private.h"
+#include "adw-tab-view-private.h"
+#include "adw-timed-animation.h"
+#include "adw-widget-utils-private.h"
+#include <math.h>
+
+#define SPACING 5
+#define DND_THRESHOLD_MULTIPLIER 4
+#define DROP_SWITCH_TIMEOUT 500
+
+#define AUTOSCROLL_SPEED 2.5
+
+#define OPEN_ANIMATION_DURATION 200
+#define CLOSE_ANIMATION_DURATION 200
+#define FOCUS_ANIMATION_DURATION 200
+#define RESIZE_ANIMATION_DURATION 200
+#define REORDER_ANIMATION_DURATION 250
+#define ICON_RESIZE_ANIMATION_DURATION 200
+
+#define MIN_COLUMNS 2
+#define MAX_COLUMNS 8
+#define MAX_THUMBNAIL_WIDTH 500
+#define SINGLE_TAB_MAX_PERCENTAGE 0.5
+
+#define SMALL_GRID_WIDTH 360
+#define SMALL_GRID_PERCENTAGE 1
+#define SMALL_NAT_THUMBNAIL_WIDTH 200
+
+#define LARGE_GRID_WIDTH 2560
+#define LARGE_GRID_PERCENTAGE 0.85
+#define LARGE_NAT_THUMBNAIL_WIDTH 360
+
+typedef enum {
+ TAB_RESIZE_NORMAL,
+ TAB_RESIZE_FIXED_TAB_SIZE
+} TabResizeMode;
+
+typedef struct {
+ GdkDrag *drag;
+
+ AdwTabThumbnail *tab;
+ GtkBorder tab_margin;
+
+ int hotspot_x;
+ int hotspot_y;
+
+ int width;
+ int height;
+
+ int initial_width;
+ int initial_height;
+
+ int target_width;
+ int target_height;
+ AdwAnimation *resize_animation;
+} DragIcon;
+
+typedef struct {
+ AdwTabGrid *box;
+ AdwTabPage *page;
+ AdwTabThumbnail *tab;
+ GtkWidget *container;
+
+ int final_x;
+ int final_y;
+ int final_width;
+ int final_height;
+
+ int unshifted_x;
+ int unshifted_y;
+ int pos_x;
+ int pos_y;
+ int width;
+ int height;
+ int last_width;
+ int last_height;
+
+ double index;
+ double final_index;
+
+ double end_reorder_offset;
+ double reorder_offset;
+
+ AdwAnimation *reorder_animation;
+ gboolean reorder_ignore_bounds;
+
+ double appear_progress;
+ AdwAnimation *appear_animation;
+
+ gulong notify_needs_attention_id;
+
+ gboolean visible;
+} TabInfo;
+
+struct _AdwTabGrid
+{
+ GtkWidget parent_instance;
+
+ gboolean pinned;
+ AdwTabOverview *tab_overview;
+ AdwTabView *view;
+ gboolean inverted;
+ float thumbnail_xalign;
+ float thumbnail_yalign;
+
+ GtkEventController *view_drop_target;
+ GtkGesture *drag_gesture;
+
+ GList *tabs;
+ int n_tabs;
+
+ GtkWidget *context_menu;
+
+ int allocated_width;
+ int allocated_height;
+ int last_height;
+ int end_padding;
+ int initial_end_padding;
+ int final_end_padding;
+ TabResizeMode tab_resize_mode;
+ AdwAnimation *resize_animation;
+
+ TabInfo *selected_tab;
+
+ gboolean hovering;
+ TabInfo *pressed_tab;
+ TabInfo *reordered_tab;
+ AdwAnimation *reorder_animation;
+
+ int reorder_x;
+ int reorder_y;
+ int reorder_index;
+ int reorder_window_x;
+ int reorder_window_y;
+ gboolean continue_reorder;
+ gboolean indirect_reordering;
+
+ gboolean dragging;
+ double drag_offset_x;
+ double drag_offset_y;
+
+ guint drag_autoscroll_cb_id;
+ gint64 drag_autoscroll_prev_time;
+
+ AdwTabPage *detached_page;
+ int detached_index;
+ TabInfo *reorder_placeholder;
+ AdwTabPage *placeholder_page;
+ gboolean can_remove_placeholder;
+ DragIcon *drag_icon;
+ gboolean should_detach_into_new_window;
+
+ TabInfo *drop_target_tab;
+ guint drop_switch_timeout_id;
+ guint reset_drop_target_tab_id;
+ double drop_target_x;
+ double drop_target_y;
+
+ TabInfo *scroll_animation_tab;
+
+ GdkDragAction extra_drag_actions;
+ GType *extra_drag_types;
+ gsize extra_drag_n_types;
+
+ GtkWidget *needs_attention_top;
+ GtkWidget *needs_attention_bottom;
+
+ double n_columns;
+ double max_n_columns;
+ double initial_max_n_columns;
+ int tab_width;
+ int tab_height;
+
+ double visible_lower;
+ double visible_upper;
+
+ GtkStringFilter *title_filter;
+ GtkStringFilter *tooltip_filter;
+ GtkStringFilter *keyword_filter;
+ GtkFilter *filter;
+ gboolean searching;
+
+ gboolean empty;
+};
+
+G_DEFINE_FINAL_TYPE (AdwTabGrid, adw_tab_grid, GTK_TYPE_WIDGET)
+
+enum {
+ PROP_0,
+ PROP_PINNED,
+ PROP_TAB_OVERVIEW,
+ PROP_VIEW,
+ PROP_RESIZE_FROZEN,
+ PROP_EMPTY,
+ LAST_PROP,
+};
+
+static GParamSpec *props[LAST_PROP];
+
+enum {
+ SIGNAL_SCROLL_RELATIVE,
+ SIGNAL_SCROLL_TO_TAB,
+ SIGNAL_EXTRA_DRAG_DROP,
+ SIGNAL_LAST_SIGNAL,
+};
+
+static guint signals[SIGNAL_LAST_SIGNAL];
+
+/* Helpers */
+
+static void
+remove_and_free_tab_info (TabInfo *info)
+{
+ gtk_widget_unparent (GTK_WIDGET (info->container));
+
+ g_free (info);
+}
+
+static inline int
+get_tab_x (AdwTabGrid *self,
+ TabInfo *info,
+ gboolean final)
+{
+ if (info == self->reordered_tab)
+ return self->reorder_window_x;
+
+ return final ? info->final_x : info->pos_x;
+}
+
+static inline int
+get_tab_y (AdwTabGrid *self,
+ TabInfo *info,
+ gboolean final)
+{
+ if (info == self->reordered_tab)
+ return self->reorder_window_y;
+
+ return final ? info->final_y : info->pos_y;
+}
+
+static inline TabInfo *
+find_tab_info_at (AdwTabGrid *self,
+ double x,
+ double y)
+{
+ GList *l;
+
+ if (self->reordered_tab) {
+ int pos_x = get_tab_x (self, self->reordered_tab, FALSE);
+ int pos_y = get_tab_y (self, self->reordered_tab, FALSE);
+
+ if (pos_x <= x && x < pos_x + self->reordered_tab->width &&
+ pos_y <= y && y < pos_y + self->reordered_tab->height)
+ return self->reordered_tab;
+ }
+
+ for (l = self->tabs; l; l = l->next) {
+ TabInfo *info = l->data;
+
+ if (!gtk_widget_should_layout (info->container))
+ continue;
+
+ if (info != self->reordered_tab &&
+ info->pos_x <= x && x < info->pos_x + info->width &&
+ info->pos_y <= y && y < info->pos_y + info->height)
+ return info;
+ }
+
+ return NULL;
+}
+
+static inline GList *
+find_link_for_page (AdwTabGrid *self,
+ AdwTabPage *page)
+{
+ GList *l;
+
+ for (l = self->tabs; l; l = l->next) {
+ TabInfo *info = l->data;
+
+ if (info->page == page)
+ return l;
+ }
+
+ return NULL;
+}
+
+static inline TabInfo *
+find_info_for_page (AdwTabGrid *self,
+ AdwTabPage *page)
+{
+ GList *l = find_link_for_page (self, page);
+
+ return l ? l->data : NULL;
+}
+
+static GList *
+find_nth_alive_tab (AdwTabGrid *self,
+ guint position)
+{
+ GList *l;
+
+ for (l = self->tabs; l; l = l->next) {
+ TabInfo *info = l->data;
+
+ if (!info->page)
+ continue;
+
+ if (!position--)
+ return l;
+ }
+
+ return NULL;
+}
+
+/* Layout */
+
+static inline AdwTabGrid *
+get_other_tab_grid (AdwTabGrid *self)
+{
+ if (self->pinned)
+ return adw_tab_overview_get_tab_grid (self->tab_overview);
+ else
+ return adw_tab_overview_get_pinned_tab_grid (self->tab_overview);
+}
+
+static double
+get_max_n_columns (AdwTabGrid *self)
+{
+ GList *l;
+ double max_columns = 0;
+ double other_max_columns = 0;
+ AdwTabGrid *other_grid = get_other_tab_grid (self);
+
+ for (l = self->tabs; l; l = l->next) {
+ TabInfo *info = l->data;
+
+ max_columns += info->appear_progress;
+ }
+
+ for (l = other_grid->tabs; l; l = l->next) {
+ TabInfo *info = l->data;
+
+ other_max_columns += info->appear_progress;
+ }
+
+ return MAX (max_columns, other_max_columns);
+}
+
+static double
+get_n_columns (AdwTabGrid *self,
+ int for_width,
+ double max_n_columns)
+{
+ double t;
+ double nat_width;
+
+ if (for_width < 0)
+ return MAX (max_n_columns, 1);
+
+ max_n_columns = CLAMP (max_n_columns, 1, MAX_COLUMNS);
+
+ t = CLAMP (((double) for_width - SMALL_GRID_WIDTH) /
+ (LARGE_GRID_WIDTH - SMALL_GRID_WIDTH), 0, 1);
+ nat_width = adw_lerp (SMALL_NAT_THUMBNAIL_WIDTH, LARGE_NAT_THUMBNAIL_WIDTH,
+ adw_easing_ease (ADW_EASE_OUT_CUBIC, t));
+
+ return CLAMP (ceil ((double) for_width / nat_width),
+ MIN (MIN_COLUMNS, max_n_columns), max_n_columns);
+}
+
+static int
+get_tab_width (AdwTabGrid *self,
+ int for_width)
+{
+ double n = get_n_columns (self, for_width, self->max_n_columns);
+ double total_size = for_width;
+ double t;
+ int ret;
+
+ t = CLAMP ((total_size - SMALL_GRID_WIDTH) / (LARGE_GRID_WIDTH - SMALL_GRID_WIDTH), 0, 1);
+ total_size *= adw_lerp (SMALL_GRID_PERCENTAGE, LARGE_GRID_PERCENTAGE,
+ adw_easing_ease (ADW_EASE_OUT_CUBIC, t));
+
+ if (n <= self->max_n_columns) {
+ double max = get_n_columns (self, for_width, MAX_COLUMNS);
+
+ total_size *= (SINGLE_TAB_MAX_PERCENTAGE + (1 - SINGLE_TAB_MAX_PERCENTAGE) * n / max);
+ }
+
+ ret = (int) ceil ((double) (total_size - SPACING * (n + 1)) / n);
+
+ return MIN (ret, MAX_THUMBNAIL_WIDTH);
+}
+
+static int
+get_tab_height (AdwTabGrid *self,
+ int tab_width)
+{
+ int height = 0;
+ GList *l;
+
+ for (l = self->tabs; l; l = l->next) {
+ TabInfo *info = l->data;
+ int tab_height;
+
+ gtk_widget_measure (GTK_WIDGET (info->tab), GTK_ORIENTATION_VERTICAL,
+ tab_width, NULL, &tab_height, NULL, NULL);
+
+ height = MAX (height, tab_height);
+ }
+
+ return height;
+}
+
+static void
+get_position_for_index (AdwTabGrid *self,
+ double index,
+ gboolean is_rtl,
+ int *pos_x,
+ int *pos_y)
+{
+ int n_columns = ceil (self->n_columns);
+ double col = fmod (index, n_columns);
+ double row = (index - col) / n_columns;
+ double offset = self->allocated_width;
+ int x, y;
+
+ offset -= self->n_columns * (self->tab_width + SPACING) - SPACING;
+ offset /= 2;
+
+ if (col > n_columns - 1) {
+ double start, end, t;
+
+ if (is_rtl) {
+ start = self->allocated_width - offset - self->tab_width;
+ end = offset;
+ } else {
+ start = offset;
+ end = self->allocated_width - offset - self->tab_width;
+ }
+
+ t = n_columns - col;
+ x = adw_lerp (start, end, t);
+ y = SPACING + (row + 1 - t) * (self->tab_height + SPACING);
+ } else {
+ x = is_rtl ? self->allocated_width - offset - self->tab_width : offset;
+
+ if (is_rtl)
+ x -= col * (self->tab_width + SPACING);
+ else
+ x += col * (self->tab_width + SPACING);
+
+ y = SPACING + row * (self->tab_height + SPACING);
+ }
+
+ if (pos_x)
+ *pos_x = x;
+
+ if (pos_y)
+ *pos_y = y;
+}
+
+static inline int
+calculate_tab_width (TabInfo *info,
+ int base_width)
+{
+ return (int) floor ((base_width + SPACING) * info->appear_progress) - SPACING;
+}
+
+static void
+measure_tab_grid (AdwTabGrid *self,
+ GtkOrientation orientation,
+ int for_size,
+ int *minimum,
+ int *natural,
+ gboolean animated)
+{
+ int min, nat;
+
+ if (self->n_tabs == 0) {
+ if (minimum)
+ *minimum = 0;
+
+ if (natural)
+ *natural = 0;
+
+ return;
+ }
+
+ if (orientation == GTK_ORIENTATION_HORIZONTAL) {
+ GList *l;
+ int indicator_min;
+ min = nat = 0;
+
+ for (l = self->tabs; l; l = l->next) {
+ TabInfo *info = l->data;
+ int child_min, child_nat;
+
+ if (!gtk_widget_should_layout (info->container))
+ continue;
+
+ gtk_widget_measure (info->container, orientation, -1,
+ &child_min, &child_nat, NULL, NULL);
+
+ if (animated)
+ min = MAX (min, calculate_tab_width (info, child_min));
+ else
+ min = MAX (min, child_min);
+
+ nat += child_nat + SPACING;
+ }
+
+ nat += SPACING;
+ min += SPACING * 2;
+
+ gtk_widget_measure (self->needs_attention_top, orientation, -1,
+ &indicator_min, NULL, NULL, NULL);
+
+ min = MAX (min, indicator_min);
+
+ gtk_widget_measure (self->needs_attention_bottom, orientation, -1,
+ &indicator_min, NULL, NULL, NULL);
+
+ min = MAX (min, indicator_min);
+ } else {
+ double n_columns, n_rows;
+ int child_width = -1, child_height;
+ double index = 0;
+ GList *l;
+ int height;
+
+ if (for_size >= 0)
+ child_width = get_tab_width (self, for_size);
+
+ child_height = get_tab_height (self, child_width);
+
+ for (l = self->tabs; l; l = l->next) {
+ TabInfo *info = l->data;
+
+ if (!gtk_widget_should_layout (info->container))
+ continue;
+
+ if (animated) {
+ index += info->appear_progress;
+ } else {
+ if (info->page)
+ index++;
+ }
+ }
+
+ n_columns = get_n_columns (self, for_size, self->max_n_columns);
+ n_rows = ceil (index / n_columns);
+
+ if (animated) {
+ double col = fmod (index, n_columns);
+
+ if (col > 0 && col < 1)
+ n_rows = n_rows + col - 1;
+ }
+
+ height = (child_height + SPACING) * n_rows + SPACING + self->end_padding;
+
+ if (!self->pinned)
+ height = MAX (self->last_height, height);
+
+ min = nat = height;
+ }
+
+ if (minimum)
+ *minimum = min;
+
+ if (natural)
+ *natural = nat;
+}
+
+static void
+calculate_tab_layout (AdwTabGrid *self)
+{
+ gboolean is_rtl;
+ GList *l;
+ double index = 0, final_index = 0;
+
+ if (self->tab_resize_mode != TAB_RESIZE_FIXED_TAB_SIZE &&
+ self->initial_max_n_columns < 0)
+ self->max_n_columns = get_max_n_columns (self);
+
+ self->n_columns = get_n_columns (self, self->allocated_width, self->max_n_columns);
+
+ if (self->context_menu)
+ gtk_popover_present (GTK_POPOVER (self->context_menu));
+
+ is_rtl = gtk_widget_get_direction (GTK_WIDGET (self)) == GTK_TEXT_DIR_RTL;
+
+ self->tab_width = get_tab_width (self, self->allocated_width);
+ self->tab_height = get_tab_height (self, self->tab_width);
+
+ for (l = self->tabs; l; l = l->next) {
+ TabInfo *info = l->data;
+
+ if (!gtk_widget_should_layout (info->container))
+ continue;
+
+ get_position_for_index (self, final_index, is_rtl,
+ &info->unshifted_x, &info->unshifted_y);
+ get_position_for_index (self, index + info->reorder_offset, is_rtl,
+ &info->pos_x, &info->pos_y);
+ get_position_for_index (self, final_index + info->end_reorder_offset, is_rtl,
+ &info->final_x, &info->final_y);
+
+ info->width = calculate_tab_width (info, self->tab_width);
+ info->final_width = self->tab_width;
+
+ info->height = self->tab_height;
+ info->final_height = self->tab_height;
+
+ info->index = index;
+ info->final_index = final_index;
+
+ index += info->appear_progress;
+ final_index++;
+
+ if (self->tab_resize_mode == TAB_RESIZE_FIXED_TAB_SIZE) {
+ self->end_padding = self->allocated_height - info->pos_y - info->height - SPACING;
+ self->final_end_padding = self->allocated_height - info->final_y - info->final_height - SPACING;
+ }
+ }
+}
+
+static void
+get_visible_range (AdwTabGrid *self,
+ int *lower,
+ int *upper)
+{
+ int min = SPACING;
+ int max = self->allocated_height - SPACING;
+
+ min = MAX (min, (int) floor (self->visible_lower) + SPACING);
+ max = MIN (max, (int) ceil (self->visible_upper) - SPACING);
+
+ if (lower)
+ *lower = min;
+
+ if (upper)
+ *upper = max;
+}
+
+static inline gboolean
+is_touchscreen (GtkGesture *gesture)
+{
+ GtkEventController *controller = GTK_EVENT_CONTROLLER (gesture);
+ GdkDevice *device = gtk_event_controller_get_current_event_device (controller);
+ GdkInputSource input_source = gdk_device_get_source (device);
+
+ return input_source == GDK_SOURCE_TOUCHSCREEN;
+}
+
+/* Search */
+
+static gboolean
+tab_should_be_visible (AdwTabGrid *self,
+ AdwTabPage *page)
+{
+ if (!self->searching)
+ return TRUE;
+
+ return gtk_filter_match (self->filter, page);
+}
+
+static void
+set_empty (AdwTabGrid *self,
+ gboolean empty)
+{
+ if (self->empty == empty)
+ return;
+
+ self->empty = empty;
+
+ g_object_notify_by_pspec (G_OBJECT (self), props[PROP_EMPTY]);
+}
+
+static void
+search_changed_cb (AdwTabGrid *self,
+ GtkFilterChange change)
+{
+ GList *l;
+ gboolean changed = FALSE;
+ gboolean empty = TRUE;
+
+ for (l = self->tabs; l; l = l->next) {
+ TabInfo *info = l->data;
+ gboolean visible;
+
+ if (change == GTK_FILTER_CHANGE_LESS_STRICT && info->visible) {
+ empty = FALSE;
+ continue;
+ }
+
+ if (change == GTK_FILTER_CHANGE_MORE_STRICT && !info->visible)
+ continue;
+
+ visible = tab_should_be_visible (self, info->page);
+
+ if (visible)
+ empty = FALSE;
+
+ if (visible != info->visible) {
+ info->visible = visible;
+ gtk_widget_set_visible (info->container, visible);
+ changed = TRUE;
+ }
+ }
+
+ set_empty (self, empty);
+
+ if (changed)
+ gtk_widget_queue_resize (GTK_WIDGET (self));
+}
+
+/* Tab resize delay */
+
+static void
+resize_animation_value_cb (double value,
+ AdwTabGrid *self)
+{
+ double target_max_n_columns = get_max_n_columns (self);
+
+ self->end_padding = (int) floor (adw_lerp (self->initial_end_padding, 0, value));
+
+ self->max_n_columns = adw_lerp (self->initial_max_n_columns, target_max_n_columns, value);
+
+ gtk_widget_queue_resize (GTK_WIDGET (self));
+}
+
+static void
+resize_animation_done_cb (AdwTabGrid *self)
+{
+ self->end_padding = 0;
+ self->final_end_padding = 0;
+ self->initial_max_n_columns = -1;
+ gtk_widget_queue_resize (GTK_WIDGET (self));
+}
+
+static void
+set_tab_resize_mode_do (AdwTabGrid *self,
+ TabResizeMode mode)
+{
+ gboolean notify;
+
+ if (self->tab_resize_mode == mode)
+ return;
+
+ if (mode == TAB_RESIZE_FIXED_TAB_SIZE) {
+ GList *l;
+
+ self->last_height = self->allocated_height;
+
+ for (l = self->tabs; l; l = l->next) {
+ TabInfo *info = l->data;
+
+ if (info->appear_animation)
+ info->last_height = info->final_height;
+ else
+ info->last_height = info->height;
+ }
+ } else {
+ self->last_height = 0;
+ }
+
+ if (mode == TAB_RESIZE_NORMAL) {
+ self->initial_end_padding = self->end_padding;
+ self->initial_max_n_columns = self->max_n_columns;
+
+ adw_animation_play (self->resize_animation);
+ }
+
+ notify = (self->tab_resize_mode == TAB_RESIZE_NORMAL) !=
+ (mode == TAB_RESIZE_NORMAL);
+
+ self->tab_resize_mode = mode;
+
+ if (notify)
+ g_object_notify_by_pspec (G_OBJECT (self), props[PROP_RESIZE_FROZEN]);
+}
+
+static void
+set_tab_resize_mode (AdwTabGrid *self,
+ TabResizeMode mode)
+{
+ set_tab_resize_mode_do (self, mode);
+ set_tab_resize_mode_do (get_other_tab_grid (self), mode);
+}
+
+/* Hover */
+
+static void
+update_hover (AdwTabGrid *self)
+{
+ if (!self->dragging && !self->hovering)
+ set_tab_resize_mode (self, TAB_RESIZE_NORMAL);
+}
+
+/* Keybindings */
+
+static void
+focus_tab_cb (AdwTabGrid *self,
+ GVariant *args)
+{
+ GtkDirectionType direction;
+ gboolean last, is_rtl, success;
+
+ if (!self->view || !self->selected_tab)
+ return;
+
+ g_variant_get (args, "(hb)", &direction, &last);
+
+ is_rtl = gtk_widget_get_direction (GTK_WIDGET (self)) == GTK_TEXT_DIR_RTL;
+ success = last;
+
+ if (direction == GTK_DIR_LEFT)
+ direction = is_rtl ? GTK_DIR_TAB_FORWARD : GTK_DIR_TAB_BACKWARD;
+ else if (direction == GTK_DIR_RIGHT)
+ direction = is_rtl ? GTK_DIR_TAB_BACKWARD : GTK_DIR_TAB_FORWARD;
+
+ if (direction == GTK_DIR_TAB_BACKWARD) {
+ if (last)
+ success = adw_tab_view_select_first_page (self->view);
+ else
+ success = adw_tab_view_select_previous_page (self->view);
+ } else if (direction == GTK_DIR_TAB_FORWARD) {
+ if (last)
+ success = adw_tab_view_select_last_page (self->view);
+ else
+ success = adw_tab_view_select_next_page (self->view);
+ }
+
+ if (!success)
+ gtk_widget_error_bell (GTK_WIDGET (self));
+}
+
+static void
+reorder_tab_cb (AdwTabGrid *self,
+ GVariant *args)
+{
+ GtkDirectionType direction;
+ gboolean last, is_rtl, success;
+
+ if (!self->view || !self->selected_tab || !self->selected_tab->page)
+ return;
+
+ g_variant_get (args, "(hb)", &direction, &last);
+
+ is_rtl = gtk_widget_get_direction (GTK_WIDGET (self)) == GTK_TEXT_DIR_RTL;
+ success = last;
+
+ if (direction == GTK_DIR_LEFT)
+ direction = is_rtl ? GTK_DIR_TAB_FORWARD : GTK_DIR_TAB_BACKWARD;
+ else if (direction == GTK_DIR_RIGHT)
+ direction = is_rtl ? GTK_DIR_TAB_BACKWARD : GTK_DIR_TAB_FORWARD;
+
+ if (direction == GTK_DIR_TAB_BACKWARD) {
+ if (last)
+ success = adw_tab_view_reorder_first (self->view, self->selected_tab->page);
+ else
+ success = adw_tab_view_reorder_backward (self->view, self->selected_tab->page);
+ } else if (direction == GTK_DIR_TAB_FORWARD) {
+ if (last)
+ success = adw_tab_view_reorder_last (self->view, self->selected_tab->page);
+ else
+ success = adw_tab_view_reorder_forward (self->view, self->selected_tab->page);
+ }
+
+ if (!success)
+ gtk_widget_error_bell (GTK_WIDGET (self));
+}
+
+static void
+add_focus_bindings (GtkWidgetClass *widget_class,
+ guint keysym,
+ GtkDirectionType direction,
+ gboolean last)
+{
+ /* All keypad keysyms are aligned at the same order as non-keypad ones */
+ guint keypad_keysym = keysym - GDK_KEY_Left + GDK_KEY_KP_Left;
+
+ gtk_widget_class_add_binding (widget_class, keysym, 0,
+ (GtkShortcutFunc) focus_tab_cb,
+ "(hb)", direction, last);
+ gtk_widget_class_add_binding (widget_class, keypad_keysym, 0,
+ (GtkShortcutFunc) focus_tab_cb,
+ "(hb)", direction, last);
+}
+
+static void
+add_reorder_bindings (GtkWidgetClass *widget_class,
+ guint keysym,
+ GtkDirectionType direction,
+ gboolean last)
+{
+ /* All keypad keysyms are aligned at the same order as non-keypad ones */
+ guint keypad_keysym = keysym - GDK_KEY_Left + GDK_KEY_KP_Left;
+
+ gtk_widget_class_add_binding (widget_class, keysym, GDK_SHIFT_MASK,
+ (GtkShortcutFunc) reorder_tab_cb,
+ "(hb)", direction, last);
+ gtk_widget_class_add_binding (widget_class, keypad_keysym, GDK_SHIFT_MASK,
+ (GtkShortcutFunc) reorder_tab_cb,
+ "(hb)", direction, last);
+}
+
+static void
+activate_tab (AdwTabGrid *self)
+{
+ GtkWidget *child;
+
+ if (!self->selected_tab || !self->selected_tab->page)
+ return;
+
+ child = adw_tab_page_get_child (self->selected_tab->page);
+
+ gtk_widget_grab_focus (child);
+}
+
+/* Scrolling */
+
+static void
+update_visible (AdwTabGrid *self)
+{
+ gboolean top = FALSE, bottom = FALSE;
+ GList *l;
+ int lower, upper;
+
+ get_visible_range (self, &lower, &upper);
+
+ for (l = self->tabs; l; l = l->next) {
+ TabInfo *info = l->data;
+ int pos;
+
+ if (!info->page)
+ continue;
+
+ pos = get_tab_y (self, info, FALSE);
+
+ adw_tab_thumbnail_set_fully_visible (info->tab,
+ pos >= lower &&
+ pos + info->height <= upper);
+
+ if (!adw_tab_page_get_needs_attention (info->page))
+ continue;
+
+ if (pos + info->height / 2.0 <= lower)
+ top = TRUE;
+
+ if (pos + info->height / 2.0 >= upper)
+ bottom = TRUE;
+ }
+
+ gtk_revealer_set_reveal_child (GTK_REVEALER (self->needs_attention_top), top);
+ gtk_revealer_set_reveal_child (GTK_REVEALER (self->needs_attention_bottom), bottom);
+}
+
+static gboolean
+drop_switch_timeout_cb (AdwTabGrid *self)
+{
+ self->drop_switch_timeout_id = 0;
+ adw_tab_view_set_selected_page (self->view,
+ self->drop_target_tab->page);
+
+ return G_SOURCE_REMOVE;
+}
+
+static void
+set_drop_target_tab (AdwTabGrid *self,
+ TabInfo *info)
+{
+ if (self->drop_target_tab == info)
+ return;
+
+ if (self->drop_target_tab)
+ g_clear_handle_id (&self->drop_switch_timeout_id, g_source_remove);
+
+ self->drop_target_tab = info;
+
+ if (self->drop_target_tab) {
+ self->drop_switch_timeout_id =
+ g_timeout_add (DROP_SWITCH_TIMEOUT,
+ (GSourceFunc) drop_switch_timeout_cb,
+ self);
+ }
+}
+
+static void
+animate_scroll_relative (AdwTabGrid *self,
+ double delta,
+ guint duration)
+{
+ g_signal_emit (self, signals[SIGNAL_SCROLL_RELATIVE], 0, delta, duration);
+}
+
+static void
+scroll_to_tab_full (AdwTabGrid *self,
+ TabInfo *info,
+ double pos,
+ guint duration,
+ gboolean keep_selected_visible)
+{
+ self->scroll_animation_tab = info;
+
+ int tab_height;
+ double padding, page_size, offset;
+
+ tab_height = info->height;
+
+ if (info->appear_animation)
+ tab_height = info->final_height;
+
+ page_size = gtk_widget_get_height (GTK_WIDGET (self->tab_overview));
+ padding = MIN (tab_height, page_size - tab_height) / 2.0;
+
+ if (pos < 0)
+ pos = get_tab_y (self, info, TRUE);
+
+ if (pos - SPACING < self->visible_lower)
+ offset = -padding;
+ else if (pos + tab_height + SPACING > self->visible_upper)
+ offset = tab_height + padding - page_size;
+ else
+ return;
+
+ g_signal_emit (self, signals[SIGNAL_SCROLL_TO_TAB], 0, offset, duration);
+}
+
+static void
+scroll_to_tab (AdwTabGrid *self,
+ TabInfo *info,
+ guint duration)
+{
+ scroll_to_tab_full (self, info, -1, duration, FALSE);
+}
+
+/* Reordering */
+
+static void
+force_end_reordering (AdwTabGrid *self)
+{
+ GList *l;
+
+ if (self->dragging || !self->reordered_tab)
+ return;
+
+ if (self->reorder_animation)
+ adw_animation_skip (self->reorder_animation);
+
+ for (l = self->tabs; l; l = l->next) {
+ TabInfo *info = l->data;
+
+ if (info->reorder_animation)
+ adw_animation_skip (info->reorder_animation);
+ }
+}
+
+static void
+check_end_reordering (AdwTabGrid *self)
+{
+ GList *l;
+
+ if (self->dragging || !self->reordered_tab || self->continue_reorder)
+ return;
+
+ if (self->reorder_animation)
+ return;
+
+ for (l = self->tabs; l; l = l->next) {
+ TabInfo *info = l->data;
+
+ if (info->reorder_animation)
+ return;
+ }
+
+ for (l = self->tabs; l; l = l->next) {
+ TabInfo *info = l->data;
+
+ info->end_reorder_offset = 0;
+ info->reorder_offset = 0;
+ }
+
+ self->reordered_tab->reorder_ignore_bounds = FALSE;
+
+ self->tabs = g_list_remove (self->tabs, self->reordered_tab);
+ self->tabs = g_list_insert (self->tabs, self->reordered_tab, self->reorder_index);
+
+ gtk_widget_queue_allocate (GTK_WIDGET (self));
+
+ self->reordered_tab = NULL;
+}
+
+static void
+start_reordering (AdwTabGrid *self,
+ TabInfo *info)
+{
+ self->reordered_tab = info;
+
+ /* The reordered tab should be displayed above everything else */
+ gtk_widget_insert_before (GTK_WIDGET (self->reordered_tab->container),
+ GTK_WIDGET (self), self->needs_attention_top);
+
+ gtk_widget_queue_allocate (GTK_WIDGET (self));
+}
+
+static void
+get_reorder_position (AdwTabGrid *self,
+ int *x,
+ int *y)
+{
+ int lower, upper;
+ int width;
+
+ if (self->reordered_tab->reorder_ignore_bounds) {
+ *x = self->reorder_x;
+ *y = self->reorder_y;
+ return;
+ }
+
+ get_visible_range (self, &lower, &upper);
+
+ width = gtk_widget_get_width (GTK_WIDGET (self));
+
+ *x = CLAMP (self->reorder_x, 0, width - self->reordered_tab->width);
+ *y = CLAMP (self->reorder_y, lower, upper - self->reordered_tab->height);
+}
+
+static void
+reorder_animation_value_cb (double value,
+ TabInfo *dest_tab)
+{
+ AdwTabGrid *self = dest_tab->box;
+ gboolean is_rtl = gtk_widget_get_direction (GTK_WIDGET (self)) == GTK_TEXT_DIR_RTL;
+ int x1, y1, x2, y2;
+
+ get_reorder_position (self, &x1, &y1);
+ get_position_for_index (self, dest_tab->index, is_rtl, &x2, &y2);
+
+ self->reorder_window_x = (int) round (adw_lerp (x1, x2, value));
+ self->reorder_window_y = (int) round (adw_lerp (y1, y2, value));
+
+ gtk_widget_queue_allocate (GTK_WIDGET (self));
+}
+
+static void
+reorder_animation_done_cb (AdwTabGrid *self)
+{
+ g_clear_object (&self->reorder_animation);
+ check_end_reordering (self);
+}
+
+static void
+animate_reordering (AdwTabGrid *self,
+ TabInfo *dest_tab)
+{
+ AdwAnimationTarget *target;
+
+ if (self->reorder_animation)
+ adw_animation_skip (self->reorder_animation);
+
+ target = adw_callback_animation_target_new ((AdwAnimationTargetFunc)
+ reorder_animation_value_cb,
+ dest_tab, NULL);
+ self->reorder_animation =
+ adw_timed_animation_new (GTK_WIDGET (self), 0, 1,
+ REORDER_ANIMATION_DURATION, target);
+
+ g_signal_connect_swapped (self->reorder_animation, "done",
+ G_CALLBACK (reorder_animation_done_cb), self);
+
+ adw_animation_play (self->reorder_animation);
+
+ check_end_reordering (self);
+}
+
+static void
+reorder_offset_animation_value_cb (double value,
+ TabInfo *info)
+{
+ AdwTabGrid *self = info->box;
+
+ info->reorder_offset = value;
+ gtk_widget_queue_allocate (GTK_WIDGET (self));
+}
+
+static void
+reorder_offset_animation_done_cb (TabInfo *info)
+{
+ AdwTabGrid *self = info->box;
+
+ g_clear_object (&info->reorder_animation);
+ check_end_reordering (self);
+}
+
+static void
+animate_reorder_offset (AdwTabGrid *self,
+ TabInfo *info,
+ double offset)
+{
+ gboolean is_rtl = gtk_widget_get_direction (GTK_WIDGET (self)) == GTK_TEXT_DIR_RTL;
+ AdwAnimationTarget *target;
+ double start_offset;
+
+ offset *= (is_rtl ? -1 : 1);
+
+ if (info->end_reorder_offset == offset)
+ return;
+
+ info->end_reorder_offset = offset;
+ start_offset = info->reorder_offset;
+
+ if (info->reorder_animation)
+ adw_animation_skip (info->reorder_animation);
+
+ target = adw_callback_animation_target_new ((AdwAnimationTargetFunc)
+ reorder_offset_animation_value_cb,
+ info, NULL);
+ info->reorder_animation =
+ adw_timed_animation_new (GTK_WIDGET (self), start_offset, offset,
+ REORDER_ANIMATION_DURATION, target);
+
+ g_signal_connect_swapped (info->reorder_animation, "done",
+ G_CALLBACK (reorder_offset_animation_done_cb), info);
+
+ adw_animation_play (info->reorder_animation);
+}
+
+static void
+reset_reorder_animations (AdwTabGrid *self)
+{
+ int i, original_index;
+ GList *l;
+
+ if (!adw_get_enable_animations (GTK_WIDGET (self)))
+ return;
+
+ l = find_link_for_page (self, self->reordered_tab->page);
+ original_index = g_list_position (self->tabs, l);
+
+ if (self->reorder_index > original_index)
+ for (i = 0; i < self->reorder_index - original_index; i++) {
+ l = l->next;
+ animate_reorder_offset (self, l->data, 0);
+ }
+
+ if (self->reorder_index < original_index)
+ for (i = 0; i < original_index - self->reorder_index; i++) {
+ l = l->prev;
+ animate_reorder_offset (self, l->data, 0);
+ }
+}
+
+static void
+page_reordered_cb (AdwTabGrid *self,
+ AdwTabPage *page,
+ int index)
+{
+ GList *link;
+ int original_index;
+ TabInfo *info, *dest_tab;
+ gboolean is_rtl;
+
+ if (adw_tab_page_get_pinned (page) != self->pinned)
+ return;
+
+ self->continue_reorder = self->reordered_tab && page == self->reordered_tab->page;
+
+ if (self->continue_reorder)
+ reset_reorder_animations (self);
+ else
+ force_end_reordering (self);
+
+ link = find_link_for_page (self, page);
+ info = link->data;
+ original_index = g_list_position (self->tabs, link);
+
+ if (!self->continue_reorder)
+ start_reordering (self, info);
+
+ if (self->continue_reorder) {
+ self->reorder_x = self->reorder_window_x;
+ self->reorder_y = self->reorder_window_y;
+ } else {
+ self->reorder_x = info->pos_x;
+ self->reorder_y = info->pos_y;
+ }
+
+ self->reorder_index = index;
+
+ if (!self->pinned)
+ self->reorder_index -= adw_tab_view_get_n_pinned_pages (self->view);
+
+ dest_tab = g_list_nth_data (self->tabs, self->reorder_index);
+
+ if (info == self->selected_tab)
+ scroll_to_tab_full (self, self->selected_tab, dest_tab->final_y, REORDER_ANIMATION_DURATION, FALSE);
+
+ animate_reordering (self, dest_tab);
+
+ is_rtl = gtk_widget_get_direction (GTK_WIDGET (self)) == GTK_TEXT_DIR_RTL;
+
+ /* If animations are disabled, animate_reordering() animation will have
+ * already finished and called check_end_reordering () by this point, so
+ * it's too late to animate these, so we get a crash.
+ */
+
+ if (adw_get_enable_animations (GTK_WIDGET (self)) &&
+ gtk_widget_get_mapped (GTK_WIDGET (self))) {
+ int i;
+
+ if (self->reorder_index > original_index)
+ for (i = 0; i < self->reorder_index - original_index; i++) {
+ link = link->next;
+ animate_reorder_offset (self, link->data, is_rtl ? 1 : -1);
+ }
+
+ if (self->reorder_index < original_index)
+ for (i = 0; i < original_index - self->reorder_index; i++) {
+ link = link->prev;
+ animate_reorder_offset (self, link->data, is_rtl ? -1 : 1);
+ }
+ }
+
+ self->continue_reorder = FALSE;
+}
+
+static void
+update_drag_reodering (AdwTabGrid *self)
+{
+ gboolean is_rtl;
+ int old_index = -1, new_index = -1;
+ int x, y;
+ int i = 0;
+ int width, height;
+ GList *l;
+
+ if (!self->dragging)
+ return;
+
+ get_reorder_position (self, &x, &y);
+
+ width = self->reordered_tab->final_width;
+ height = self->reordered_tab->final_height;
+
+ self->reorder_window_x = x;
+ self->reorder_window_y = y;
+
+ gtk_widget_queue_allocate (GTK_WIDGET (self));
+
+ is_rtl = gtk_widget_get_direction (GTK_WIDGET (self)) == GTK_TEXT_DIR_RTL;
+
+ for (l = self->tabs; l; l = l->next) {
+ TabInfo *info = l->data;
+ int center_x, center_y;
+
+ center_x = info->unshifted_x + info->final_width / 2;
+ center_y = info->unshifted_y + info->final_height / 2;
+
+ if (is_rtl)
+ center_x -= info->final_width;
+
+ if (info == self->reordered_tab)
+ old_index = i;
+
+ if (x + width + SPACING > center_x && center_x >= x - SPACING &&
+ y + height + SPACING > center_y && center_y >= y - SPACING &&
+ new_index < 0)
+ new_index = i;
+
+ if (old_index >= 0 && new_index >= 0)
+ break;
+
+ i++;
+ }
+
+ if (new_index < 0)
+ new_index = g_list_length (self->tabs) - 1;
+
+ i = 0;
+
+ for (l = self->tabs; l; l = l->next) {
+ TabInfo *info = l->data;
+ double offset = 0;
+
+ if (i > old_index && i <= new_index)
+ offset = is_rtl ? 1 : -1;
+
+ if (i < old_index && i >= new_index)
+ offset = is_rtl ? -1 : 1;
+
+ i++;
+
+ animate_reorder_offset (self, info, offset);
+ }
+
+ self->reorder_index = new_index;
+}
+
+static gboolean
+drag_autoscroll_cb (GtkWidget *widget,
+ GdkFrameClock *frame_clock,
+ AdwTabGrid *self)
+{
+ double y, delta_ms, start_threshold, end_threshold, autoscroll_factor;
+ gint64 time;
+ int offset = 0;
+ int tab_height = 0;
+ int autoscroll_area = 0;
+
+ if (self->visible_upper - self->visible_lower >= self->allocated_height)
+ return G_SOURCE_CONTINUE;
+
+ if (self->reordered_tab) {
+ tab_height = self->reordered_tab->height;
+ y = (double) self->reorder_y - SPACING;
+ } else if (self->drop_target_tab) {
+ tab_height = self->drop_target_tab->height;
+ y = (double) self->drop_target_y - tab_height / 2;
+ } else {
+ return G_SOURCE_CONTINUE;
+ }
+
+ autoscroll_area = tab_height / 2;
+
+ y = CLAMP (y,
+ autoscroll_area,
+ self->allocated_height - tab_height - autoscroll_area);
+
+ time = gdk_frame_clock_get_frame_time (frame_clock);
+ delta_ms = (time - self->drag_autoscroll_prev_time) / 1000.0;
+
+ start_threshold = self->visible_lower + autoscroll_area;
+ end_threshold = self->visible_upper - tab_height - autoscroll_area;
+
+ autoscroll_factor = 0;
+
+ if (y < start_threshold)
+ autoscroll_factor = -(start_threshold - y) / autoscroll_area;
+ else if (y > end_threshold)
+ autoscroll_factor = (y - end_threshold) / autoscroll_area;
+
+ autoscroll_factor = CLAMP (autoscroll_factor, -1, 1);
+ autoscroll_factor = adw_easing_ease (ADW_EASE_IN_CUBIC,
+ autoscroll_factor);
+ self->drag_autoscroll_prev_time = time;
+
+ if (autoscroll_factor == 0)
+ return G_SOURCE_CONTINUE;
+
+ if (autoscroll_factor > 0)
+ offset = (int) ceil (autoscroll_factor * delta_ms * AUTOSCROLL_SPEED);
+ else
+ offset = (int) floor (autoscroll_factor * delta_ms * AUTOSCROLL_SPEED);
+
+ self->reorder_y += offset;
+ animate_scroll_relative (self, offset, 0);
+ update_drag_reodering (self);
+
+ return G_SOURCE_CONTINUE;
+}
+
+static void
+start_autoscroll (AdwTabGrid *self)
+{
+ GdkFrameClock *frame_clock;
+
+ if (self->drag_autoscroll_cb_id)
+ return;
+
+ frame_clock = gtk_widget_get_frame_clock (GTK_WIDGET (self));
+
+ self->drag_autoscroll_prev_time = gdk_frame_clock_get_frame_time (frame_clock);
+ self->drag_autoscroll_cb_id =
+ gtk_widget_add_tick_callback (GTK_WIDGET (self),
+ (GtkTickCallback) drag_autoscroll_cb,
+ self, NULL);
+}
+
+static void
+end_autoscroll (AdwTabGrid *self)
+{
+ if (self->drag_autoscroll_cb_id) {
+ gtk_widget_remove_tick_callback (GTK_WIDGET (self),
+ self->drag_autoscroll_cb_id);
+ self->drag_autoscroll_cb_id = 0;
+ }
+}
+
+static void
+start_drag_reodering (AdwTabGrid *self,
+ TabInfo *info,
+ double x,
+ double y)
+{
+ if (self->dragging)
+ return;
+
+ if (self->searching)
+ return;
+
+ if (!info)
+ return;
+
+ self->continue_reorder = info == self->reordered_tab;
+
+ if (self->continue_reorder) {
+ if (self->reorder_animation)
+ adw_animation_skip (self->reorder_animation);
+
+ reset_reorder_animations (self);
+
+ self->reorder_x = (int) round (x - self->drag_offset_x);
+ self->reorder_y = (int) round (y - self->drag_offset_y);
+ } else
+ force_end_reordering (self);
+
+ start_autoscroll (self);
+ self->dragging = TRUE;
+
+ if (!self->continue_reorder)
+ start_reordering (self, info);
+}
+
+static void
+end_drag_reodering (AdwTabGrid *self)
+{
+ TabInfo *dest_tab;
+
+ if (!self->dragging)
+ return;
+
+ self->dragging = FALSE;
+
+ end_autoscroll (self);
+
+ dest_tab = g_list_nth_data (self->tabs, self->reorder_index);
+
+ if (!self->indirect_reordering) {
+ int index = self->reorder_index;
+
+ if (!self->pinned)
+ index += adw_tab_view_get_n_pinned_pages (self->view);
+
+ /* We've already reordered the tab here, no need to do it again */
+ g_signal_handlers_block_by_func (self->view, page_reordered_cb, self);
+
+ adw_tab_view_reorder_page (self->view, self->reordered_tab->page, index);
+
+ g_signal_handlers_unblock_by_func (self->view, page_reordered_cb, self);
+ }
+
+ animate_reordering (self, dest_tab);
+
+ self->continue_reorder = FALSE;
+}
+
+static void
+reorder_begin_cb (AdwTabGrid *self,
+ double start_x,
+ double start_y,
+ GtkGesture *gesture)
+{
+ self->pressed_tab = find_tab_info_at (self, start_x, start_y);
+
+ if (!self->pressed_tab)
+ return;
+
+ self->drag_offset_x = start_x - get_tab_x (self, self->pressed_tab, FALSE);
+ self->drag_offset_y = start_y - get_tab_y (self, self->pressed_tab, FALSE);
+
+ if (!self->reorder_animation) {
+ self->reorder_x = (int) round (start_x - self->drag_offset_x);
+ self->reorder_y = (int) round (start_y - self->drag_offset_y);
+ }
+}
+
+/* Copied from gtkdragsource.c */
+static gboolean
+gtk_drag_check_threshold_double (GtkWidget *widget,
+ double start_x,
+ double start_y,
+ double current_x,
+ double current_y)
+{
+ int drag_threshold;
+
+ g_object_get (gtk_widget_get_settings (widget),
+ "gtk-dnd-drag-threshold", &drag_threshold,
+ NULL);
+
+ return (ABS (current_x - start_x) > drag_threshold ||
+ ABS (current_y - start_y) > drag_threshold);
+}
+
+static gboolean
+check_dnd_threshold (AdwTabGrid *self,
+ double x,
+ double y)
+{
+ int threshold;
+ graphene_rect_t rect;
+
+ g_object_get (gtk_widget_get_settings (GTK_WIDGET (self)),
+ "gtk-dnd-drag-threshold", &threshold,
+ NULL);
+
+ threshold *= DND_THRESHOLD_MULTIPLIER;
+
+ graphene_rect_init (&rect, 0, 0,
+ gtk_widget_get_width (GTK_WIDGET (self)),
+ self->allocated_height);
+ graphene_rect_inset (&rect, -threshold, -threshold);
+
+ return !graphene_rect_contains_point (&rect, &GRAPHENE_POINT_INIT (x, y));
+}
+
+static void begin_drag (AdwTabGrid *self,
+ GdkDevice *device);
+
+static void
+reorder_update_cb (AdwTabGrid *self,
+ double offset_x,
+ double offset_y,
+ GtkGesture *gesture)
+{
+ double start_x, start_y, x, y;
+ GdkDevice *device;
+
+ if (!self->pressed_tab) {
+ gtk_gesture_set_state (gesture, GTK_EVENT_SEQUENCE_DENIED);
+ return;
+ }
+
+ if (!self->dragging &&
+ !gtk_drag_check_threshold_double (GTK_WIDGET (self), 0, 0,
+ offset_x, offset_y))
+ return;
+
+ gtk_gesture_drag_get_start_point (GTK_GESTURE_DRAG (gesture),
+ &start_x, &start_y);
+
+ x = start_x + offset_x;
+ y = start_y + offset_y;
+
+ start_drag_reodering (self, self->pressed_tab, x, y);
+
+ if (self->dragging) {
+ adw_tab_view_set_selected_page (self->view, self->pressed_tab->page);
+ gtk_gesture_set_state (gesture, GTK_EVENT_SEQUENCE_CLAIMED);
+ } else {
+ gtk_gesture_set_state (gesture, GTK_EVENT_SEQUENCE_DENIED);
+ return;
+ }
+
+ self->reorder_x = (int) round (x - self->drag_offset_x);
+ self->reorder_y = (int) round (y - self->drag_offset_y);
+
+ device = gtk_event_controller_get_current_event_device (GTK_EVENT_CONTROLLER (gesture));
+
+ if (!self->pinned &&
+ self->pressed_tab &&
+ self->pressed_tab != self->reorder_placeholder &&
+ self->pressed_tab->page &&
+ !is_touchscreen (gesture) &&
+ adw_tab_view_get_n_pages (self->view) > 1 &&
+ check_dnd_threshold (self, x, y)) {
+ begin_drag (self, device);
+
+ gtk_gesture_set_state (gesture, GTK_EVENT_SEQUENCE_DENIED);
+
+ return;
+ }
+
+ update_drag_reodering (self);
+}
+
+static void
+reorder_end_cb (AdwTabGrid *self,
+ double offset_x,
+ double offset_y,
+ GtkGesture *gesture)
+{
+ end_drag_reodering (self);
+}
+
+/* Selection */
+
+static void
+reset_focus (AdwTabGrid *self)
+{
+ GtkRoot *root = gtk_widget_get_root (GTK_WIDGET (self));
+
+ gtk_widget_set_focus_child (GTK_WIDGET (self), NULL);
+
+ if (root)
+ gtk_root_set_focus (root, NULL);
+}
+
+static void
+select_page (AdwTabGrid *self,
+ AdwTabPage *page)
+{
+ if (!page) {
+ self->selected_tab = NULL;
+
+ reset_focus (self);
+
+ return;
+ }
+
+ self->selected_tab = find_info_for_page (self, page);
+
+ if (!self->selected_tab) {
+ if (gtk_widget_get_focus_child (GTK_WIDGET (self)))
+ reset_focus (self);
+
+ return;
+ }
+
+ if (adw_tab_overview_tabs_have_visible_focus (self->tab_overview))
+ gtk_widget_grab_focus (self->selected_tab->container);
+
+ gtk_widget_set_focus_child (GTK_WIDGET (self),
+ self->selected_tab->container);
+
+ if (self->selected_tab->width >= 0)
+ scroll_to_tab (self, self->selected_tab, FOCUS_ANIMATION_DURATION);
+}
+
+/* Opening */
+
+static gboolean
+extra_drag_drop_cb (AdwTabThumbnail *tab,
+ GValue *value,
+ AdwTabGrid *self)
+{
+ gboolean ret = GDK_EVENT_PROPAGATE;
+ AdwTabPage *page = adw_tab_thumbnail_get_page (tab);
+
+ g_signal_emit (self, signals[SIGNAL_EXTRA_DRAG_DROP], 0, page, value, &ret);
+
+ return ret;
+}
+
+static void
+appear_animation_value_cb (double value,
+ TabInfo *info)
+{
+ info->appear_progress = value;
+
+ if (GTK_IS_WIDGET (info->container))
+ gtk_widget_queue_resize (info->container);
+}
+
+static void
+open_animation_done_cb (TabInfo *info)
+{
+ g_clear_object (&info->appear_animation);
+}
+
+static void
+measure_tab (AdwGizmo *widget,
+ GtkOrientation orientation,
+ int for_size,
+ int *minimum,
+ int *natural,
+ int *minimum_baseline,
+ int *natural_baseline)
+{
+ GtkWidget *child = gtk_widget_get_first_child (GTK_WIDGET (widget));
+
+ gtk_widget_measure (child, orientation, for_size,
+ minimum, natural,
+ minimum_baseline, natural_baseline);
+
+ if (orientation == GTK_ORIENTATION_HORIZONTAL && minimum)
+ *minimum = 0;
+}
+
+static void
+allocate_tab (AdwGizmo *widget,
+ int width,
+ int height,
+ int baseline)
+{
+ TabInfo *info = g_object_get_data (G_OBJECT (widget), "info");
+ GtkWidget *child = gtk_widget_get_first_child (GTK_WIDGET (widget));
+ int allocated_width = gtk_widget_get_allocated_width (GTK_WIDGET (widget));
+ int width_diff = MAX (0, info->final_width - allocated_width);
+
+ gtk_widget_allocate (child, width + width_diff, height, baseline,
+ gsk_transform_translate (NULL, &GRAPHENE_POINT_INIT (-width_diff / 2, 0)));
+}
+
+static TabInfo *
+create_tab_info (AdwTabGrid *self,
+ AdwTabPage *page)
+{
+ TabInfo *info;
+
+ info = g_new0 (TabInfo, 1);
+ info->box = self;
+ info->page = page;
+ info->unshifted_x = -1;
+ info->unshifted_y = -1;
+ info->pos_x = -1;
+ info->pos_y = -1;
+ info->width = -1;
+ info->height = -1;
+ info->visible = tab_should_be_visible (self, page);
+ info->container = adw_gizmo_new ("tabgridchild", measure_tab, allocate_tab,
+ NULL, NULL,
+ (AdwGizmoFocusFunc) adw_widget_focus_child,
+ (AdwGizmoGrabFocusFunc) adw_widget_grab_focus_self);
+ gtk_widget_set_visible (info->container, info->visible);
+ info->tab = adw_tab_thumbnail_new (self->view, self->pinned);
+
+ g_object_set_data (G_OBJECT (info->container), "info", info);
+ gtk_widget_set_overflow (info->container, GTK_OVERFLOW_HIDDEN);
+ gtk_widget_set_focusable (info->container, TRUE);
+
+ adw_tab_thumbnail_set_page (info->tab, page);
+ adw_tab_thumbnail_set_inverted (info->tab, self->inverted);
+ adw_tab_thumbnail_set_align (info->tab, self->thumbnail_xalign, self->thumbnail_yalign);
+ adw_tab_thumbnail_setup_extra_drop_target (info->tab,
+ self->extra_drag_actions,
+ self->extra_drag_types,
+ self->extra_drag_n_types);
+
+ gtk_widget_set_parent (GTK_WIDGET (info->tab), info->container);
+ gtk_widget_insert_before (info->container, GTK_WIDGET (self), self->needs_attention_top);
+
+ g_signal_connect_object (info->tab, "extra-drag-drop", G_CALLBACK (extra_drag_drop_cb), self, 0);
+
+ return info;
+}
+
+static void
+page_attached_cb (AdwTabGrid *self,
+ AdwTabPage *page,
+ int position)
+{
+ AdwAnimationTarget *target;
+ TabInfo *info;
+ GList *l;
+
+ if (adw_tab_page_get_pinned (page) != self->pinned)
+ return;
+
+ if (!self->pinned)
+ position -= adw_tab_view_get_n_pinned_pages (self->view);
+
+ set_tab_resize_mode (self, TAB_RESIZE_NORMAL);
+ force_end_reordering (self);
+
+ info = create_tab_info (self, page);
+
+ info->notify_needs_attention_id =
+ g_signal_connect_object (page,
+ "notify::needs-attention",
+ G_CALLBACK (update_visible),
+ self,
+ G_CONNECT_SWAPPED);
+
+ target = adw_callback_animation_target_new ((AdwAnimationTargetFunc)
+ appear_animation_value_cb,
+ info, NULL);
+ info->appear_animation =
+ adw_timed_animation_new (GTK_WIDGET (self), 0, 1,
+ OPEN_ANIMATION_DURATION, target);
+
+ g_signal_connect_swapped (info->appear_animation, "done",
+ G_CALLBACK (open_animation_done_cb), info);
+
+ l = find_nth_alive_tab (self, position);
+ self->tabs = g_list_insert_before (self->tabs, l, info);
+
+ self->n_tabs++;
+
+ if (!self->searching)
+ set_empty (self, FALSE);
+
+ adw_animation_play (info->appear_animation);
+
+ calculate_tab_layout (self);
+
+ if (page == adw_tab_view_get_selected_page (self->view))
+ adw_tab_grid_select_page (self, page);
+ else
+ scroll_to_tab_full (self, info, -1, OPEN_ANIMATION_DURATION, TRUE);
+}
+
+/* Closing */
+
+static void
+close_animation_done_cb (TabInfo *info)
+{
+ AdwTabGrid *self = info->box;
+
+ g_clear_object (&info->appear_animation);
+
+ self->tabs = g_list_remove (self->tabs, info);
+
+ if (info->reorder_animation)
+ adw_animation_skip (info->reorder_animation);
+
+ if (self->reorder_animation)
+ adw_animation_skip (self->reorder_animation);
+
+ if (self->pressed_tab == info)
+ self->pressed_tab = NULL;
+
+ if (self->reordered_tab == info)
+ self->reordered_tab = NULL;
+
+ remove_and_free_tab_info (info);
+
+ self->n_tabs--;
+
+ if (!self->searching && self->n_tabs == 0)
+ set_empty (self, TRUE);
+}
+
+static void
+page_detached_cb (AdwTabGrid *self,
+ AdwTabPage *page)
+{
+ AdwAnimationTarget *target;
+ TabInfo *info;
+ GList *page_link;
+
+ page_link = find_link_for_page (self, page);
+
+ if (!page_link)
+ return;
+
+ info = page_link->data;
+ page_link = page_link->next;
+
+ force_end_reordering (self);
+
+ if (self->hovering) {
+ gboolean is_last = TRUE;
+
+ while (page_link) {
+ TabInfo *i = page_link->data;
+ page_link = page_link->next;
+
+ if (i->page) {
+ is_last = FALSE;
+ break;
+ }
+ }
+
+ if (is_last && !self->pinned)
+ set_tab_resize_mode (self, TAB_RESIZE_NORMAL);
+ else
+ set_tab_resize_mode (self, TAB_RESIZE_FIXED_TAB_SIZE);
+ }
+
+ g_assert (info->page);
+
+ if (gtk_widget_is_focus (info->container))
+ adw_tab_grid_try_focus_selected_tab (self);
+
+ if (info == self->selected_tab)
+ adw_tab_grid_select_page (self, NULL);
+
+ adw_tab_thumbnail_set_page (info->tab, NULL);
+
+ if (info->notify_needs_attention_id > 0) {
+ g_signal_handler_disconnect (info->page, info->notify_needs_attention_id);
+ info->notify_needs_attention_id = 0;
+ }
+
+ info->page = NULL;
+
+ if (info->appear_animation)
+ adw_animation_skip (info->appear_animation);
+
+ target = adw_callback_animation_target_new ((AdwAnimationTargetFunc)
+ appear_animation_value_cb,
+ info, NULL);
+ info->appear_animation =
+ adw_timed_animation_new (GTK_WIDGET (self), info->appear_progress, 0,
+ CLOSE_ANIMATION_DURATION, target);
+
+ g_signal_connect_swapped (info->appear_animation, "done",
+ G_CALLBACK (close_animation_done_cb), info);
+
+ adw_animation_play (info->appear_animation);
+}
+
+/* Tab DND */
+
+#define ADW_TYPE_TAB_GRID_ROOT_CONTENT (adw_tab_grid_root_content_get_type ())
+
+G_DECLARE_FINAL_TYPE (AdwTabGridRootContent, adw_tab_grid_root_content, ADW, TAB_GRID_ROOT_CONTENT,
GdkContentProvider)
+
+struct _AdwTabGridRootContent
+{
+ GdkContentProvider parent_instance;
+
+ AdwTabGrid *tab_grid;
+};
+
+G_DEFINE_FINAL_TYPE (AdwTabGridRootContent, adw_tab_grid_root_content, GDK_TYPE_CONTENT_PROVIDER)
+
+static GdkContentFormats *
+adw_tab_grid_root_content_ref_formats (GdkContentProvider *provider)
+{
+ return gdk_content_formats_new ((const char *[1]) { "application/x-rootwindow-drop" }, 1);
+}
+
+static void
+adw_tab_grid_root_content_write_mime_type_async (GdkContentProvider *provider,
+ const char *mime_type,
+ GOutputStream *stream,
+ int io_priority,
+ GCancellable *cancellable,
+ GAsyncReadyCallback callback,
+ gpointer user_data)
+{
+ AdwTabGridRootContent *self = ADW_TAB_GRID_ROOT_CONTENT (provider);
+ GTask *task;
+
+ self->tab_grid->should_detach_into_new_window = TRUE;
+
+ task = g_task_new (self, cancellable, callback, user_data);
+ g_task_set_priority (task, io_priority);
+ g_task_set_source_tag (task, adw_tab_grid_root_content_write_mime_type_async);
+ g_task_return_boolean (task, TRUE);
+
+ g_object_unref (task);
+}
+
+static gboolean
+adw_tab_grid_root_content_write_mime_type_finish (GdkContentProvider *provider,
+ GAsyncResult *result,
+ GError **error)
+{
+ return g_task_propagate_boolean (G_TASK (result), error);
+}
+
+static void
+adw_tab_grid_root_content_finalize (GObject *object)
+{
+ AdwTabGridRootContent *self = ADW_TAB_GRID_ROOT_CONTENT (object);
+
+ g_clear_object (&self->tab_grid);
+
+ G_OBJECT_CLASS (adw_tab_grid_root_content_parent_class)->finalize (object);
+}
+
+static void
+adw_tab_grid_root_content_class_init (AdwTabGridRootContentClass *klass)
+{
+ GObjectClass *object_class = G_OBJECT_CLASS (klass);
+ GdkContentProviderClass *provider_class = GDK_CONTENT_PROVIDER_CLASS (klass);
+
+ object_class->finalize = adw_tab_grid_root_content_finalize;
+
+ provider_class->ref_formats = adw_tab_grid_root_content_ref_formats;
+ provider_class->write_mime_type_async = adw_tab_grid_root_content_write_mime_type_async;
+ provider_class->write_mime_type_finish = adw_tab_grid_root_content_write_mime_type_finish;
+}
+
+static void
+adw_tab_grid_root_content_init (AdwTabGridRootContent *self)
+{
+}
+
+static GdkContentProvider *
+adw_tab_grid_root_content_new (AdwTabGrid *tab_grid)
+{
+ AdwTabGridRootContent *self = g_object_new (ADW_TYPE_TAB_GRID_ROOT_CONTENT, NULL);
+
+ self->tab_grid = g_object_ref (tab_grid);
+
+ return GDK_CONTENT_PROVIDER (self);
+}
+
+static int
+calculate_placeholder_index (AdwTabGrid *self,
+ int x,
+ int y)
+{
+ int lower, upper, i;
+ gboolean is_rtl;
+
+ get_visible_range (self, &lower, &upper);
+
+ x = CLAMP (x, 0, self->allocated_width);
+ y = CLAMP (y, lower, upper);
+
+ is_rtl = gtk_widget_get_direction (GTK_WIDGET (self)) == GTK_TEXT_DIR_RTL;
+
+ for (i = 0; i < self->n_tabs; i++) {
+ int tab_x, tab_y;
+
+ get_position_for_index (self, i, is_rtl, &tab_x, &tab_y);
+
+ if (x <= tab_x + self->tab_height + SPACING / 2 &&
+ y <= tab_y + self->tab_width + SPACING / 2)
+ return i;
+ }
+
+ return i;
+}
+
+static void
+insert_animation_value_cb (double value,
+ TabInfo *info)
+{
+ AdwTabGrid *self = info->box;
+
+ appear_animation_value_cb (value, info);
+
+ update_drag_reodering (self);
+}
+
+static void
+insert_placeholder (AdwTabGrid *self,
+ AdwTabPage *page,
+ int x,
+ int y)
+{
+ TabInfo *info = self->reorder_placeholder;
+ double initial_progress = 0;
+ AdwAnimationTarget *target;
+
+ if (info) {
+ initial_progress = info->appear_progress;
+
+ if (info->appear_animation)
+ adw_animation_skip (info->appear_animation);
+ } else {
+ int index;
+
+ self->placeholder_page = page;
+
+ info = create_tab_info (self, page);
+
+ gtk_widget_set_opacity (info->container, 0);
+
+ adw_tab_thumbnail_set_dragging (info->tab, TRUE);
+
+ info->reorder_ignore_bounds = TRUE;
+
+ index = calculate_placeholder_index (self, x, y);
+
+ self->tabs = g_list_insert (self->tabs, info, index);
+ self->n_tabs++;
+
+ if (!self->searching)
+ set_empty (self, FALSE);
+
+ self->reorder_placeholder = info;
+ self->reorder_index = g_list_index (self->tabs, info);
+ }
+
+ target = adw_callback_animation_target_new ((AdwAnimationTargetFunc)
+ insert_animation_value_cb,
+ info, NULL);
+ info->appear_animation =
+ adw_timed_animation_new (GTK_WIDGET (self), initial_progress, 1,
+ OPEN_ANIMATION_DURATION, target);
+
+ g_signal_connect_swapped (info->appear_animation, "done",
+ G_CALLBACK (open_animation_done_cb), info);
+
+ adw_animation_play (info->appear_animation);
+}
+
+static void
+replace_animation_done_cb (TabInfo *info)
+{
+ AdwTabGrid *self = info->box;
+
+ g_clear_object (&info->appear_animation);
+ self->reorder_placeholder = NULL;
+ self->can_remove_placeholder = TRUE;
+}
+
+static void
+replace_placeholder (AdwTabGrid *self,
+ AdwTabPage *page)
+{
+ TabInfo *info = self->reorder_placeholder;
+ double initial_progress;
+ AdwAnimationTarget *target;
+
+ gtk_widget_set_opacity (self->reorder_placeholder->container, 1);
+ adw_tab_thumbnail_set_dragging (info->tab, FALSE);
+
+ if (!info->appear_animation) {
+ self->reorder_placeholder = NULL;
+
+ return;
+ }
+
+ initial_progress = info->appear_progress;
+
+ self->can_remove_placeholder = FALSE;
+
+ adw_tab_thumbnail_set_page (info->tab, page);
+ info->page = page;
+
+ adw_animation_skip (info->appear_animation);
+
+ target = adw_callback_animation_target_new ((AdwAnimationTargetFunc)
+ appear_animation_value_cb,
+ info, NULL);
+ info->appear_animation =
+ adw_timed_animation_new (GTK_WIDGET (self), initial_progress, 1,
+ OPEN_ANIMATION_DURATION, target);
+
+ g_signal_connect_swapped (info->appear_animation, "done",
+ G_CALLBACK (replace_animation_done_cb), info);
+
+ adw_animation_play (info->appear_animation);
+}
+
+static void
+remove_animation_done_cb (TabInfo *info)
+{
+ AdwTabGrid *self = info->box;
+
+ g_clear_object (&info->appear_animation);
+
+ if (!self->can_remove_placeholder) {
+ adw_tab_thumbnail_set_page (info->tab, self->placeholder_page);
+ info->page = self->placeholder_page;
+
+ return;
+ }
+
+ if (self->reordered_tab == info) {
+ force_end_reordering (self);
+
+ if (info->reorder_animation)
+ adw_animation_skip (info->reorder_animation);
+
+ self->reordered_tab = NULL;
+ }
+
+ if (self->pressed_tab == info)
+ self->pressed_tab = NULL;
+
+ self->tabs = g_list_remove (self->tabs, info);
+
+ remove_and_free_tab_info (info);
+
+ self->n_tabs--;
+
+ self->reorder_placeholder = NULL;
+}
+
+static void
+remove_placeholder (AdwTabGrid *self)
+{
+ TabInfo *info = self->reorder_placeholder;
+ AdwAnimationTarget *target;
+
+ if (!info || !info->page)
+ return;
+
+ adw_tab_thumbnail_set_page (info->tab, NULL);
+ info->page = NULL;
+
+ if (info->appear_animation)
+ adw_animation_skip (info->appear_animation);
+
+ target = adw_callback_animation_target_new ((AdwAnimationTargetFunc)
+ appear_animation_value_cb,
+ info, NULL);
+ info->appear_animation =
+ adw_timed_animation_new (GTK_WIDGET (self), info->appear_progress, 0,
+ CLOSE_ANIMATION_DURATION, target);
+
+ g_signal_connect_swapped (info->appear_animation, "done",
+ G_CALLBACK (remove_animation_done_cb), info);
+
+ adw_animation_play (info->appear_animation);
+}
+
+static inline AdwTabGrid *
+get_source_tab_grid (GtkDropTarget *target)
+{
+ GdkDrop *drop = gtk_drop_target_get_current_drop (target);
+ GdkDrag *drag = gdk_drop_get_drag (drop);
+
+ if (!drag)
+ return NULL;
+
+ return ADW_TAB_GRID (g_object_get_data (G_OBJECT (drag),
+ "adw-tab-overview-drag-origin"));
+}
+
+static void
+do_drag_drop (AdwTabGrid *self,
+ AdwTabGrid *source_tab_grid)
+{
+ AdwTabPage *page = source_tab_grid->detached_page;
+ int offset = (self->pinned ? 0 : adw_tab_view_get_n_pinned_pages (self->view));
+
+ if (self->reorder_placeholder) {
+ replace_placeholder (self, page);
+ end_drag_reodering (self);
+
+ g_signal_handlers_block_by_func (self->view, page_attached_cb, self);
+
+ adw_tab_view_attach_page (self->view, page, self->reorder_index + offset);
+
+ g_signal_handlers_unblock_by_func (self->view, page_attached_cb, self);
+ } else {
+ adw_tab_view_attach_page (self->view, page, self->reorder_index + offset);
+ }
+
+ source_tab_grid->should_detach_into_new_window = FALSE;
+ source_tab_grid->detached_page = NULL;
+
+ self->indirect_reordering = FALSE;
+}
+
+static void
+detach_into_new_window (AdwTabGrid *self)
+{
+ AdwTabPage *page;
+ AdwTabView *new_view;
+
+ page = self->detached_page;
+
+ new_view = adw_tab_view_create_window (self->view);
+
+ if (ADW_IS_TAB_VIEW (new_view))
+ adw_tab_view_attach_page (new_view, page, 0);
+ else
+ adw_tab_view_attach_page (self->view, page, self->detached_index);
+
+ self->should_detach_into_new_window = FALSE;
+}
+
+static gboolean
+is_view_in_the_same_group (AdwTabGrid *self,
+ AdwTabView *other_view)
+{
+ /* TODO when we have groups, this should do the actual check */
+ return TRUE;
+}
+
+static void
+drag_end (AdwTabGrid *self,
+ GdkDrag *drag,
+ gboolean success)
+{
+ g_signal_handlers_disconnect_by_data (drag, self);
+
+ gdk_drag_drop_done (drag, success);
+
+ if (!success) {
+ adw_tab_view_attach_page (self->view,
+ self->detached_page,
+ self->detached_index);
+
+ self->indirect_reordering = FALSE;
+ }
+
+ self->detached_page = NULL;
+
+ if (self->drag_icon) {
+ g_clear_object (&self->drag_icon->resize_animation);
+ g_clear_pointer (&self->drag_icon, g_free);
+ }
+
+ g_object_unref (drag);
+}
+
+static void
+tab_drop_performed_cb (AdwTabGrid *self,
+ GdkDrag *drag)
+{
+ /* Catch drops into our windows, but outside of tab views. If this is a false
+ * positive, it will be set to FALSE in do_drag_drop(). */
+ self->should_detach_into_new_window = TRUE;
+}
+
+static void
+tab_dnd_finished_cb (AdwTabGrid *self,
+ GdkDrag *drag)
+{
+ if (self->should_detach_into_new_window)
+ detach_into_new_window (self);
+
+ drag_end (self, drag, TRUE);
+}
+
+static void
+tab_drag_cancel_cb (AdwTabGrid *self,
+ GdkDragCancelReason reason,
+ GdkDrag *drag)
+{
+ if (reason == GDK_DRAG_CANCEL_NO_TARGET) {
+ detach_into_new_window (self);
+ drag_end (self, drag, TRUE);
+
+ return;
+ }
+
+ self->should_detach_into_new_window = FALSE;
+ drag_end (self, drag, FALSE);
+}
+
+static void
+icon_resize_animation_value_cb (double value,
+ DragIcon *icon)
+{
+ double relative_x, relative_y;
+
+ relative_x = (double) icon->hotspot_x / icon->width;
+ relative_y = (double) icon->hotspot_y / icon->height;
+
+ icon->width = (int) round (adw_lerp (icon->initial_width, icon->target_width, value));
+ icon->height = (int) round (adw_lerp (icon->initial_height, icon->target_height, value));
+
+ gtk_widget_set_size_request (GTK_WIDGET (icon->tab),
+ icon->width + icon->tab_margin.left + icon->tab_margin.right,
+ icon->height + icon->tab_margin.top + icon->tab_margin.bottom);
+
+ icon->hotspot_x = (int) round (icon->width * relative_x);
+ icon->hotspot_y = (int) round (icon->height * relative_y);
+
+ gdk_drag_set_hotspot (icon->drag,
+ icon->hotspot_x + icon->tab_margin.left,
+ icon->hotspot_y + icon->tab_margin.top);
+
+ gtk_widget_queue_resize (GTK_WIDGET (icon->tab));
+}
+
+static void
+create_drag_icon (AdwTabGrid *self,
+ GdkDrag *drag)
+{
+ DragIcon *icon;
+ AdwAnimationTarget *target;
+
+ icon = g_new0 (DragIcon, 1);
+
+ icon->drag = drag;
+
+ icon->width = self->tab_width;
+ icon->initial_width = icon->width;
+ icon->target_width = icon->width;
+
+ icon->height = self->tab_height;
+ icon->initial_width = icon->height;
+ icon->target_width = icon->height;
+
+ icon->tab = adw_tab_thumbnail_new (self->view, FALSE);
+ adw_tab_thumbnail_set_page (icon->tab, self->reordered_tab->page);
+ adw_tab_thumbnail_set_dragging (icon->tab, TRUE);
+ adw_tab_thumbnail_set_inverted (icon->tab, self->inverted);
+ adw_tab_thumbnail_set_align (icon->tab, self->thumbnail_xalign, self->thumbnail_yalign);
+ gtk_widget_set_halign (GTK_WIDGET (icon->tab), GTK_ALIGN_START);
+
+ gtk_drag_icon_set_child (GTK_DRAG_ICON (gtk_drag_icon_get_for_drag (drag)),
+ GTK_WIDGET (icon->tab));
+
+ gtk_style_context_get_margin (gtk_widget_get_style_context (GTK_WIDGET (icon->tab)),
+ &icon->tab_margin);
+
+ gtk_widget_set_size_request (GTK_WIDGET (icon->tab),
+ icon->width + icon->tab_margin.left + icon->tab_margin.right,
+ icon->height + icon->tab_margin.top + icon->tab_margin.bottom);
+
+ icon->hotspot_x = (int) self->drag_offset_x;
+ icon->hotspot_y = (int) self->drag_offset_y;
+
+ gdk_drag_set_hotspot (drag,
+ icon->hotspot_x + icon->tab_margin.left,
+ icon->hotspot_y + icon->tab_margin.top);
+
+ target = adw_callback_animation_target_new ((AdwAnimationTargetFunc)
+ icon_resize_animation_value_cb,
+ icon, NULL);
+ icon->resize_animation =
+ adw_timed_animation_new (GTK_WIDGET (icon->tab), 0, 1,
+ ICON_RESIZE_ANIMATION_DURATION, target);
+
+ self->drag_icon = icon;
+}
+
+static void
+resize_drag_icon (AdwTabGrid *self,
+ int width,
+ int height)
+{
+ DragIcon *icon = self->drag_icon;
+
+ if (width == icon->target_width && height == icon->target_height)
+ return;
+
+ icon->initial_width = icon->width;
+ icon->initial_height = icon->height;
+
+ icon->target_width = width;
+ icon->target_height = height;
+
+ adw_animation_play (icon->resize_animation);
+}
+
+static void
+begin_drag (AdwTabGrid *self,
+ GdkDevice *device)
+{
+ GdkContentProvider *content;
+ GtkNative *native;
+ GdkSurface *surface;
+ GdkDrag *drag;
+ TabInfo *detached_info;
+ GtkWidget *detached_tab;
+
+ native = gtk_widget_get_native (GTK_WIDGET (self));
+ surface = gtk_native_get_surface (native);
+
+ self->hovering = TRUE;
+ get_other_tab_grid (self)->hovering = TRUE;
+ self->pressed_tab = NULL;
+
+ detached_info = self->reordered_tab;
+ detached_tab = g_object_ref (detached_info->container);
+ self->detached_page = detached_info->page;
+
+ self->indirect_reordering = TRUE;
+
+ content = gdk_content_provider_new_union ((GdkContentProvider *[2]) {
+ adw_tab_grid_root_content_new (self),
+ gdk_content_provider_new_typed (ADW_TYPE_TAB_PAGE,
detached_info->page)
+ }, 2);
+
+ drag = gdk_drag_begin (surface, device, content, GDK_ACTION_MOVE,
+ self->reorder_x, self->reorder_y);
+
+ g_object_set_data (G_OBJECT (drag), "adw-tab-overview-drag-origin", self);
+
+ g_signal_connect_swapped (drag, "drop-performed",
+ G_CALLBACK (tab_drop_performed_cb), self);
+ g_signal_connect_swapped (drag, "dnd-finished",
+ G_CALLBACK (tab_dnd_finished_cb), self);
+ g_signal_connect_swapped (drag, "cancel",
+ G_CALLBACK (tab_drag_cancel_cb), self);
+
+ create_drag_icon (self, drag);
+
+ end_drag_reodering (self);
+ update_hover (self);
+
+ gtk_widget_set_opacity (detached_tab, 0);
+ self->detached_index = adw_tab_view_get_page_position (self->view, self->detached_page);
+
+ adw_tab_view_detach_page (self->view, self->detached_page);
+
+ self->indirect_reordering = FALSE;
+
+ g_object_unref (content);
+ g_object_unref (detached_tab);
+}
+
+static GdkDragAction
+tab_drag_enter_motion_cb (AdwTabGrid *self,
+ double x,
+ double y,
+ GtkDropTarget *target)
+{
+ AdwTabGrid *source_tab_grid;
+
+ if (self->pinned)
+ return 0;
+
+ if (self->searching)
+ return 0;
+
+ source_tab_grid = get_source_tab_grid (target);
+
+ if (!source_tab_grid)
+ return 0;
+
+ if (!self->view || !is_view_in_the_same_group (self, source_tab_grid->view))
+ return 0;
+
+ self->can_remove_placeholder = FALSE;
+
+ if (!self->reorder_placeholder || !self->reorder_placeholder->page) {
+ AdwTabPage *page = source_tab_grid->detached_page;
+ double center_x = x - source_tab_grid->drag_icon->hotspot_x + source_tab_grid->drag_icon->width / 2;
+ double center_y = y - source_tab_grid->drag_icon->hotspot_y + source_tab_grid->drag_icon->height / 2;
+
+ insert_placeholder (self, page, center_x, center_y);
+
+ self->indirect_reordering = TRUE;
+
+ resize_drag_icon (source_tab_grid, self->tab_width, self->tab_height);
+ adw_tab_thumbnail_set_inverted (source_tab_grid->drag_icon->tab, self->inverted);
+ adw_tab_thumbnail_set_align (source_tab_grid->drag_icon->tab, self->thumbnail_xalign,
self->thumbnail_yalign);
+
+ self->drag_offset_x = source_tab_grid->drag_icon->hotspot_x;
+ self->drag_offset_y = source_tab_grid->drag_icon->hotspot_y;
+
+ self->reorder_x = (int) round (x - source_tab_grid->drag_icon->hotspot_x);
+ self->reorder_y = (int) round (y - source_tab_grid->drag_icon->hotspot_y);
+
+ start_drag_reodering (self, self->reorder_placeholder, x, y);
+
+ return GDK_ACTION_MOVE;
+ }
+
+ self->reorder_x = (int) round (x - source_tab_grid->drag_icon->hotspot_x);
+ self->reorder_y = (int) round (y - source_tab_grid->drag_icon->hotspot_y);
+
+ update_drag_reodering (self);
+
+ return GDK_ACTION_MOVE;
+}
+
+static void
+tab_drag_leave_cb (AdwTabGrid *self,
+ GtkDropTarget *target)
+{
+ AdwTabGrid *source_tab_grid;
+
+ if (!self->indirect_reordering)
+ return;
+
+ if (self->pinned)
+ return;
+
+ source_tab_grid = get_source_tab_grid (target);
+
+ if (!source_tab_grid)
+ return;
+
+ if (!self->view || !is_view_in_the_same_group (self, source_tab_grid->view))
+ return;
+
+ self->can_remove_placeholder = TRUE;
+
+ end_drag_reodering (self);
+ remove_placeholder (self);
+
+ self->indirect_reordering = FALSE;
+}
+
+static gboolean
+tab_drag_drop_cb (AdwTabGrid *self,
+ const GValue *value,
+ double x,
+ double y,
+ GtkDropTarget *target)
+{
+ AdwTabGrid *source_tab_grid;
+
+ if (self->pinned)
+ return GDK_EVENT_PROPAGATE;
+
+ source_tab_grid = get_source_tab_grid (target);
+
+ if (!source_tab_grid)
+ return GDK_EVENT_PROPAGATE;
+
+ if (!self->view || !is_view_in_the_same_group (self, source_tab_grid->view))
+ return GDK_EVENT_PROPAGATE;
+
+ do_drag_drop (self, source_tab_grid);
+
+ return GDK_EVENT_STOP;
+}
+
+static gboolean
+view_drag_drop_cb (AdwTabGrid *self,
+ const GValue *value,
+ double x,
+ double y,
+ GtkDropTarget *target)
+{
+ AdwTabGrid *source_tab_grid;
+
+ if (self->pinned)
+ return GDK_EVENT_PROPAGATE;
+
+ source_tab_grid = get_source_tab_grid (target);
+
+ if (!source_tab_grid)
+ return GDK_EVENT_PROPAGATE;
+
+ if (!self->view || !is_view_in_the_same_group (self, source_tab_grid->view))
+ return GDK_EVENT_PROPAGATE;
+
+ self->reorder_index = adw_tab_view_get_n_pages (self->view) -
+ adw_tab_view_get_n_pinned_pages (self->view);
+
+ do_drag_drop (self, source_tab_grid);
+
+ return GDK_EVENT_STOP;
+}
+
+/* DND autoscrolling */
+
+static gboolean
+reset_drop_target_tab_cb (AdwTabGrid *self)
+{
+ self->reset_drop_target_tab_id = 0;
+ set_drop_target_tab (self, NULL);
+
+ return G_SOURCE_REMOVE;
+}
+
+static void
+drag_leave_cb (AdwTabGrid *self,
+ GtkDropControllerMotion *controller)
+{
+ GdkDrop *drop = gtk_drop_controller_motion_get_drop (controller);
+ GdkDrag *drag = gdk_drop_get_drag (drop);
+ AdwTabGrid *source = ADW_TAB_GRID (g_object_get_data (G_OBJECT (drag),
+ "adw-tab-overview-drag-origin"));
+
+ if (source)
+ return;
+
+ if (!self->reset_drop_target_tab_id)
+ self->reset_drop_target_tab_id =
+ g_idle_add ((GSourceFunc) reset_drop_target_tab_cb, self);
+
+ end_autoscroll (self);
+}
+
+static void
+drag_enter_motion_cb (AdwTabGrid *self,
+ double x,
+ double y,
+ GtkDropControllerMotion *controller)
+{
+ TabInfo *info;
+ GdkDrop *drop = gtk_drop_controller_motion_get_drop (controller);
+ GdkDrag *drag = gdk_drop_get_drag (drop);
+ AdwTabGrid *source = ADW_TAB_GRID (g_object_get_data (G_OBJECT (drag),
+ "adw-tab-overview-drag-origin"));
+
+ if (source)
+ return;
+
+ info = find_tab_info_at (self, x, y);
+
+ if (!info) {
+ drag_leave_cb (self, controller);
+
+ return;
+ }
+
+ self->drop_target_x = x;
+ self->drop_target_y = y;
+ set_drop_target_tab (self, info);
+
+ start_autoscroll (self);
+}
+
+/* Context menu */
+
+static gboolean
+reset_setup_menu_cb (AdwTabGrid *self)
+{
+ g_signal_emit_by_name (self->view, "setup-menu", NULL);
+
+ return G_SOURCE_REMOVE;
+}
+
+static void
+touch_menu_notify_visible_cb (AdwTabGrid *self)
+{
+ if (!self->context_menu || gtk_widget_get_visible (self->context_menu))
+ return;
+
+ self->hovering = FALSE;
+ get_other_tab_grid (self)->hovering = FALSE;
+ update_hover (self);
+
+ g_idle_add ((GSourceFunc) reset_setup_menu_cb, self);
+}
+
+static void
+do_popup (AdwTabGrid *self,
+ TabInfo *info,
+ double x,
+ double y)
+{
+ GMenuModel *model = adw_tab_view_get_menu_model (self->view);
+ GdkRectangle rect;
+
+ if (!G_IS_MENU_MODEL (model))
+ return;
+
+ g_signal_emit_by_name (self->view, "setup-menu", info->page);
+
+ if (!self->context_menu) {
+ self->context_menu = gtk_popover_menu_new_from_model (model);
+ gtk_widget_set_parent (self->context_menu, GTK_WIDGET (self));
+ gtk_popover_set_position (GTK_POPOVER (self->context_menu), GTK_POS_BOTTOM);
+ gtk_popover_set_has_arrow (GTK_POPOVER (self->context_menu), FALSE);
+
+ if (gtk_widget_get_direction (GTK_WIDGET (self)) == GTK_TEXT_DIR_RTL)
+ gtk_widget_set_halign (self->context_menu, GTK_ALIGN_END);
+ else
+ gtk_widget_set_halign (self->context_menu, GTK_ALIGN_START);
+
+ g_signal_connect_object (self->context_menu, "notify::visible",
+ G_CALLBACK (touch_menu_notify_visible_cb), self,
+ G_CONNECT_AFTER | G_CONNECT_SWAPPED);
+ }
+
+ if (x >= 0 && y >= 0) {
+ rect.x = x;
+ rect.y = y;
+ } else {
+ rect.x = info->pos_x;
+ rect.y = info->pos_y + gtk_widget_get_allocated_height (GTK_WIDGET (info->container));
+
+ if (gtk_widget_get_direction (GTK_WIDGET (self)) == GTK_TEXT_DIR_RTL)
+ rect.x += info->width;
+ }
+
+ rect.width = 0;
+ rect.height = 0;
+
+ gtk_popover_set_pointing_to (GTK_POPOVER (self->context_menu), &rect);
+
+ gtk_popover_popup (GTK_POPOVER (self->context_menu));
+}
+
+static void
+long_pressed_cb (AdwTabGrid *self,
+ double x,
+ double y,
+ GtkGesture *gesture)
+{
+ TabInfo *info = find_tab_info_at (self, x, y);
+
+ gtk_gesture_set_state (self->drag_gesture, GTK_EVENT_SEQUENCE_DENIED);
+
+ if (!info || !info->page) {
+ gtk_gesture_set_state (gesture, GTK_EVENT_SEQUENCE_DENIED);
+ return;
+ }
+
+ gtk_gesture_set_state (gesture, GTK_EVENT_SEQUENCE_CLAIMED);
+ do_popup (self, self->pressed_tab, x, y);
+}
+
+static void
+popup_menu_cb (GtkWidget *widget,
+ const char *action_name,
+ GVariant *parameter)
+{
+ AdwTabGrid *self = ADW_TAB_GRID (widget);
+
+ if (self->selected_tab && self->selected_tab->page)
+ do_popup (self, self->selected_tab, -1, -1);
+}
+
+/* Clicking */
+
+static void
+handle_click (AdwTabGrid *self,
+ TabInfo *info,
+ GtkGesture *gesture)
+{
+ gboolean can_grab_focus;
+
+ can_grab_focus = adw_tab_overview_tabs_have_visible_focus (self->tab_overview);
+
+ if (info == self->selected_tab)
+ can_grab_focus = TRUE;
+ else
+ adw_tab_view_set_selected_page (self->view, info->page);
+
+ if (can_grab_focus)
+ gtk_widget_grab_focus (info->container);
+ else
+ activate_tab (self);
+}
+
+static void
+pressed_cb (AdwTabGrid *self,
+ int n_press,
+ double x,
+ double y,
+ GtkGesture *gesture)
+{
+ TabInfo *info;
+ GdkEvent *event;
+ GdkEventSequence *current;
+ guint button;
+
+ if (is_touchscreen (gesture))
+ return;
+
+ info = find_tab_info_at (self, x, y);
+
+ if (!info || !info->page) {
+ gtk_gesture_set_state (gesture, GTK_EVENT_SEQUENCE_DENIED);
+
+ return;
+ }
+
+ current = gtk_gesture_single_get_current_sequence (GTK_GESTURE_SINGLE (gesture));
+ event = gtk_gesture_get_last_event (gesture, current);
+
+ if (gdk_event_triggers_context_menu (event)) {
+ do_popup (self, info, x, y);
+ gtk_gesture_set_state (gesture, GTK_EVENT_SEQUENCE_CLAIMED);
+ gtk_event_controller_reset (GTK_EVENT_CONTROLLER (gesture));
+
+ return;
+ }
+
+ button = gtk_gesture_single_get_current_button (GTK_GESTURE_SINGLE (gesture));
+
+ if (button == GDK_BUTTON_MIDDLE) {
+ gtk_gesture_set_state (gesture, GTK_EVENT_SEQUENCE_CLAIMED);
+
+ return;
+ }
+
+ if (button != GDK_BUTTON_PRIMARY) {
+ gtk_gesture_set_state (gesture, GTK_EVENT_SEQUENCE_DENIED);
+
+ return;
+ }
+
+ handle_click (self, info, gesture);
+}
+
+static void
+released_cb (AdwTabGrid *self,
+ int n_press,
+ double x,
+ double y,
+ GtkGesture *gesture)
+{
+ TabInfo *info;
+ guint button;
+
+ if (x < 0 || x > gtk_widget_get_width (GTK_WIDGET (self))) {
+ gtk_gesture_set_state (gesture, GTK_EVENT_SEQUENCE_DENIED);
+
+ return;
+ }
+
+ info = find_tab_info_at (self, x, y);
+
+ if (!info || !info->page) {
+ gtk_gesture_set_state (gesture, GTK_EVENT_SEQUENCE_DENIED);
+
+ return;
+ }
+
+ button = gtk_gesture_single_get_current_button (GTK_GESTURE_SINGLE (gesture));
+
+ if (button == GDK_BUTTON_MIDDLE) {
+ adw_tab_view_close_page (self->view, info->page);
+
+ return;
+ }
+
+ if (is_touchscreen (gesture))
+ handle_click (self, info, gesture);
+
+ adw_tab_overview_set_open (self->tab_overview, FALSE);
+}
+
+/* Overrides */
+
+static void
+adw_tab_grid_measure (GtkWidget *widget,
+ GtkOrientation orientation,
+ int for_size,
+ int *minimum,
+ int *natural,
+ int *minimum_baseline,
+ int *natural_baseline)
+{
+ AdwTabGrid *self = ADW_TAB_GRID (widget);
+
+ measure_tab_grid (self, orientation, for_size, minimum, natural, TRUE);
+
+ if (minimum_baseline)
+ *minimum_baseline = -1;
+
+ if (natural_baseline)
+ *natural_baseline = -1;
+}
+
+static void
+adw_tab_grid_size_allocate (GtkWidget *widget,
+ int width,
+ int height,
+ int baseline)
+{
+ AdwTabGrid *self = ADW_TAB_GRID (widget);
+ GList *l;
+ GtkAllocation child_allocation;
+ int indicator_size;
+ GskTransform *transform;
+
+ measure_tab_grid (self, GTK_ORIENTATION_HORIZONTAL, -1,
+ &self->allocated_width, NULL, TRUE);
+ self->allocated_width = MAX (self->allocated_width, width);
+
+ measure_tab_grid (self, GTK_ORIENTATION_VERTICAL, width,
+ &self->allocated_height, NULL, TRUE);
+ self->allocated_height = MAX (self->allocated_height, height);
+
+ calculate_tab_layout (self);
+
+ for (l = self->tabs; l; l = l->next) {
+ TabInfo *info = l->data;
+
+ if (!gtk_widget_should_layout (info->container))
+ continue;
+
+ child_allocation.x = ((info == self->reordered_tab) ? self->reorder_window_x : info->pos_x);
+ child_allocation.y = ((info == self->reordered_tab) ? self->reorder_window_y : info->pos_y);
+ child_allocation.width = MAX (0, info->width);
+ child_allocation.height = MAX (0, info->height);
+
+ gtk_widget_size_allocate (info->container, &child_allocation, baseline);
+ }
+
+ gtk_widget_measure (self->needs_attention_top, GTK_ORIENTATION_VERTICAL, -1,
+ &indicator_size, NULL, NULL, NULL);
+ transform = gsk_transform_translate (NULL, &GRAPHENE_POINT_INIT (0, self->visible_lower));
+ gtk_widget_allocate (self->needs_attention_top, width, indicator_size, baseline, transform);
+
+ gtk_widget_measure (self->needs_attention_bottom, GTK_ORIENTATION_VERTICAL, -1,
+ &indicator_size, NULL, NULL, NULL);
+ transform = gsk_transform_translate (NULL, &GRAPHENE_POINT_INIT (0, self->visible_upper - indicator_size));
+ gtk_widget_allocate (self->needs_attention_bottom, width, indicator_size, baseline, transform);
+
+ update_visible (self);
+}
+
+static GtkSizeRequestMode
+adw_tab_grid_get_request_mode (GtkWidget *widget)
+{
+ return GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH;
+}
+
+static gboolean
+adw_tab_grid_focus (GtkWidget *widget,
+ GtkDirectionType direction)
+{
+ AdwTabGrid *self = ADW_TAB_GRID (widget);
+
+ if (!self->selected_tab)
+ return GDK_EVENT_PROPAGATE;
+
+ return gtk_widget_grab_focus (self->selected_tab->container);
+}
+
+static void
+adw_tab_grid_unrealize (GtkWidget *widget)
+{
+ AdwTabGrid *self = ADW_TAB_GRID (widget);
+
+ g_clear_pointer (&self->context_menu, gtk_widget_unparent);
+
+ GTK_WIDGET_CLASS (adw_tab_grid_parent_class)->unrealize (widget);
+}
+
+static void
+adw_tab_grid_unmap (GtkWidget *widget)
+{
+ AdwTabGrid *self = ADW_TAB_GRID (widget);
+
+ force_end_reordering (self);
+
+ if (self->drag_autoscroll_cb_id) {
+ gtk_widget_remove_tick_callback (widget, self->drag_autoscroll_cb_id);
+ self->drag_autoscroll_cb_id = 0;
+ }
+
+ GTK_WIDGET_CLASS (adw_tab_grid_parent_class)->unmap (widget);
+}
+
+static void
+adw_tab_grid_direction_changed (GtkWidget *widget,
+ GtkTextDirection previous_direction)
+{
+ AdwTabGrid *self = ADW_TAB_GRID (widget);
+
+ if (gtk_widget_get_direction (widget) == previous_direction)
+ return;
+
+ if (self->context_menu) {
+ if (gtk_widget_get_direction (GTK_WIDGET (self)) == GTK_TEXT_DIR_RTL)
+ gtk_widget_set_halign (self->context_menu, GTK_ALIGN_END);
+ else
+ gtk_widget_set_halign (self->context_menu, GTK_ALIGN_START);
+ }
+}
+
+static void
+adw_tab_grid_dispose (GObject *object)
+{
+ AdwTabGrid *self = ADW_TAB_GRID (object);
+
+ g_clear_handle_id (&self->drop_switch_timeout_id, g_source_remove);
+
+ self->drag_gesture = NULL;
+ self->tab_overview = NULL;
+ adw_tab_grid_set_view (self, NULL);
+
+ g_clear_object (&self->filter);
+ self->title_filter = NULL;
+ self->tooltip_filter = NULL;
+ self->keyword_filter = NULL;
+
+ g_clear_object (&self->resize_animation);
+
+ g_clear_pointer (&self->needs_attention_top, gtk_widget_unparent);
+ g_clear_pointer (&self->needs_attention_bottom, gtk_widget_unparent);
+
+ G_OBJECT_CLASS (adw_tab_grid_parent_class)->dispose (object);
+}
+
+static void
+adw_tab_grid_finalize (GObject *object)
+{
+ AdwTabGrid *self = (AdwTabGrid *) object;
+
+ g_clear_pointer (&self->extra_drag_types, g_free);
+
+ G_OBJECT_CLASS (adw_tab_grid_parent_class)->finalize (object);
+}
+
+static void
+adw_tab_grid_get_property (GObject *object,
+ guint prop_id,
+ GValue *value,
+ GParamSpec *pspec)
+{
+ AdwTabGrid *self = ADW_TAB_GRID (object);
+
+ switch (prop_id) {
+ case PROP_PINNED:
+ g_value_set_boolean (value, self->pinned);
+ break;
+
+ case PROP_TAB_OVERVIEW:
+ g_value_set_object (value, self->tab_overview);
+ break;
+
+ case PROP_VIEW:
+ g_value_set_object (value, self->view);
+ break;
+
+ case PROP_RESIZE_FROZEN:
+ g_value_set_boolean (value, self->tab_resize_mode != TAB_RESIZE_NORMAL);
+ break;
+
+ case PROP_EMPTY:
+ g_value_set_boolean (value, adw_tab_grid_get_empty (self));
+ break;
+
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+ }
+}
+
+static void
+adw_tab_grid_set_property (GObject *object,
+ guint prop_id,
+ const GValue *value,
+ GParamSpec *pspec)
+{
+ AdwTabGrid *self = ADW_TAB_GRID (object);
+
+ switch (prop_id) {
+ case PROP_PINNED:
+ self->pinned = g_value_get_boolean (value);
+ break;
+
+ case PROP_TAB_OVERVIEW:
+ self->tab_overview = g_value_get_object (value);
+ break;
+
+ case PROP_VIEW:
+ adw_tab_grid_set_view (self, g_value_get_object (value));
+ break;
+
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+ }
+}
+
+static void
+adw_tab_grid_class_init (AdwTabGridClass *klass)
+{
+ GObjectClass *object_class = G_OBJECT_CLASS (klass);
+ GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
+
+ object_class->dispose = adw_tab_grid_dispose;
+ object_class->finalize = adw_tab_grid_finalize;
+ object_class->get_property = adw_tab_grid_get_property;
+ object_class->set_property = adw_tab_grid_set_property;
+
+ widget_class->measure = adw_tab_grid_measure;
+ widget_class->size_allocate = adw_tab_grid_size_allocate;
+ widget_class->get_request_mode = adw_tab_grid_get_request_mode;
+ widget_class->focus = adw_tab_grid_focus;
+ widget_class->unrealize = adw_tab_grid_unrealize;
+ widget_class->unmap = adw_tab_grid_unmap;
+ widget_class->direction_changed = adw_tab_grid_direction_changed;
+
+ props[PROP_PINNED] =
+ g_param_spec_boolean ("pinned", NULL, NULL,
+ FALSE,
+ G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS);
+
+ props[PROP_TAB_OVERVIEW] =
+ g_param_spec_object ("tab-overview", NULL, NULL,
+ ADW_TYPE_TAB_OVERVIEW,
+ G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS);
+
+ props[PROP_VIEW] =
+ g_param_spec_object ("view", NULL, NULL,
+ ADW_TYPE_TAB_VIEW,
+ G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS | G_PARAM_EXPLICIT_NOTIFY);
+
+ props[PROP_RESIZE_FROZEN] =
+ g_param_spec_boolean ("resize-frozen", NULL, NULL,
+ FALSE,
+ G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
+
+ props[PROP_EMPTY] =
+ g_param_spec_boolean ("empty", NULL, NULL,
+ TRUE,
+ G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
+
+ g_object_class_install_properties (object_class, LAST_PROP, props);
+
+ signals[SIGNAL_SCROLL_RELATIVE] =
+ g_signal_new ("scroll-relative",
+ G_TYPE_FROM_CLASS (klass),
+ G_SIGNAL_RUN_LAST,
+ 0,
+ NULL, NULL, NULL,
+ G_TYPE_NONE,
+ 2,
+ G_TYPE_DOUBLE,
+ G_TYPE_UINT);
+
+ signals[SIGNAL_SCROLL_TO_TAB] =
+ g_signal_new ("scroll-to-tab",
+ G_TYPE_FROM_CLASS (klass),
+ G_SIGNAL_RUN_LAST,
+ 0,
+ NULL, NULL, NULL,
+ G_TYPE_NONE,
+ 2,
+ G_TYPE_DOUBLE,
+ G_TYPE_UINT);
+
+ signals[SIGNAL_EXTRA_DRAG_DROP] =
+ g_signal_new ("extra-drag-drop",
+ G_TYPE_FROM_CLASS (klass),
+ G_SIGNAL_RUN_LAST,
+ 0,
+ g_signal_accumulator_first_wins, NULL, NULL,
+ G_TYPE_BOOLEAN,
+ 2,
+ ADW_TYPE_TAB_PAGE,
+ G_TYPE_VALUE);
+
+ gtk_widget_class_install_action (widget_class, "menu.popup", NULL, popup_menu_cb);
+
+ gtk_widget_class_add_binding_action (widget_class, GDK_KEY_F10, GDK_SHIFT_MASK, "menu.popup", NULL);
+ gtk_widget_class_add_binding_action (widget_class, GDK_KEY_Menu, 0, "menu.popup", NULL);
+
+ add_focus_bindings (widget_class, GDK_KEY_Page_Up, GTK_DIR_TAB_BACKWARD, FALSE);
+ add_focus_bindings (widget_class, GDK_KEY_Page_Down, GTK_DIR_TAB_FORWARD, FALSE);
+ add_focus_bindings (widget_class, GDK_KEY_Home, GTK_DIR_TAB_BACKWARD, TRUE);
+ add_focus_bindings (widget_class, GDK_KEY_End, GTK_DIR_TAB_FORWARD, TRUE);
+
+ add_reorder_bindings (widget_class, GDK_KEY_Left, GTK_DIR_LEFT, FALSE);
+ add_reorder_bindings (widget_class, GDK_KEY_Right, GTK_DIR_RIGHT, FALSE);
+ add_reorder_bindings (widget_class, GDK_KEY_Page_Up, GTK_DIR_TAB_BACKWARD, FALSE);
+ add_reorder_bindings (widget_class, GDK_KEY_Page_Down, GTK_DIR_TAB_FORWARD, FALSE);
+ add_reorder_bindings (widget_class, GDK_KEY_Home, GTK_DIR_TAB_BACKWARD, TRUE);
+ add_reorder_bindings (widget_class, GDK_KEY_End, GTK_DIR_TAB_FORWARD, TRUE);
+
+ gtk_widget_class_set_css_name (widget_class, "tabgrid");
+}
+
+static void
+adw_tab_grid_init (AdwTabGrid *self)
+{
+ GtkEventController *controller;
+ AdwAnimationTarget *target;
+ GtkWidget *widget;
+ GtkExpression *expression;
+
+ self->can_remove_placeholder = TRUE;
+ self->thumbnail_xalign = 0.0;
+ self->thumbnail_yalign = 0.0;
+ self->initial_max_n_columns = -1;
+
+ controller = GTK_EVENT_CONTROLLER (gtk_gesture_click_new ());
+ gtk_gesture_single_set_button (GTK_GESTURE_SINGLE (controller), 0);
+ gtk_gesture_single_set_exclusive (GTK_GESTURE_SINGLE (controller), TRUE);
+ g_signal_connect_swapped (controller, "pressed", G_CALLBACK (pressed_cb), self);
+ g_signal_connect_swapped (controller, "released", G_CALLBACK (released_cb), self);
+ gtk_widget_add_controller (GTK_WIDGET (self), controller);
+
+ controller = GTK_EVENT_CONTROLLER (gtk_gesture_long_press_new ());
+ gtk_gesture_long_press_set_delay_factor (GTK_GESTURE_LONG_PRESS (controller), 2);
+ gtk_gesture_single_set_exclusive (GTK_GESTURE_SINGLE (controller), TRUE);
+ gtk_gesture_single_set_touch_only (GTK_GESTURE_SINGLE (controller), TRUE);
+ g_signal_connect_swapped (controller, "pressed", G_CALLBACK (long_pressed_cb), self);
+ gtk_widget_add_controller (GTK_WIDGET (self), controller);
+
+ controller = GTK_EVENT_CONTROLLER (gtk_gesture_drag_new ());
+ gtk_gesture_single_set_button (GTK_GESTURE_SINGLE (controller), GDK_BUTTON_PRIMARY);
+ gtk_gesture_single_set_exclusive (GTK_GESTURE_SINGLE (controller), TRUE);
+ g_signal_connect_swapped (controller, "drag-begin", G_CALLBACK (reorder_begin_cb), self);
+ g_signal_connect_swapped (controller, "drag-update", G_CALLBACK (reorder_update_cb), self);
+ g_signal_connect_swapped (controller, "drag-end", G_CALLBACK (reorder_end_cb), self);
+ gtk_widget_add_controller (GTK_WIDGET (self), controller);
+ self->drag_gesture = GTK_GESTURE (controller);
+
+ controller = gtk_drop_controller_motion_new ();
+ g_signal_connect_swapped (controller, "enter", G_CALLBACK (drag_enter_motion_cb), self);
+ g_signal_connect_swapped (controller, "motion", G_CALLBACK (drag_enter_motion_cb), self);
+ g_signal_connect_swapped (controller, "leave", G_CALLBACK (drag_leave_cb), self);
+ gtk_widget_add_controller (GTK_WIDGET (self), controller);
+
+ controller = GTK_EVENT_CONTROLLER (gtk_drop_target_new (ADW_TYPE_TAB_PAGE, GDK_ACTION_MOVE));
+ gtk_drop_target_set_preload (GTK_DROP_TARGET (controller), TRUE);
+ g_signal_connect_swapped (controller, "enter", G_CALLBACK (tab_drag_enter_motion_cb), self);
+ g_signal_connect_swapped (controller, "motion", G_CALLBACK (tab_drag_enter_motion_cb), self);
+ g_signal_connect_swapped (controller, "leave", G_CALLBACK (tab_drag_leave_cb), self);
+ g_signal_connect_swapped (controller, "drop", G_CALLBACK (tab_drag_drop_cb), self);
+ gtk_widget_add_controller (GTK_WIDGET (self), controller);
+
+ target = adw_callback_animation_target_new ((AdwAnimationTargetFunc)
+ resize_animation_value_cb,
+ self, NULL);
+ self->resize_animation =
+ adw_timed_animation_new (GTK_WIDGET (self), 0, 1,
+ RESIZE_ANIMATION_DURATION, target);
+
+ g_signal_connect_swapped (self->resize_animation, "done",
+ G_CALLBACK (resize_animation_done_cb), self);
+
+ self->needs_attention_top = gtk_revealer_new ();
+ gtk_revealer_set_transition_type (GTK_REVEALER (self->needs_attention_top),
+ GTK_REVEALER_TRANSITION_TYPE_CROSSFADE);
+ gtk_widget_set_can_target (self->needs_attention_top, FALSE);
+ gtk_widget_set_can_focus (self->needs_attention_top, FALSE);
+ gtk_widget_set_parent (self->needs_attention_top, GTK_WIDGET (self));
+
+ widget = adw_gizmo_new ("indicator", NULL, NULL, NULL, NULL, NULL, NULL);
+ gtk_widget_add_css_class (widget, "top");
+ gtk_revealer_set_child (GTK_REVEALER (self->needs_attention_top), widget);
+
+ self->needs_attention_bottom = gtk_revealer_new ();
+ gtk_revealer_set_transition_type (GTK_REVEALER (self->needs_attention_bottom),
+ GTK_REVEALER_TRANSITION_TYPE_CROSSFADE);
+ gtk_widget_set_can_target (self->needs_attention_bottom, FALSE);
+ gtk_widget_set_can_focus (self->needs_attention_bottom, FALSE);
+ gtk_widget_set_parent (self->needs_attention_bottom, GTK_WIDGET (self));
+
+ widget = adw_gizmo_new ("indicator", NULL, NULL, NULL, NULL, NULL, NULL);
+ gtk_widget_add_css_class (widget, "bottom");
+ gtk_revealer_set_child (GTK_REVEALER (self->needs_attention_bottom), widget);
+
+ expression = gtk_property_expression_new (ADW_TYPE_TAB_PAGE, NULL, "title");
+ self->title_filter = gtk_string_filter_new (expression);
+
+ expression = gtk_property_expression_new (ADW_TYPE_TAB_PAGE, NULL, "tooltip");
+ self->tooltip_filter = gtk_string_filter_new (expression);
+
+ expression = gtk_property_expression_new (ADW_TYPE_TAB_PAGE, NULL, "keyword");
+ self->keyword_filter = gtk_string_filter_new (expression);
+
+ self->filter = GTK_FILTER (gtk_any_filter_new ());
+ gtk_multi_filter_append (GTK_MULTI_FILTER (self->filter),
+ GTK_FILTER (self->title_filter));
+ gtk_multi_filter_append (GTK_MULTI_FILTER (self->filter),
+ GTK_FILTER (self->tooltip_filter));
+ gtk_multi_filter_append (GTK_MULTI_FILTER (self->filter),
+ GTK_FILTER (self->keyword_filter));
+
+ g_signal_connect_swapped (self->filter, "changed",
+ G_CALLBACK (search_changed_cb), self);
+}
+
+void
+adw_tab_grid_set_view (AdwTabGrid *self,
+ AdwTabView *view)
+{
+ g_return_if_fail (ADW_IS_TAB_GRID (self));
+ g_return_if_fail (view == NULL || ADW_IS_TAB_VIEW (view));
+
+ if (view == self->view)
+ return;
+
+ if (self->view) {
+ force_end_reordering (self);
+ g_signal_handlers_disconnect_by_func (self->view, page_attached_cb, self);
+ g_signal_handlers_disconnect_by_func (self->view, page_detached_cb, self);
+ g_signal_handlers_disconnect_by_func (self->view, page_reordered_cb, self);
+
+ if (!self->pinned) {
+ gtk_widget_remove_controller (GTK_WIDGET (self->view), self->view_drop_target);
+ self->view_drop_target = NULL;
+ }
+
+ g_clear_list (&self->tabs, (GDestroyNotify) remove_and_free_tab_info);
+ self->n_tabs = 0;
+ }
+
+ self->view = view;
+
+ if (self->view) {
+ int i, n_pages = adw_tab_view_get_n_pages (self->view);
+
+ for (i = n_pages - 1; i >= 0; i--)
+ page_attached_cb (self, adw_tab_view_get_nth_page (self->view, i), 0);
+
+ g_signal_connect_object (self->view, "page-attached", G_CALLBACK (page_attached_cb), self,
G_CONNECT_SWAPPED);
+ g_signal_connect_object (self->view, "page-detached", G_CALLBACK (page_detached_cb), self,
G_CONNECT_SWAPPED);
+ g_signal_connect_object (self->view, "page-reordered", G_CALLBACK (page_reordered_cb), self,
G_CONNECT_SWAPPED);
+
+ if (!self->pinned) {
+ self->view_drop_target = GTK_EVENT_CONTROLLER (gtk_drop_target_new (ADW_TYPE_TAB_PAGE,
GDK_ACTION_MOVE));
+
+ g_signal_connect_object (self->view_drop_target, "drop", G_CALLBACK (view_drag_drop_cb), self,
G_CONNECT_SWAPPED);
+
+ gtk_widget_add_controller (GTK_WIDGET (self->view), self->view_drop_target);
+ }
+ }
+
+ gtk_widget_queue_allocate (GTK_WIDGET (self));
+
+ g_object_notify_by_pspec (G_OBJECT (self), props[PROP_VIEW]);
+}
+
+void
+adw_tab_grid_attach_page (AdwTabGrid *self,
+ AdwTabPage *page,
+ int position)
+{
+ g_return_if_fail (ADW_IS_TAB_GRID (self));
+ g_return_if_fail (ADW_IS_TAB_PAGE (page));
+
+ page_attached_cb (self, page, position);
+}
+
+void
+adw_tab_grid_detach_page (AdwTabGrid *self,
+ AdwTabPage *page)
+{
+ g_return_if_fail (ADW_IS_TAB_GRID (self));
+ g_return_if_fail (ADW_IS_TAB_PAGE (page));
+
+ page_detached_cb (self, page);
+}
+
+void
+adw_tab_grid_select_page (AdwTabGrid *self,
+ AdwTabPage *page)
+{
+ g_return_if_fail (ADW_IS_TAB_GRID (self));
+ g_return_if_fail (page == NULL || ADW_IS_TAB_PAGE (page));
+
+ select_page (self, page);
+}
+
+void
+adw_tab_grid_try_focus_selected_tab (AdwTabGrid *self)
+{
+ g_return_if_fail (ADW_IS_TAB_GRID (self));
+
+ if (self->selected_tab)
+ gtk_widget_grab_focus (self->selected_tab->container);
+}
+
+gboolean
+adw_tab_grid_is_page_focused (AdwTabGrid *self,
+ AdwTabPage *page)
+{
+ TabInfo *info;
+
+ g_return_val_if_fail (ADW_IS_TAB_GRID (self), FALSE);
+ g_return_val_if_fail (ADW_IS_TAB_PAGE (page), FALSE);
+
+ info = find_info_for_page (self, page);
+
+ return info && gtk_widget_is_focus (info->container);
+}
+
+void
+adw_tab_grid_setup_extra_drop_target (AdwTabGrid *self,
+ GdkDragAction actions,
+ GType *types,
+ gsize n_types)
+{
+ GList *l;
+
+ g_return_if_fail (ADW_IS_TAB_GRID (self));
+ g_return_if_fail (n_types == 0 || types != NULL);
+
+ g_clear_pointer (&self->extra_drag_types, g_free);
+
+ self->extra_drag_actions = actions;
+#if GLIB_CHECK_VERSION(2, 67, 3)
+ self->extra_drag_types = g_memdup2 (types, sizeof (GType) * n_types);
+#else
+ self->extra_drag_types = g_memdup (types, sizeof (GType) * n_types);
+#endif
+ self->extra_drag_n_types = n_types;
+
+ for (l = self->tabs; l; l = l->next) {
+ TabInfo *info = l->data;
+
+ adw_tab_thumbnail_setup_extra_drop_target (info->tab,
+ self->extra_drag_actions,
+ self->extra_drag_types,
+ self->extra_drag_n_types);
+ }
+}
+
+gboolean
+adw_tab_grid_get_inverted (AdwTabGrid *self)
+{
+ g_return_val_if_fail (ADW_IS_TAB_GRID (self), FALSE);
+
+ return self->inverted;
+}
+
+void
+adw_tab_grid_set_inverted (AdwTabGrid *self,
+ gboolean inverted)
+{
+ GList *l;
+
+ g_return_if_fail (ADW_IS_TAB_GRID (self));
+
+ inverted = !!inverted;
+
+ if (inverted == self->inverted)
+ return;
+
+ self->inverted = inverted;
+
+ for (l = self->tabs; l; l = l->next) {
+ TabInfo *info = l->data;
+
+ adw_tab_thumbnail_set_inverted (info->tab, inverted);
+ }
+}
+
+void
+adw_tab_grid_set_thumbnail_align (AdwTabGrid *self,
+ float xalign,
+ float yalign)
+{
+ GList *l;
+
+ g_return_if_fail (ADW_IS_TAB_GRID (self));
+
+ self->thumbnail_xalign = xalign;
+ self->thumbnail_yalign = yalign;
+
+ for (l = self->tabs; l; l = l->next) {
+ TabInfo *info = l->data;
+
+ adw_tab_thumbnail_set_align (info->tab, xalign, yalign);
+ }
+}
+
+AdwTabThumbnail *
+adw_tab_grid_get_transition_thumbnail (AdwTabGrid *self)
+{
+ g_return_val_if_fail (ADW_IS_TAB_GRID (self), NULL);
+
+ if (self->selected_tab)
+ return self->selected_tab->tab;
+
+ return NULL;
+}
+
+void
+adw_tab_grid_set_visible_range (AdwTabGrid *self,
+ double lower,
+ double upper)
+{
+ g_return_if_fail (ADW_IS_TAB_GRID (self));
+
+ self->visible_lower = lower;
+ self->visible_upper = upper;
+
+ gtk_widget_queue_allocate (GTK_WIDGET (self));
+ update_visible (self);
+}
+
+void
+adw_tab_grid_adjustment_shifted (AdwTabGrid *self,
+ double delta)
+{
+ if (!self->drop_target_tab)
+ return;
+
+ self->drop_target_y += delta;
+
+ set_drop_target_tab (self, find_tab_info_at (self,
+ self->drop_target_x,
+ self->drop_target_y));
+}
+
+double
+adw_tab_grid_get_scrolled_tab_y (AdwTabGrid *self)
+{
+ if (!self->scroll_animation_tab)
+ return NAN;
+
+ return get_tab_y (self, self->scroll_animation_tab, TRUE);
+}
+
+void
+adw_tab_grid_reset_scrolled_tab (AdwTabGrid *self)
+{
+ self->scroll_animation_tab = NULL;
+}
+
+void
+adw_tab_grid_scroll_to_page (AdwTabGrid *self,
+ AdwTabPage *page,
+ gboolean animate)
+{
+ TabInfo *info = find_info_for_page (self, page);
+
+ scroll_to_tab (self, info, animate ? OPEN_ANIMATION_DURATION : 0);
+}
+
+void
+adw_tab_grid_set_hovering (AdwTabGrid *self,
+ gboolean hovering)
+{
+ self->hovering = hovering;
+ update_hover (self);
+}
+
+void
+adw_tab_grid_set_search_terms (AdwTabGrid *self,
+ const char *terms)
+{
+ self->searching = terms && *terms;
+ gtk_string_filter_set_search (self->title_filter, terms);
+ gtk_string_filter_set_search (self->tooltip_filter, terms);
+ gtk_string_filter_set_search (self->keyword_filter, terms);
+
+ if (!self->searching)
+ set_empty (self, self->n_tabs > 0);
+}
+
+gboolean
+adw_tab_grid_get_empty (AdwTabGrid *self)
+{
+ return self->empty;
+}
diff --git a/src/adw-tab-overview-private.h b/src/adw-tab-overview-private.h
new file mode 100644
index 00000000..d701dad3
--- /dev/null
+++ b/src/adw-tab-overview-private.h
@@ -0,0 +1,26 @@
+/*
+ * Copyright (C) 2022 Purism SPC
+ *
+ * SPDX-License-Identifier: LGPL-2.1-or-later
+ *
+ * Author: Alexander Mikhaylenko <alexander mikhaylenko puri sm>
+ */
+
+#pragma once
+
+#if !defined(_ADWAITA_INSIDE) && !defined(ADWAITA_COMPILATION)
+#error "Only <adwaita.h> can be included directly."
+#endif
+
+#include "adw-tab-overview.h"
+
+#include "adw-tab-grid-private.h"
+
+G_BEGIN_DECLS
+
+gboolean adw_tab_overview_tabs_have_visible_focus (AdwTabOverview *self);
+
+AdwTabGrid *adw_tab_overview_get_tab_grid (AdwTabOverview *self);
+AdwTabGrid *adw_tab_overview_get_pinned_tab_grid (AdwTabOverview *self);
+
+G_END_DECLS
diff --git a/src/adw-tab-overview.c b/src/adw-tab-overview.c
new file mode 100644
index 00000000..ed4d76c0
--- /dev/null
+++ b/src/adw-tab-overview.c
@@ -0,0 +1,2320 @@
+/*
+ * Copyright (C) 2021 Purism SPC
+ *
+ * SPDX-License-Identifier: LGPL-2.1+
+ *
+ * Author: Alexander Mikhaylenko <alexander mikhaylenko puri sm>
+ */
+
+#include "config.h"
+#include <glib/gi18n-lib.h>
+
+#include "adw-tab-overview-private.h"
+
+#include "adw-animation-util.h"
+#include "adw-bin.h"
+#include "adw-macros-private.h"
+#include "adw-style-manager.h"
+#include "adw-tab-grid-private.h"
+#include "adw-tab-thumbnail-private.h"
+#include "adw-timed-animation.h"
+#include "adw-widget-utils-private.h"
+#include "adw-window-title.h"
+
+#define SCROLL_ANIMATION_DURATION 200
+#define TRANSITION_DURATION 400
+#define THUMBNAIL_BORDER_RADIUS 12
+#define WINDOW_BORDER_RADIUS 12
+
+/**
+ * AdwTabOverview:
+ *
+ * TODO
+ *
+ * Since: 1.3
+ */
+
+struct _AdwTabOverview
+{
+ GtkWidget parent_instance;
+
+ GtkWidget *overview;
+ GtkWidget *stack;
+ GtkWidget *scrollable;
+ GtkWidget *child_bin;
+ GtkWidget *header_bar;
+ GtkWidget *title;
+ GtkWidget *new_tab_button;
+ GtkWidget *search_button;
+ GtkWidget *search_bar;
+ GtkWidget *search_entry;
+ GtkWidget *extra_menu_button;
+ AdwTabView *view;
+
+ AdwTabGrid *grid;
+ AdwTabGrid *pinned_grid;
+
+ float thumbnail_xalign;
+ float thumbnail_yalign;
+ gboolean enable_search;
+ gboolean enable_new_tab;
+ gboolean search_active;
+
+ gboolean is_open;
+ AdwAnimation *open_animation;
+ double progress;
+ gboolean animating;
+
+ AdwTabThumbnail *transition_thumbnail;
+ GtkWidget *transition_picture;
+ gboolean transition_pinned;
+};
+
+static void adw_tab_overview_buildable_init (GtkBuildableIface *iface);
+
+G_DEFINE_FINAL_TYPE_WITH_CODE (AdwTabOverview, adw_tab_overview, GTK_TYPE_WIDGET,
+ G_IMPLEMENT_INTERFACE (GTK_TYPE_BUILDABLE, adw_tab_overview_buildable_init))
+
+static GtkBuildableIface *parent_buildable_iface;
+
+enum {
+ PROP_0,
+ PROP_VIEW,
+ PROP_CHILD,
+ PROP_OPEN,
+ PROP_INVERTED,
+ PROP_THUMBNAIL_XALIGN,
+ PROP_THUMBNAIL_YALIGN,
+ PROP_ENABLE_SEARCH,
+ PROP_SEARCH_ACTIVE,
+ PROP_ENABLE_NEW_TAB,
+ PROP_NEW_TAB_ACTION_NAME,
+ PROP_NEW_TAB_ACTION_TARGET,
+ PROP_EXTRA_MENU,
+ LAST_PROP
+};
+
+static GParamSpec *props[LAST_PROP];
+
+enum {
+ SIGNAL_NEW_TAB_CLICKED,
+ SIGNAL_EXTRA_DRAG_DROP,
+ SIGNAL_LAST_SIGNAL,
+};
+
+static guint signals[SIGNAL_LAST_SIGNAL];
+
+#define ADW_TYPE_TAB_OVERVIEW_SCROLLABLE (adw_tab_overview_scrollable_get_type ())
+
+G_DECLARE_FINAL_TYPE (AdwTabOverviewScrollable, adw_tab_overview_scrollable, ADW, TAB_OVERVIEW_SCROLLABLE,
GtkWidget)
+
+struct _AdwTabOverviewScrollable
+{
+ GtkWidget parent_instance;
+
+ GtkWidget *grid;
+ GtkWidget *pinned_grid;
+ GtkWidget *overview;
+ GtkWidget *new_button;
+ GtkWidget *search_entry;
+
+ GtkAdjustment *hadjustment;
+ GtkAdjustment *vadjustment;
+ GtkScrollablePolicy hscroll_policy;
+ GtkScrollablePolicy vscroll_policy;
+
+ AdwAnimation *scroll_animation;
+ AdwTabGrid *scroll_animation_grid;
+ gboolean scroll_animation_done;
+ double scroll_animation_from;
+ double scroll_animation_offset;
+ gboolean block_scrolling;
+ double adjustment_prev_value;
+
+ int grid_pos;
+ int pinned_grid_pos;
+
+ gboolean hovering;
+};
+
+G_DEFINE_FINAL_TYPE_WITH_CODE (AdwTabOverviewScrollable, adw_tab_overview_scrollable, GTK_TYPE_WIDGET,
+ G_IMPLEMENT_INTERFACE (GTK_TYPE_SCROLLABLE, NULL))
+
+enum {
+ SCROLLABLE_PROP_0,
+ SCROLLABLE_PROP_GRID,
+ SCROLLABLE_PROP_PINNED_GRID,
+ SCROLLABLE_PROP_OVERVIEW,
+ SCROLLABLE_PROP_NEW_BUTTON,
+ /* GtkScrollable */
+ SCROLLABLE_PROP_HADJUSTMENT,
+ SCROLLABLE_PROP_VADJUSTMENT,
+ SCROLLABLE_PROP_HSCROLL_POLICY,
+ SCROLLABLE_PROP_VSCROLL_POLICY,
+ LAST_SCROLLABLE_PROP = SCROLLABLE_PROP_HADJUSTMENT
+};
+
+static GParamSpec *scrollable_props[LAST_SCROLLABLE_PROP];
+
+static void
+vadjustment_value_changed_cb (AdwTabOverviewScrollable *self)
+{
+ double value = gtk_adjustment_get_value (self->vadjustment);
+
+ adw_tab_grid_adjustment_shifted (ADW_TAB_GRID (self->grid),
+ value - self->adjustment_prev_value);
+
+ self->adjustment_prev_value = value;
+
+ if (self->block_scrolling)
+ return;
+
+ adw_animation_pause (self->scroll_animation);
+
+ gtk_widget_queue_allocate (GTK_WIDGET (self));
+}
+
+static void
+vadjustment_weak_notify (gpointer data,
+ GObject *object)
+{
+ AdwTabOverviewScrollable *self = data;
+
+ self->vadjustment = NULL;
+}
+
+static void
+set_vadjustment (AdwTabOverviewScrollable *self,
+ GtkAdjustment *adjustment)
+{
+ if (self->vadjustment) {
+ g_signal_handlers_disconnect_by_func (self->vadjustment, vadjustment_value_changed_cb, self);
+
+ g_object_weak_unref (G_OBJECT (self->vadjustment), vadjustment_weak_notify, self);
+ }
+
+ self->vadjustment = adjustment;
+
+ if (self->vadjustment) {
+ g_object_weak_ref (G_OBJECT (self->vadjustment), vadjustment_weak_notify, self);
+
+ g_signal_connect_swapped (self->vadjustment, "value-changed",
+ G_CALLBACK (vadjustment_value_changed_cb), self);
+ }
+}
+
+static inline int
+get_grid_offset (AdwTabOverviewScrollable *self,
+ AdwTabGrid *grid)
+{
+ if (grid == ADW_TAB_GRID (self->grid))
+ return self->grid_pos;
+
+ if (grid == ADW_TAB_GRID (self->pinned_grid))
+ return self->pinned_grid_pos;
+
+ g_assert_not_reached ();
+}
+
+static double
+get_scroll_animation_value (AdwTabOverviewScrollable *self)
+{
+ double to, value;
+ double scrolled_y;
+
+ g_assert (self->scroll_animation);
+
+ if (adw_animation_get_state (self->scroll_animation) != ADW_ANIMATION_PLAYING &&
+ adw_animation_get_state (self->scroll_animation) != ADW_ANIMATION_FINISHED)
+ return gtk_adjustment_get_value (self->vadjustment);
+
+ to = self->scroll_animation_offset;
+
+ scrolled_y = adw_tab_grid_get_scrolled_tab_y (self->scroll_animation_grid);
+ if (!isnan (scrolled_y)) {
+ double page_size = gtk_adjustment_get_page_size (self->vadjustment);
+ double upper = gtk_adjustment_get_upper (self->vadjustment);
+
+ to += scrolled_y + get_grid_offset (self, self->scroll_animation_grid);
+ to = CLAMP (to, 0, upper - page_size);
+ }
+
+ value = adw_animation_get_value (self->scroll_animation);
+
+ return round (adw_lerp (self->scroll_animation_from, to, value));
+}
+
+static void
+scroll_animation_cb (double value,
+ AdwTabOverviewScrollable *self)
+{
+ gtk_widget_queue_resize (GTK_WIDGET (self));
+}
+
+static void
+scroll_animation_done_cb (AdwTabOverviewScrollable *self)
+{
+ self->scroll_animation_done = TRUE;
+ gtk_widget_queue_resize (GTK_WIDGET (self));
+}
+
+static void
+stop_kinetic_scrolling (AdwTabOverviewScrollable *self)
+{
+ GtkWidget *window = gtk_widget_get_ancestor (GTK_WIDGET (self), GTK_TYPE_SCROLLED_WINDOW);
+
+ g_assert (window);
+
+ /* HACK: Need to cancel kinetic scrolling. If only the built-in adjustment
+ * animation API was public, we wouldn't have to do any of this... */
+ gtk_scrolled_window_set_kinetic_scrolling (GTK_SCROLLED_WINDOW (window), FALSE);
+ gtk_scrolled_window_set_kinetic_scrolling (GTK_SCROLLED_WINDOW (window), TRUE);
+}
+
+static void
+animate_scroll (AdwTabOverviewScrollable *self,
+ AdwTabGrid *grid,
+ double offset,
+ guint duration)
+{
+ stop_kinetic_scrolling (self);
+
+ if (duration == 0) {
+ gtk_adjustment_set_value (self->vadjustment, offset);
+
+ return;
+ }
+
+ self->scroll_animation_done = FALSE;
+ self->scroll_animation_grid = grid;
+ self->scroll_animation_from = gtk_adjustment_get_value (self->vadjustment);
+ self->scroll_animation_offset = offset;
+
+ adw_timed_animation_set_duration (ADW_TIMED_ANIMATION (self->scroll_animation),
+ duration);
+ adw_animation_play (self->scroll_animation);
+}
+
+static void
+scroll_relative_cb (AdwTabOverviewScrollable *self,
+ double delta,
+ guint duration,
+ AdwTabGrid *grid)
+{
+ double current_value = gtk_adjustment_get_value (self->vadjustment);
+
+ if (adw_animation_get_state (self->scroll_animation) == ADW_ANIMATION_PLAYING) {
+ double tab_y = adw_tab_grid_get_scrolled_tab_y (self->scroll_animation_grid);
+
+ current_value = self->scroll_animation_offset;
+
+ if (!isnan (tab_y))
+ current_value += tab_y + get_grid_offset (self, self->scroll_animation_grid);
+ }
+
+ animate_scroll (self, grid, current_value + delta, duration);
+}
+
+static void
+scroll_to_tab_cb (AdwTabOverviewScrollable *self,
+ double offset,
+ guint duration,
+ AdwTabGrid *grid)
+{
+ animate_scroll (self, grid, offset, duration);
+}
+
+static void
+set_grid (AdwTabOverviewScrollable *self,
+ GtkWidget **field,
+ AdwTabGrid *grid)
+{
+ if (*field) {
+ g_signal_handlers_disconnect_by_func (*field, scroll_relative_cb, self);
+ g_signal_handlers_disconnect_by_func (*field, scroll_to_tab_cb, self);
+
+ gtk_widget_unparent (*field);
+ }
+
+ *field = GTK_WIDGET (grid);
+
+ if (*field) {
+ gtk_widget_set_parent (*field, GTK_WIDGET (self));
+
+ g_signal_connect_swapped (*field, "scroll-relative",
+ G_CALLBACK (scroll_relative_cb), self);
+ g_signal_connect_swapped (*field, "scroll-to-tab",
+ G_CALLBACK (scroll_to_tab_cb), self);
+ }
+}
+
+static void
+set_hovering (AdwTabOverviewScrollable *self,
+ gboolean hovering)
+{
+ self->hovering = hovering;
+
+ adw_tab_grid_set_hovering (ADW_TAB_GRID (self->grid), hovering);
+ adw_tab_grid_set_hovering (ADW_TAB_GRID (self->pinned_grid), hovering);
+}
+
+static void
+motion_cb (AdwTabOverviewScrollable *self,
+ double x,
+ double y,
+ GtkEventController *controller)
+{
+ GdkDevice *device = gtk_event_controller_get_current_event_device (controller);
+ GdkInputSource input_source = gdk_device_get_source (device);
+
+ if (input_source == GDK_SOURCE_TOUCHSCREEN)
+ return;
+
+ if (self->hovering)
+ return;
+
+ set_hovering (self, TRUE);
+}
+
+static void
+leave_cb (AdwTabOverviewScrollable *self,
+ GtkEventController *controller)
+{
+ set_hovering (self, FALSE);
+}
+
+static void
+adw_tab_overview_scrollable_unmap (GtkWidget *widget)
+{
+ AdwTabOverviewScrollable *self = ADW_TAB_OVERVIEW_SCROLLABLE (widget);
+
+ set_hovering (self, FALSE);
+
+ GTK_WIDGET_CLASS (adw_tab_overview_scrollable_parent_class)->unmap (widget);
+}
+
+static void
+adw_tab_overview_scrollable_measure (GtkWidget *widget,
+ GtkOrientation orientation,
+ int for_size,
+ int *minimum,
+ int *natural,
+ int *minimum_baseline,
+ int *natural_baseline)
+{
+ int min = 0, nat = 0;
+ GtkWidget *child;
+
+ for (child = gtk_widget_get_first_child (widget);
+ child;
+ child = gtk_widget_get_next_sibling (child)) {
+ int child_min, child_nat;
+
+ gtk_widget_measure (child, orientation, for_size,
+ &child_min, &child_nat, NULL, NULL);
+
+ if (orientation == GTK_ORIENTATION_HORIZONTAL) {
+ min = MAX (min, child_min);
+ nat = MAX (nat, child_nat);
+ } else {
+ min += child_min;
+ nat += child_nat;
+ }
+ }
+
+ if (minimum_baseline)
+ *minimum_baseline = -1;
+ if (natural_baseline)
+ *natural_baseline = -1;
+}
+
+static void
+adw_tab_overview_scrollable_size_allocate (GtkWidget *widget,
+ int width,
+ int height,
+ int baseline)
+{
+ AdwTabOverviewScrollable *self = ADW_TAB_OVERVIEW_SCROLLABLE (widget);
+ double value;
+ int grid_height, pinned_height, new_button_height;
+
+ gtk_widget_measure (self->grid, GTK_ORIENTATION_VERTICAL, width,
+ &grid_height, NULL, NULL, NULL);
+ gtk_widget_measure (self->pinned_grid, GTK_ORIENTATION_VERTICAL, width,
+ &pinned_height, NULL, NULL, NULL);
+
+ if (gtk_widget_should_layout (self->new_button))
+ gtk_widget_measure (self->new_button, GTK_ORIENTATION_VERTICAL, width,
+ &new_button_height, NULL, NULL, NULL);
+ else
+ new_button_height = 0;
+
+ self->pinned_grid_pos = 0;
+ self->grid_pos = self->pinned_grid_pos + pinned_height;
+
+ grid_height = MAX (grid_height, height - new_button_height - self->grid_pos);
+
+ value = get_scroll_animation_value (self);
+
+ self->block_scrolling = TRUE;
+ gtk_adjustment_configure (self->vadjustment,
+ value,
+ 0,
+ self->grid_pos + grid_height + new_button_height,
+ height * 0.1,
+ height * 0.9,
+ height);
+ self->block_scrolling = FALSE;
+
+ /* The value may have changed during gtk_adjustment_configure() */
+ value = gtk_adjustment_get_value (self->vadjustment);
+
+ if (value <= 0)
+ gtk_widget_add_css_class (self->overview, "scrolled-to-top");
+ else
+ gtk_widget_remove_css_class (self->overview, "scrolled-to-top");
+
+ adw_tab_grid_set_visible_range (ADW_TAB_GRID (self->pinned_grid),
+ CLAMP (value - self->pinned_grid_pos, 0, pinned_height),
+ CLAMP (value - self->pinned_grid_pos + height - new_button_height, 0,
pinned_height));
+ adw_tab_grid_set_visible_range (ADW_TAB_GRID (self->grid),
+ CLAMP (value - self->grid_pos, 0, grid_height),
+ CLAMP (value - self->grid_pos + height - new_button_height, 0,
grid_height));
+
+ if (self->scroll_animation_done) {
+ g_clear_pointer (&self->scroll_animation_grid, adw_tab_grid_reset_scrolled_tab);
+ self->scroll_animation_done = FALSE;
+ adw_animation_reset (self->scroll_animation);
+ }
+
+ gtk_widget_allocate (self->pinned_grid, width, pinned_height, baseline,
+ gsk_transform_translate (NULL, &GRAPHENE_POINT_INIT (0, self->pinned_grid_pos -
value)));
+ gtk_widget_allocate (self->grid, width, grid_height, baseline,
+ gsk_transform_translate (NULL, &GRAPHENE_POINT_INIT (0, self->grid_pos - value)));
+}
+
+static void
+adw_tab_overview_scrollable_dispose (GObject *object)
+{
+ AdwTabOverviewScrollable *self = ADW_TAB_OVERVIEW_SCROLLABLE (object);
+
+ g_clear_object (&self->scroll_animation);
+
+ set_vadjustment (self, NULL);
+
+ g_clear_pointer (&self->grid, gtk_widget_unparent);
+ g_clear_pointer (&self->pinned_grid, gtk_widget_unparent);
+
+ self->overview = NULL;
+ self->new_button = NULL;
+
+ G_OBJECT_CLASS (adw_tab_overview_scrollable_parent_class)->dispose (object);
+}
+
+static void
+adw_tab_overview_scrollable_get_property (GObject *object,
+ guint prop_id,
+ GValue *value,
+ GParamSpec *pspec)
+{
+ AdwTabOverviewScrollable *self = ADW_TAB_OVERVIEW_SCROLLABLE (object);
+
+ switch (prop_id) {
+ case SCROLLABLE_PROP_GRID:
+ g_value_set_object (value, self->grid);
+ break;
+ case SCROLLABLE_PROP_PINNED_GRID:
+ g_value_set_object (value, self->pinned_grid);
+ break;
+ case SCROLLABLE_PROP_OVERVIEW:
+ g_value_set_object (value, self->overview);
+ break;
+ case SCROLLABLE_PROP_NEW_BUTTON:
+ g_value_set_object (value, self->new_button);
+ break;
+ case SCROLLABLE_PROP_HADJUSTMENT:
+ g_value_set_object (value, self->hadjustment);
+ break;
+ case SCROLLABLE_PROP_VADJUSTMENT:
+ g_value_set_object (value, self->vadjustment);
+ break;
+ case SCROLLABLE_PROP_HSCROLL_POLICY:
+ g_value_set_enum (value, self->hscroll_policy);
+ break;
+ case SCROLLABLE_PROP_VSCROLL_POLICY:
+ g_value_set_enum (value, self->vscroll_policy);
+ break;
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+ }
+}
+
+static void
+adw_tab_overview_scrollable_set_property (GObject *object,
+ guint prop_id,
+ const GValue *value,
+ GParamSpec *pspec)
+{
+ AdwTabOverviewScrollable *self = ADW_TAB_OVERVIEW_SCROLLABLE (object);
+
+ switch (prop_id) {
+ case SCROLLABLE_PROP_GRID:
+ set_grid (self, &self->grid, g_value_get_object (value));
+ break;
+ case SCROLLABLE_PROP_PINNED_GRID:
+ set_grid (self, &self->pinned_grid, g_value_get_object (value));
+ break;
+ case SCROLLABLE_PROP_OVERVIEW:
+ self->overview = g_value_get_object (value);
+ break;
+ case SCROLLABLE_PROP_NEW_BUTTON:
+ self->new_button = g_value_get_object (value);
+ break;
+ case SCROLLABLE_PROP_HADJUSTMENT:
+ self->hadjustment = g_value_get_object (value);
+ break;
+ case SCROLLABLE_PROP_VADJUSTMENT:
+ set_vadjustment (self, g_value_get_object (value));
+ break;
+ case SCROLLABLE_PROP_HSCROLL_POLICY:
+ self->hscroll_policy = g_value_get_enum (value);
+ break;
+ case SCROLLABLE_PROP_VSCROLL_POLICY:
+ self->vscroll_policy = g_value_get_enum (value);
+ break;
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+ }
+}
+
+static void
+adw_tab_overview_scrollable_class_init (AdwTabOverviewScrollableClass *klass)
+{
+ GObjectClass *object_class = G_OBJECT_CLASS (klass);
+ GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
+
+ object_class->dispose = adw_tab_overview_scrollable_dispose;
+ object_class->get_property = adw_tab_overview_scrollable_get_property;
+ object_class->set_property = adw_tab_overview_scrollable_set_property;
+
+ widget_class->unmap = adw_tab_overview_scrollable_unmap;
+ widget_class->measure = adw_tab_overview_scrollable_measure;
+ widget_class->size_allocate = adw_tab_overview_scrollable_size_allocate;
+
+ scrollable_props[SCROLLABLE_PROP_GRID] =
+ g_param_spec_object ("grid", NULL, NULL,
+ ADW_TYPE_TAB_GRID,
+ G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+
+ scrollable_props[SCROLLABLE_PROP_PINNED_GRID] =
+ g_param_spec_object ("pinned-grid", NULL, NULL,
+ ADW_TYPE_TAB_GRID,
+ G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+
+ scrollable_props[SCROLLABLE_PROP_OVERVIEW] =
+ g_param_spec_object ("overview", NULL, NULL,
+ GTK_TYPE_WIDGET,
+ G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+
+ scrollable_props[SCROLLABLE_PROP_NEW_BUTTON] =
+ g_param_spec_object ("new-button", NULL, NULL,
+ GTK_TYPE_WIDGET,
+ G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+
+ g_object_class_install_properties (object_class, LAST_SCROLLABLE_PROP, scrollable_props);
+
+ g_object_class_override_property (object_class,
+ SCROLLABLE_PROP_HADJUSTMENT,
+ "hadjustment");
+ g_object_class_override_property (object_class,
+ SCROLLABLE_PROP_VADJUSTMENT,
+ "vadjustment");
+ g_object_class_override_property (object_class,
+ SCROLLABLE_PROP_HSCROLL_POLICY,
+ "hscroll-policy");
+ g_object_class_override_property (object_class,
+ SCROLLABLE_PROP_VSCROLL_POLICY,
+ "vscroll-policy");
+}
+
+static void
+adw_tab_overview_scrollable_init (AdwTabOverviewScrollable *self)
+{
+ GtkEventController *controller;
+ AdwAnimationTarget *target;
+
+ gtk_widget_set_overflow (GTK_WIDGET (self), GTK_OVERFLOW_HIDDEN);
+
+ controller = gtk_event_controller_motion_new ();
+ g_signal_connect_swapped (controller, "motion", G_CALLBACK (motion_cb), self);
+ g_signal_connect_swapped (controller, "leave", G_CALLBACK (leave_cb), self);
+ gtk_widget_add_controller (GTK_WIDGET (self), controller);
+
+ /* The actual update will be done in size_allocate(). After the animation
+ * finishes, don't remove it right away, it will be done in size-allocate as
+ * well after one last update, so that we don't miss the last frame.
+ */
+ target = adw_callback_animation_target_new ((AdwAnimationTargetFunc)
+ scroll_animation_cb,
+ self, NULL);
+ self->scroll_animation =
+ adw_timed_animation_new (GTK_WIDGET (self), 0, 1,
+ SCROLL_ANIMATION_DURATION, target);
+ g_signal_connect_swapped (self->scroll_animation, "done",
+ G_CALLBACK (scroll_animation_done_cb), self);
+}
+
+static gboolean
+extra_drag_drop_cb (AdwTabOverview *self,
+ AdwTabPage *page,
+ GValue *value)
+{
+ gboolean ret = GDK_EVENT_PROPAGATE;
+
+ g_signal_emit (self, signals[SIGNAL_EXTRA_DRAG_DROP], 0, page, value, &ret);
+
+ return ret;
+}
+
+static void
+empty_changed_cb (AdwTabOverview *self)
+{
+ gboolean empty =
+ self->search_active &&
+ adw_tab_grid_get_empty (self->grid) &&
+ adw_tab_grid_get_empty (self->pinned_grid);
+
+ gtk_stack_set_visible_child_name (GTK_STACK (self->stack),
+ empty ? "empty" : "tabs");
+}
+
+static void
+update_header_bar (AdwTabOverview *self)
+{
+ gtk_widget_set_visible (self->header_bar,
+ self->enable_search ||
+ adw_tab_overview_get_extra_menu (self));
+}
+
+static void
+update_new_tab_button (AdwTabOverview *self)
+{
+ gtk_widget_set_visible (self->new_tab_button,
+ self->enable_new_tab && !self->search_active);
+ gtk_widget_queue_resize (self->scrollable);
+}
+
+static void
+set_search_active (AdwTabOverview *self,
+ gboolean search_active)
+{
+ if (search_active == self->search_active)
+ return;
+
+ self->search_active = search_active;
+
+ update_new_tab_button (self);
+ empty_changed_cb (self);
+
+ g_object_notify_by_pspec (G_OBJECT (self), props[PROP_SEARCH_ACTIVE]);
+}
+
+static void
+search_changed_cb (AdwTabOverview *self)
+{
+ const char *text = gtk_editable_get_text (GTK_EDITABLE (self->search_entry));
+
+ adw_tab_grid_set_search_terms (self->grid, text);
+ adw_tab_grid_set_search_terms (self->pinned_grid, text);
+
+ set_search_active (self, text && *text);
+}
+
+static void
+stop_search_cb (AdwTabOverview *self)
+{
+ gtk_editable_set_text (GTK_EDITABLE (self->search_entry), "");
+
+ adw_tab_grid_set_search_terms (self->grid, "");
+ adw_tab_grid_set_search_terms (self->pinned_grid, "");
+
+ set_search_active (self, FALSE);
+}
+
+static void
+notify_action_name_cb (AdwTabOverview *self)
+{
+ g_object_notify_by_pspec (G_OBJECT (self), props[PROP_NEW_TAB_ACTION_NAME]);
+}
+
+static void
+notify_action_target_cb (AdwTabOverview *self)
+{
+ g_object_notify_by_pspec (G_OBJECT (self), props[PROP_NEW_TAB_ACTION_TARGET]);
+}
+
+static gboolean
+new_tab_idle_cb (AdwTabOverview *self)
+{
+ adw_tab_overview_set_open (self, FALSE);
+
+ return G_SOURCE_REMOVE;
+}
+
+static void
+new_tab_clicked_cb (AdwTabOverview *self)
+{
+ g_signal_emit (self, signals[SIGNAL_NEW_TAB_CLICKED], 0);
+
+ g_idle_add ((GSourceFunc) new_tab_idle_cb, self);
+}
+
+static void
+view_destroy_cb (AdwTabOverview *self)
+{
+ adw_tab_overview_set_view (self, NULL);
+}
+
+static void
+notify_selected_page_cb (AdwTabOverview *self)
+{
+ AdwTabPage *page = adw_tab_view_get_selected_page (self->view);
+
+ if (!page)
+ return;
+
+ if (adw_tab_page_get_pinned (page)) {
+ adw_tab_grid_select_page (self->pinned_grid, page);
+ adw_tab_grid_select_page (self->grid, page);
+ } else {
+ adw_tab_grid_select_page (self->grid, page);
+ adw_tab_grid_select_page (self->pinned_grid, page);
+ }
+}
+
+static void
+notify_n_pages_cb (AdwTabOverview *self)
+{
+ guint n_pages;
+ char *title_str;
+
+ if (!self->view) {
+ adw_window_title_set_title (ADW_WINDOW_TITLE (self->title), "");
+ return;
+ }
+
+ n_pages = adw_tab_view_get_n_pages (self->view);
+
+ title_str = g_strdup_printf (ngettext ("%u Tab", "%u Tabs", n_pages), n_pages);
+
+ adw_window_title_set_title (ADW_WINDOW_TITLE (self->title), title_str);
+
+ g_free (title_str);
+}
+
+static void
+notify_pinned_cb (AdwTabPage *page,
+ GParamSpec *pspec,
+ AdwTabOverview *self)
+{
+ AdwTabGrid *from, *to;
+ gboolean should_focus;
+
+ if (adw_tab_page_get_pinned (page)) {
+ from = self->grid;
+ to = self->pinned_grid;
+ } else {
+ from = self->pinned_grid;
+ to = self->grid;
+ }
+
+ should_focus = adw_tab_grid_is_page_focused (from, page);
+
+ adw_tab_grid_detach_page (from, page);
+ adw_tab_grid_attach_page (to, page, adw_tab_view_get_n_pinned_pages (self->view));
+
+ adw_tab_grid_scroll_to_page (to, page, TRUE);
+
+ if (should_focus)
+ adw_tab_grid_try_focus_selected_tab (to);
+}
+
+static void
+page_attached_cb (AdwTabOverview *self,
+ AdwTabPage *page,
+ int position)
+{
+ g_signal_connect_object (page, "notify::pinned",
+ G_CALLBACK (notify_pinned_cb), self,
+ 0);
+}
+
+static void
+page_detached_cb (AdwTabOverview *self,
+ AdwTabPage *page,
+ int position)
+{
+ g_signal_handlers_disconnect_by_func (page, notify_pinned_cb, self);
+}
+
+static void
+open_animation_value_cb (double value,
+ AdwTabOverview *self)
+{
+ self->progress = value;
+ gtk_widget_queue_draw (GTK_WIDGET (self));
+}
+
+static void
+open_animation_done_cb (AdwTabOverview *self)
+{
+ if (self->transition_picture) {
+ gtk_widget_set_opacity (self->transition_picture, 1);
+ g_clear_object (&self->transition_picture);
+
+ adw_tab_thumbnail_fade_out (self->transition_thumbnail);
+ self->transition_thumbnail = NULL;
+ }
+
+ if (!self->is_open) {
+ gtk_widget_hide (self->overview);
+ gtk_widget_set_can_target (self->overview, FALSE);
+ gtk_widget_set_can_target (self->child_bin, TRUE);
+ gtk_widget_set_can_focus (self->child_bin, TRUE);
+
+ gtk_search_bar_set_search_mode (GTK_SEARCH_BAR (self->search_bar), FALSE);
+ }
+
+ self->animating = FALSE;
+ gtk_widget_queue_draw (GTK_WIDGET (self));
+}
+
+static void
+calculate_bounds (AdwTabOverview *self,
+ graphene_rect_t *bounds,
+ graphene_rect_t *transition_bounds,
+ graphene_rect_t *clip_bounds,
+ graphene_size_t *clip_scale)
+{
+ GtkWidget *widget = GTK_WIDGET (self);
+ graphene_rect_t view_bounds, thumbnail_bounds;
+ double view_ratio, thumb_ratio;
+
+ if (!gtk_widget_compute_bounds (GTK_WIDGET (self->view), widget, &view_bounds))
+ g_critical ("View must be inside the overview"); // TODO
+
+ if (!gtk_widget_compute_bounds (self->transition_picture, widget, &thumbnail_bounds))
+ graphene_rect_init (&thumbnail_bounds, 0, 0, 0, 0);
+
+ graphene_rect_init (bounds, 0, 0,
+ gtk_widget_get_width (widget),
+ gtk_widget_get_height (widget));
+
+ view_ratio = view_bounds.size.width / view_bounds.size.height;
+ thumb_ratio = thumbnail_bounds.size.width / thumbnail_bounds.size.height;
+
+ if (view_ratio > thumb_ratio) {
+ double new_width = view_bounds.size.height * thumb_ratio;
+ double xalign = self->thumbnail_xalign;
+
+ if (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL)
+ xalign = 1 - xalign;
+
+ view_bounds.origin.x += (float) (view_bounds.size.width - new_width) * xalign;
+ view_bounds.size.width = new_width;
+ } else if (view_ratio < thumb_ratio) {
+ double new_height = view_bounds.size.width / thumb_ratio;
+
+ view_bounds.origin.y += (float) (view_bounds.size.height - new_height) * self->thumbnail_yalign;
+ view_bounds.size.height = new_height;
+ }
+
+ graphene_rect_interpolate (bounds, &view_bounds,
+ self->progress, clip_bounds);
+
+ graphene_size_init (clip_scale,
+ adw_lerp (1, thumbnail_bounds.size.width / view_bounds.size.width, self->progress),
+ adw_lerp (1, thumbnail_bounds.size.height / view_bounds.size.height, self->progress));
+
+ graphene_rect_init (transition_bounds,
+ adw_lerp (0, thumbnail_bounds.origin.x, self->progress),
+ adw_lerp (0, thumbnail_bounds.origin.y, self->progress),
+ clip_bounds->size.width * clip_scale->width,
+ clip_bounds->size.height * clip_scale->height);
+}
+
+static void
+should_round_corners (AdwTabOverview *self,
+ gboolean *round_top_left,
+ gboolean *round_top_right,
+ gboolean *round_bottom_left,
+ gboolean *round_bottom_right)
+{
+ GtkRoot *root = gtk_widget_get_root (GTK_WIDGET (self));
+ GtkBorder border, padding, window_border, window_padding;
+ graphene_rect_t bounds;
+ GtkStyleContext *context;
+ GdkSurface *surface;
+ GdkToplevelState state;
+ gboolean top_left = TRUE;
+ gboolean top_right = TRUE;
+ gboolean bottom_left = TRUE;
+ gboolean bottom_right = TRUE;
+
+ *round_top_left = FALSE;
+ *round_top_right = FALSE;
+ *round_bottom_left = FALSE;
+ *round_bottom_right = FALSE;
+
+ if (!root || !GTK_IS_WINDOW (root) || !gtk_widget_get_realized (GTK_WIDGET (root)))
+ return;
+
+ surface = gtk_native_get_surface (GTK_NATIVE (root));
+ state = gdk_toplevel_get_state (GDK_TOPLEVEL (surface));
+
+ if ((state & (GDK_TOPLEVEL_STATE_FULLSCREEN |
+ GDK_TOPLEVEL_STATE_MAXIMIZED |
+ GDK_TOPLEVEL_STATE_TILED |
+ GDK_TOPLEVEL_STATE_TOP_TILED |
+ GDK_TOPLEVEL_STATE_RIGHT_TILED |
+ GDK_TOPLEVEL_STATE_BOTTOM_TILED |
+ GDK_TOPLEVEL_STATE_LEFT_TILED)) > 0)
+ return;
+
+ context = gtk_widget_get_style_context (GTK_WIDGET (root));
+
+ if (!gtk_style_context_has_class (context, "csd") ||
+ gtk_style_context_has_class (context, "solid-csd"))
+ return;
+
+ gtk_style_context_get_border (context, &window_border);
+ gtk_style_context_get_padding (context, &window_padding);
+
+ context = gtk_widget_get_style_context (GTK_WIDGET (self));
+ gtk_style_context_get_border (context, &border);
+ gtk_style_context_get_padding (context, &padding);
+
+ if (!gtk_widget_compute_bounds (GTK_WIDGET (self), GTK_WIDGET (root), &bounds))
+ return;
+
+ if (border.left + padding.left + window_border.left + window_padding.left + bounds.origin.x > 0) {
+ top_left = FALSE;
+ bottom_left = FALSE;
+ }
+
+ if (border.right + padding.right + window_border.right + window_padding.right > 0 ||
+ bounds.origin.x + bounds.size.width < gtk_widget_get_width (GTK_WIDGET (root))) {
+ top_right = FALSE;
+ bottom_right = FALSE;
+ }
+
+ if (border.top + padding.top + window_border.top + window_padding.top + bounds.origin.y > 0) {
+ top_left = FALSE;
+ top_right = FALSE;
+ }
+
+ if (border.bottom + padding.bottom + window_border.bottom + window_padding.bottom > 0 ||
+ bounds.origin.y + bounds.size.height < gtk_widget_get_height (GTK_WIDGET (root))) {
+ bottom_left = FALSE;
+ bottom_right = FALSE;
+ }
+
+ *round_top_left = top_left;
+ *round_top_right = top_right;
+ *round_bottom_left = bottom_left;
+ *round_bottom_right = bottom_right;
+}
+
+static void
+adw_tab_overview_snapshot (GtkWidget *widget,
+ GtkSnapshot *snapshot)
+{
+ AdwTabOverview *self = ADW_TAB_OVERVIEW (widget);
+ graphene_rect_t bounds, transition_bounds, clip_bounds;
+ graphene_size_t clip_scale, corner_size, window_corner_size;
+ GskRoundedRect transition_rect;
+ gboolean round_top_left, round_top_right;
+ gboolean round_bottom_left, round_bottom_right;
+ GdkRGBA rgba;
+ GdkDisplay *display;
+ AdwStyleManager *style_manager;
+ gboolean hc;
+
+ if (!self->animating) {
+ if (self->is_open) {
+ GtkSnapshot *child_snapshot;
+
+ gtk_widget_snapshot_child (widget, self->overview, snapshot);
+
+ /* We don't want to actually draw the child, but we do need it
+ * to redraw so that it can be displayed by the paintables */
+ child_snapshot = gtk_snapshot_new ();
+
+ gtk_widget_snapshot_child (widget, self->child_bin, child_snapshot);
+
+ g_object_unref (child_snapshot);
+ } else {
+ gtk_widget_snapshot_child (widget, self->child_bin, snapshot);
+ }
+
+ return;
+ }
+
+ calculate_bounds (self, &bounds, &transition_bounds, &clip_bounds, &clip_scale);
+ should_round_corners (self, &round_top_left, &round_top_right,
+ &round_bottom_left, &round_bottom_right);
+
+ graphene_size_init (&corner_size,
+ adw_lerp (0, THUMBNAIL_BORDER_RADIUS, self->progress),
+ adw_lerp (0, THUMBNAIL_BORDER_RADIUS, self->progress));
+
+ graphene_size_init (&window_corner_size,
+ adw_lerp (WINDOW_BORDER_RADIUS,
+ THUMBNAIL_BORDER_RADIUS, self->progress),
+ adw_lerp (WINDOW_BORDER_RADIUS,
+ THUMBNAIL_BORDER_RADIUS, self->progress));
+
+ gsk_rounded_rect_init (&transition_rect, &transition_bounds,
+ round_top_left ? &window_corner_size : &corner_size,
+ round_top_right ? &window_corner_size : &corner_size,
+ round_bottom_right ? &window_corner_size : &corner_size,
+ round_bottom_left ? &window_corner_size : &corner_size);
+
+ display = gtk_widget_get_display (widget);
+ style_manager = adw_style_manager_get_for_display (display);
+ hc = adw_style_manager_get_high_contrast (style_manager);
+
+ /* Draw overview */
+ gtk_widget_snapshot_child (widget, self->overview, snapshot);
+
+ /* Draw dim layer */
+ if (!gtk_style_context_lookup_color (gtk_widget_get_style_context (widget),
+ "shade_color", &rgba))
+ rgba.alpha = 0;
+
+ rgba.alpha *= 1 - self->progress;
+
+ gtk_snapshot_append_color (snapshot, &rgba, &bounds);
+
+ /* Draw the transition thumbnail. Unfortunately, since GTK widgets have
+ * integer sizes, we can't use a real widget for this and have to custom
+ * draw it instead. We also want to interpolate border-radius. */
+ gtk_snapshot_push_rounded_clip (snapshot, &transition_rect);
+
+ if (self->transition_pinned)
+ gtk_snapshot_push_cross_fade (snapshot, self->progress);
+
+ gtk_snapshot_translate (snapshot, &transition_bounds.origin);
+ gtk_snapshot_scale (snapshot, clip_scale.width, clip_scale.height);
+ gtk_snapshot_translate (snapshot, &GRAPHENE_POINT_INIT (-clip_bounds.origin.x,
+ -clip_bounds.origin.y));
+ gtk_widget_snapshot_child (widget, self->child_bin, snapshot);
+
+ if (self->transition_pinned) {
+ GtkStyleContext *context = gtk_widget_get_style_context (self->transition_picture);
+
+ if (!gtk_style_context_lookup_color (context, "thumbnail_bg_color", &rgba))
+ rgba.red = rgba.green = rgba.blue = rgba.alpha = 1;
+
+ gtk_snapshot_pop (snapshot);
+ gtk_snapshot_append_color (snapshot, &rgba, &bounds);
+ gtk_snapshot_pop (snapshot);
+ }
+
+ gtk_snapshot_pop (snapshot);
+
+ /* Draw outer outline */
+ if (hc) {
+ rgba.red = rgba.green = rgba.blue = 0;
+ rgba.alpha = 0.5;
+ } else {
+ if (!gtk_style_context_lookup_color (gtk_widget_get_style_context (widget),
+ "shade_color", &rgba))
+ rgba.alpha = 0;
+ }
+
+ rgba.alpha *= adw_easing_ease (ADW_EASE_OUT_EXPO, self->progress);
+
+ gtk_snapshot_append_outset_shadow (snapshot, &transition_rect,
+ &rgba, 0, 0, 1, 0);
+
+ /* Draw inner outline */
+ if (!self->transition_pinned) {
+ /* Keep in sync with $window_outline_color */
+ rgba.red = rgba.green = rgba.blue = 1;
+ rgba.alpha = hc ? 0.3 : 0.07;
+
+ rgba.alpha *= adw_easing_ease (ADW_EASE_OUT_EXPO, self->progress);
+
+ gtk_snapshot_append_inset_shadow (snapshot, &transition_rect,
+ &rgba, 0, 0, 1, 0);
+ }
+}
+
+static void
+adw_tab_overview_dispose (GObject *object)
+{
+ AdwTabOverview *self = ADW_TAB_OVERVIEW (object);
+
+ adw_tab_overview_set_view (self, NULL);
+
+ gtk_widget_unparent (GTK_WIDGET (self->overview));
+ gtk_widget_unparent (GTK_WIDGET (self->child_bin));
+
+ g_clear_object (&self->open_animation);
+
+ G_OBJECT_CLASS (adw_tab_overview_parent_class)->dispose (object);
+}
+
+static void
+adw_tab_overview_get_property (GObject *object,
+ guint prop_id,
+ GValue *value,
+ GParamSpec *pspec)
+{
+ AdwTabOverview *self = ADW_TAB_OVERVIEW (object);
+
+ switch (prop_id) {
+ case PROP_VIEW:
+ g_value_set_object (value, adw_tab_overview_get_view (self));
+ break;
+ case PROP_CHILD:
+ g_value_set_object (value, adw_tab_overview_get_child (self));
+ break;
+ case PROP_OPEN:
+ g_value_set_boolean (value, adw_tab_overview_get_open (self));
+ break;
+ case PROP_INVERTED:
+ g_value_set_boolean (value, adw_tab_overview_get_inverted (self));
+ break;
+ case PROP_THUMBNAIL_XALIGN:
+ g_value_set_float (value, adw_tab_overview_get_thumbnail_xalign (self));
+ break;
+ case PROP_THUMBNAIL_YALIGN:
+ g_value_set_float (value, adw_tab_overview_get_thumbnail_yalign (self));
+ break;
+ case PROP_ENABLE_SEARCH:
+ g_value_set_boolean (value, adw_tab_overview_get_enable_search (self));
+ break;
+ case PROP_SEARCH_ACTIVE:
+ g_value_set_boolean (value, adw_tab_overview_get_search_active (self));
+ break;
+ case PROP_ENABLE_NEW_TAB:
+ g_value_set_boolean (value, adw_tab_overview_get_enable_new_tab (self));
+ break;
+ case PROP_NEW_TAB_ACTION_NAME:
+ g_value_set_string (value, adw_tab_overview_get_new_tab_action_name (self));
+ break;
+ case PROP_NEW_TAB_ACTION_TARGET:
+ g_value_set_variant (value, adw_tab_overview_get_new_tab_action_target_value (self));
+ break;
+ case PROP_EXTRA_MENU:
+ g_value_set_object (value, adw_tab_overview_get_extra_menu (self));
+ break;
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+ }
+}
+
+static void
+adw_tab_overview_set_property (GObject *object,
+ guint prop_id,
+ const GValue *value,
+ GParamSpec *pspec)
+{
+ AdwTabOverview *self = ADW_TAB_OVERVIEW (object);
+
+ switch (prop_id) {
+ case PROP_VIEW:
+ adw_tab_overview_set_view (self, g_value_get_object (value));
+ break;
+ case PROP_CHILD:
+ adw_tab_overview_set_child (self, g_value_get_object (value));
+ break;
+ case PROP_OPEN:
+ adw_tab_overview_set_open (self, g_value_get_boolean (value));
+ break;
+ case PROP_INVERTED:
+ adw_tab_overview_set_inverted (self, g_value_get_boolean (value));
+ break;
+ case PROP_THUMBNAIL_XALIGN:
+ adw_tab_overview_set_thumbnail_xalign (self, g_value_get_float (value));
+ break;
+ case PROP_THUMBNAIL_YALIGN:
+ adw_tab_overview_set_thumbnail_yalign (self, g_value_get_float (value));
+ break;
+ case PROP_ENABLE_SEARCH:
+ adw_tab_overview_set_enable_search (self, g_value_get_boolean (value));
+ break;
+ case PROP_ENABLE_NEW_TAB:
+ adw_tab_overview_set_enable_new_tab (self, g_value_get_boolean (value));
+ break;
+ case PROP_NEW_TAB_ACTION_NAME:
+ adw_tab_overview_set_new_tab_action_name (self, g_value_get_string (value));
+ break;
+ case PROP_NEW_TAB_ACTION_TARGET:
+ adw_tab_overview_set_new_tab_action_target_value (self, g_value_get_variant (value));
+ break;
+ case PROP_EXTRA_MENU:
+ adw_tab_overview_set_extra_menu (self, g_value_get_object (value));
+ break;
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+ }
+}
+
+static void
+overview_open_cb (AdwTabOverview *self)
+{
+ adw_tab_overview_set_open (self, TRUE);
+}
+
+static void
+adw_tab_overview_class_init (AdwTabOverviewClass *klass)
+{
+ GObjectClass *object_class = G_OBJECT_CLASS (klass);
+ GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
+
+ object_class->dispose = adw_tab_overview_dispose;
+ object_class->get_property = adw_tab_overview_get_property;
+ object_class->set_property = adw_tab_overview_set_property;
+
+ widget_class->snapshot = adw_tab_overview_snapshot;
+ widget_class->compute_expand = adw_widget_compute_expand;
+
+ /**
+ * AdwTabOverview:view: (attributes org.gtk.Property.get=adw_tab_overview_get_view
org.gtk.Property.set=adw_tab_overview_set_view)
+ *
+ * The tab view the overview controls.
+ *
+ * Since: 1.3
+ */
+ props[PROP_VIEW] =
+ g_param_spec_object ("view", NULL, NULL,
+ ADW_TYPE_TAB_VIEW,
+ G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS | G_PARAM_EXPLICIT_NOTIFY);
+
+ /**
+ * AdwTabOverview:child: (attributes org.gtk.Property.get=adw_tab_overview_get_child
org.gtk.Property.set=adw_tab_overview_set_child)
+ *
+ * The child widget.
+ *
+ * Since: 1.3
+ */
+ props[PROP_CHILD] =
+ g_param_spec_object ("child", NULL, NULL,
+ GTK_TYPE_WIDGET,
+ G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS | G_PARAM_EXPLICIT_NOTIFY);
+
+ /**
+ * AdwTabOverview:open: (attributes org.gtk.Property.get=adw_tab_overview_get_open
org.gtk.Property.set=adw_tab_overview_set_open)
+ *
+ * Whether the overview is open.
+ *
+ * Since: 1.3
+ */
+ props[PROP_OPEN] =
+ g_param_spec_boolean ("open", NULL, NULL,
+ FALSE,
+ G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS | G_PARAM_EXPLICIT_NOTIFY);
+
+ /**
+ * AdwTabOverview:inverted: (attributes org.gtk.Property.get=adw_tab_overview_get_inverted
org.gtk.Property.set=adw_tab_overview_set_inverted)
+ *
+ * Whether thumbnails use inverted layout.
+ *
+ * If set to `TRUE`, thumbnails will have the close button at the beginning
+ * and the indicator at the end rather than the other way around.
+ *
+ * Since: 1.3
+ */
+ props[PROP_INVERTED] =
+ g_param_spec_boolean ("inverted", NULL, NULL,
+ FALSE,
+ G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS | G_PARAM_EXPLICIT_NOTIFY);
+
+ /**
+ * AdwTabOverview:thumbnail-xalign: (attributes org.gtk.Property.get=adw_tab_overview_get_thumbnail_xalign
org.gtk.Property.set=adw_tab_overview_set_thumbnail_xalign)
+ *
+ * TODO
+ *
+ * Since: 1.3
+ */
+ props[PROP_THUMBNAIL_XALIGN] =
+ g_param_spec_float ("thumbnail-xalign", NULL, NULL,
+ 0.0, 1.0,
+ 0.0,
+ G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS | G_PARAM_EXPLICIT_NOTIFY);
+
+ /**
+ * AdwTabOverview:thumbnail-yalign: (attributes org.gtk.Property.get=adw_tab_overview_get_thumbnail_yalign
org.gtk.Property.set=adw_tab_overview_set_thumbnail_yalign)
+ *
+ * TODO
+ *
+ * Since: 1.3
+ */
+ props[PROP_THUMBNAIL_YALIGN] =
+ g_param_spec_float ("thumbnail-yalign", NULL, NULL,
+ 0.0, 1.0,
+ 0.0,
+ G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS | G_PARAM_EXPLICIT_NOTIFY);
+
+ /**
+ * AdwTabOverview:enable-search: (attributes org.gtk.Property.get=adw_tab_overview_get_enable_search
org.gtk.Property.set=adw_tab_overview_set_enable_search)
+ *
+ * TODO
+ *
+ * Since: 1.3
+ */
+ props[PROP_ENABLE_SEARCH] =
+ g_param_spec_boolean ("enable-search", NULL, NULL,
+ TRUE,
+ G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS | G_PARAM_EXPLICIT_NOTIFY);
+
+ /**
+ * AdwTabOverview:search-active: (attributes org.gtk.Property.get=adw_tab_overview_get_search_active
org.gtk.Property.set=adw_tab_overview_set_search_active)
+ *
+ * TODO
+ *
+ * Since: 1.3
+ */
+ props[PROP_SEARCH_ACTIVE] =
+ g_param_spec_boolean ("search-active", NULL, NULL,
+ FALSE,
+ G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
+
+ /**
+ * AdwTabOverview:enable-new-tab: (attributes org.gtk.Property.get=adw_tab_overview_get_enable_new_tab
org.gtk.Property.set=adw_tab_overview_set_enable_new_tab)
+ *
+ * TODO
+ *
+ * Since: 1.3
+ */
+ props[PROP_ENABLE_NEW_TAB] =
+ g_param_spec_boolean ("enable-new-tab", NULL, NULL,
+ FALSE,
+ G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS | G_PARAM_EXPLICIT_NOTIFY);
+
+ /**
+ * AdwTabOverview:new-tab-action-name: (attributes
org.gtk.Property.get=adw_tab_overview_get_new_tab_action_name
org.gtk.Property.set=adw_tab_overview_set_new_tab_action_name)
+ *
+ * TODO
+ *
+ * See [property@AdwTabOverview:new-tab-action-target].
+ *
+ * Since: 1.3
+ */
+ props[PROP_NEW_TAB_ACTION_NAME] =
+ g_param_spec_string ("new-tab-action-name", NULL, NULL,
+ NULL,
+ G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS | G_PARAM_EXPLICIT_NOTIFY);
+
+ /**
+ * AdwTabOverview:new-tab-action-target: (attributes
org.gtk.Property.get=adw_tab_overview_get_new_tab_action_target_value
org.gtk.Property.set=adw_tab_overview_set_new_tab_action_target_value)
+ *
+ * TODO
+ *
+ * See [property@AdwTabOverview:new-tab-action-name].
+ *
+ * Since: 1.3
+ */
+ props[PROP_NEW_TAB_ACTION_TARGET] =
+ g_param_spec_variant ("new-tab-action-target", NULL, NULL,
+ G_VARIANT_TYPE_ANY,
+ NULL,
+ G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS | G_PARAM_EXPLICIT_NOTIFY);
+
+ /**
+ * AdwTabOverview:extra-menu: (attributes org.gtk.Property.get=adw_tab_overview_get_extra_menu
org.gtk.Property.set=adw_tab_overview_set_extra_menu)
+ *
+ * TODO
+ *
+ * Since: 1.3
+ */
+ props[PROP_EXTRA_MENU] =
+ g_param_spec_object ("extra-menu", NULL, NULL,
+ G_TYPE_MENU_MODEL,
+ G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS | G_PARAM_EXPLICIT_NOTIFY);
+
+ g_object_class_install_properties (object_class, LAST_PROP, props);
+
+ /**
+ * AdwTabOverview::new-tab-clicked:
+ * @self: a tab overview
+ *
+ * This signal is emitted when TODO.
+ *
+ * See [property@TabOverview:enable-new-tab].
+ *
+ * Since: 1.3
+ */
+ signals[SIGNAL_NEW_TAB_CLICKED] =
+ g_signal_new ("new-tab-clicked",
+ G_TYPE_FROM_CLASS (klass),
+ G_SIGNAL_RUN_LAST,
+ 0,
+ NULL, NULL, NULL,
+ G_TYPE_NONE,
+ 0);
+
+ /**
+ * AdwTabOverview::extra-drag-drop:
+ * @self: a tab overview
+ * @page: the page matching the tab the content was dropped onto
+ * @value: the `GValue` being dropped
+ *
+ * This signal is emitted when content is dropped onto a tab.
+ *
+ * The content must be of one of the types set up via
+ * [method@TabOverview.setup_extra_drop_target].
+ *
+ * See [signal@Gtk.DropTarget::drop].
+ *
+ * Returns: whether the drop was accepted for @page
+ *
+ * Since: 1.3
+ */
+ signals[SIGNAL_EXTRA_DRAG_DROP] =
+ g_signal_new ("extra-drag-drop",
+ G_TYPE_FROM_CLASS (klass),
+ G_SIGNAL_RUN_LAST,
+ 0,
+ g_signal_accumulator_first_wins, NULL, NULL,
+ G_TYPE_BOOLEAN,
+ 2,
+ ADW_TYPE_TAB_PAGE,
+ G_TYPE_VALUE);
+
+ gtk_widget_class_install_action (widget_class, "overview.open", NULL,
+ (GtkWidgetActionActivateFunc) overview_open_cb);
+
+ gtk_widget_class_set_template_from_resource (widget_class,
+ "/org/gnome/Adwaita/ui/adw-tab-overview.ui");
+
+ gtk_widget_class_bind_template_child (widget_class, AdwTabOverview, overview);
+ gtk_widget_class_bind_template_child (widget_class, AdwTabOverview, stack);
+ gtk_widget_class_bind_template_child (widget_class, AdwTabOverview, scrollable);
+ gtk_widget_class_bind_template_child (widget_class, AdwTabOverview, child_bin);
+ gtk_widget_class_bind_template_child (widget_class, AdwTabOverview, header_bar);
+ gtk_widget_class_bind_template_child (widget_class, AdwTabOverview, title);
+ gtk_widget_class_bind_template_child (widget_class, AdwTabOverview, new_tab_button);
+ gtk_widget_class_bind_template_child (widget_class, AdwTabOverview, search_button);
+ gtk_widget_class_bind_template_child (widget_class, AdwTabOverview, search_bar);
+ gtk_widget_class_bind_template_child (widget_class, AdwTabOverview, search_entry);
+ gtk_widget_class_bind_template_child (widget_class, AdwTabOverview, extra_menu_button);
+ gtk_widget_class_bind_template_child (widget_class, AdwTabOverview, grid);
+ gtk_widget_class_bind_template_child (widget_class, AdwTabOverview, pinned_grid);
+ gtk_widget_class_bind_template_callback (widget_class, extra_drag_drop_cb);
+ gtk_widget_class_bind_template_callback (widget_class, empty_changed_cb);
+ gtk_widget_class_bind_template_callback (widget_class, search_changed_cb);
+ gtk_widget_class_bind_template_callback (widget_class, stop_search_cb);
+ gtk_widget_class_bind_template_callback (widget_class, notify_action_name_cb);
+ gtk_widget_class_bind_template_callback (widget_class, notify_action_target_cb);
+ gtk_widget_class_bind_template_callback (widget_class, new_tab_clicked_cb);
+
+ gtk_widget_class_set_layout_manager_type (widget_class, GTK_TYPE_BIN_LAYOUT);
+ gtk_widget_class_set_css_name (widget_class, "taboverview");
+
+ g_type_ensure (ADW_TYPE_TAB_GRID);
+ g_type_ensure (ADW_TYPE_TAB_OVERVIEW_SCROLLABLE);
+}
+
+static void
+adw_tab_overview_init (AdwTabOverview *self)
+{
+ AdwAnimationTarget *target;
+
+ self->thumbnail_xalign = 0;
+ self->thumbnail_yalign = 0;
+ self->enable_search = TRUE;
+
+ gtk_widget_init_template (GTK_WIDGET (self));
+
+ gtk_search_bar_connect_entry (GTK_SEARCH_BAR (self->search_bar),
+ GTK_EDITABLE (self->search_entry));
+
+ target = adw_callback_animation_target_new ((AdwAnimationTargetFunc) open_animation_value_cb,
+ self, NULL);
+
+ self->open_animation =
+ adw_timed_animation_new (GTK_WIDGET (self),
+ 0, 0,
+ TRANSITION_DURATION,
+ target);
+
+ g_signal_connect_swapped (self->open_animation, "done",
+ G_CALLBACK (open_animation_done_cb), self);
+}
+
+static void
+adw_tab_overview_buildable_add_child (GtkBuildable *buildable,
+ GtkBuilder *builder,
+ GObject *child,
+ const char *type)
+{
+ AdwTabOverview *self = ADW_TAB_OVERVIEW (buildable);
+
+ if (!self->overview)
+ parent_buildable_iface->add_child (buildable, builder, child, type);
+ else if (GTK_IS_WIDGET (child))
+ adw_tab_overview_set_child (self, GTK_WIDGET (child));
+ else
+ parent_buildable_iface->add_child (buildable, builder, child, type);
+}
+
+static void
+adw_tab_overview_buildable_init (GtkBuildableIface *iface)
+{
+ parent_buildable_iface = g_type_interface_peek_parent (iface);
+
+ iface->add_child = adw_tab_overview_buildable_add_child;
+}
+
+/**
+ * adw_tab_overview_new:
+ *
+ * Creates a new `AdwTabOverview`.
+ *
+ * Returns: the newly created `AdwTabOverview`
+ *
+ * Since: 1.3
+ */
+GtkWidget *
+adw_tab_overview_new (void)
+{
+ return g_object_new (ADW_TYPE_TAB_OVERVIEW, NULL);
+}
+
+/**
+ * adw_tab_overview_get_view: (attributes org.gtk.Method.get_property=view)
+ * @self: a tab overview
+ *
+ * Gets the tab view @self controls.
+ *
+ * Returns: (transfer none) (nullable): the tab view
+ *
+ * Since: 1.3
+ */
+AdwTabView *
+adw_tab_overview_get_view (AdwTabOverview *self)
+{
+ g_return_val_if_fail (ADW_IS_TAB_OVERVIEW (self), NULL);
+
+ return self->view;
+}
+
+/**
+ * adw_tab_overview_set_view: (attributes org.gtk.Method.set_property=view)
+ * @self: a tab overview
+ * @view: (nullable): a tab view
+ *
+ * Sets the tab view to control.
+ *
+ * Since: 1.3
+ */
+void
+adw_tab_overview_set_view (AdwTabOverview *self,
+ AdwTabView *view)
+{
+ g_return_if_fail (ADW_IS_TAB_OVERVIEW (self));
+ g_return_if_fail (view == NULL || ADW_IS_TAB_VIEW (view));
+
+ if (self->view == view)
+ return;
+
+ if (self->view) {
+ int i, n;
+
+ g_signal_handlers_disconnect_by_func (self->view, notify_selected_page_cb, self);
+ g_signal_handlers_disconnect_by_func (self->view, notify_n_pages_cb, self);
+ g_signal_handlers_disconnect_by_func (self->view, page_attached_cb, self);
+ g_signal_handlers_disconnect_by_func (self->view, page_detached_cb, self);
+ g_signal_handlers_disconnect_by_func (self->view, view_destroy_cb, self);
+
+ n = adw_tab_view_get_n_pages (self->view);
+
+ for (i = 0; i < n; i++)
+ page_detached_cb (self, adw_tab_view_get_nth_page (self->view, i), i);
+
+ adw_tab_grid_set_view (self->grid, NULL);
+ adw_tab_grid_set_view (self->pinned_grid, NULL);
+
+ notify_n_pages_cb (self);
+ }
+
+ g_set_object (&self->view, view);
+
+ if (self->view) {
+ int i, n;
+
+ adw_tab_grid_set_view (self->grid, view);
+ adw_tab_grid_set_view (self->pinned_grid, view);
+
+ g_signal_connect_object (self->view, "notify::selected-page",
+ G_CALLBACK (notify_selected_page_cb), self,
+ G_CONNECT_SWAPPED);
+ g_signal_connect_object (self->view, "notify::n-pages",
+ G_CALLBACK (notify_n_pages_cb), self,
+ G_CONNECT_SWAPPED);
+ g_signal_connect_object (self->view, "page-attached",
+ G_CALLBACK (page_attached_cb), self,
+ G_CONNECT_SWAPPED);
+ g_signal_connect_object (self->view, "page-detached",
+ G_CALLBACK (page_detached_cb), self,
+ G_CONNECT_SWAPPED);
+ g_signal_connect_object (self->view, "destroy",
+ G_CALLBACK (view_destroy_cb), self,
+ G_CONNECT_SWAPPED);
+
+ n = adw_tab_view_get_n_pages (self->view);
+
+ for (i = 0; i < n; i++)
+ page_attached_cb (self, adw_tab_view_get_nth_page (self->view, i), i);
+
+ notify_n_pages_cb (self);
+ }
+
+ g_object_notify_by_pspec (G_OBJECT (self), props[PROP_VIEW]);
+}
+
+/**
+ * adw_tab_overview_get_child: (attributes org.gtk.Method.get_property=child)
+ * @self: a `AdwTabOveview`
+ *
+ * Gets the child widget of @self.
+ *
+ * Returns: (nullable) (transfer none): the child widget of @self
+ *
+ * Since: 1.3
+ */
+GtkWidget *
+adw_tab_overview_get_child (AdwTabOverview *self)
+{
+ g_return_val_if_fail (ADW_IS_TAB_OVERVIEW (self), NULL);
+
+ return adw_bin_get_child (ADW_BIN (self->child_bin));
+}
+
+/**
+ * adw_tab_overview_set_child: (attributes org.gtk.Method.set_property=child)
+ * @self: a tab overview
+ * @child: (nullable): the child widget
+ *
+ * Sets the child widget of @self.
+ *
+ * Since: 1.3
+ */
+void
+adw_tab_overview_set_child (AdwTabOverview *self,
+ GtkWidget *child)
+{
+ g_return_if_fail (ADW_IS_TAB_OVERVIEW (self));
+ g_return_if_fail (child == NULL || GTK_IS_WIDGET (child));
+
+ if (child == adw_tab_overview_get_child (self))
+ return;
+
+ adw_bin_set_child (ADW_BIN (self->child_bin), child);
+
+ g_object_notify_by_pspec (G_OBJECT (self), props[PROP_CHILD]);
+}
+
+/**
+ * adw_tab_overview_get_open: (attributes org.gtk.Method.get_property=open)
+ * @self: a tab overview
+ *
+ * Gets whether the overview is open.
+ *
+ * Returns: whether the overview is open
+ *
+ * Since: 1.3
+ */
+gboolean
+adw_tab_overview_get_open (AdwTabOverview *self)
+{
+ g_return_val_if_fail (ADW_IS_TAB_OVERVIEW (self), FALSE);
+
+ return self->is_open;
+}
+
+/**
+ * adw_tab_overview_set_open: (attributes org.gtk.Method.set_property=open)
+ * @self: a tab overview
+ * @open: whether the overview is open
+ *
+ * Sets whether the overview is open.
+ *
+ * Since: 1.3
+ */
+void
+adw_tab_overview_set_open (AdwTabOverview *self,
+ gboolean open)
+{
+ AdwTabPage *selected_page;
+ AdwTabGrid *grid;
+
+ g_return_if_fail (ADW_IS_TAB_OVERVIEW (self));
+
+ open = !!open;
+
+ if (self->is_open == open)
+ return;
+
+ selected_page = adw_tab_view_get_selected_page (self->view);
+
+ self->transition_pinned = adw_tab_page_get_pinned (selected_page);
+
+ if (self->transition_pinned)
+ grid = ADW_TAB_GRID (self->pinned_grid);
+ else
+ grid = ADW_TAB_GRID (self->grid);
+
+ if (self->transition_thumbnail) {
+ if (self->transition_thumbnail != adw_tab_grid_get_transition_thumbnail (grid)) {
+ adw_animation_skip (self->open_animation);
+ }
+ }
+
+ self->is_open = open;
+
+ if (open) {
+ gtk_widget_show (self->overview);
+ gtk_widget_set_can_target (self->overview, TRUE);
+ gtk_widget_set_can_target (self->child_bin, FALSE);
+ gtk_widget_set_can_focus (self->child_bin, FALSE);
+ }
+
+ if (self->transition_picture)
+ gtk_widget_set_opacity (self->transition_picture, 1);
+
+ if (open)
+ adw_tab_grid_scroll_to_page (grid, selected_page, FALSE); // FIXME doesn't work, maybe needs idle?
+
+ self->transition_thumbnail = adw_tab_grid_get_transition_thumbnail (grid);
+ self->transition_picture = g_object_ref (adw_tab_thumbnail_get_thumbnail (self->transition_thumbnail));
+ gtk_widget_set_opacity (self->transition_picture, 0);
+
+ adw_timed_animation_set_value_from (ADW_TIMED_ANIMATION (self->open_animation),
+ self->progress);
+ adw_timed_animation_set_value_to (ADW_TIMED_ANIMATION (self->open_animation),
+ open ? 1 : 0);
+
+ self->animating = TRUE;
+ adw_animation_play (self->open_animation);
+
+ g_object_notify_by_pspec (G_OBJECT (self), props[PROP_OPEN]);
+}
+
+/**
+ * adw_tab_overview_get_inverted: (attributes org.gtk.Method.get_property=inverted)
+ * @self: a tab overview
+ *
+ * Gets whether thumbnails use inverted layout.
+ *
+ * Returns: whether thumbnails use inverted layout
+ *
+ * Since: 1.3
+ */
+gboolean
+adw_tab_overview_get_inverted (AdwTabOverview *self)
+{
+ g_return_val_if_fail (ADW_IS_TAB_OVERVIEW (self), FALSE);
+
+ return adw_tab_grid_get_inverted (self->grid);
+}
+
+/**
+ * adw_tab_overview_set_inverted: (attributes org.gtk.Method.set_property=inverted)
+ * @self: a tab overview
+ * @inverted: whether thumbnails use inverted layout
+ *
+ * Sets whether tabs thumbnails use inverted layout.
+ *
+ * If set to `TRUE`, thumbnails will have the close button at the beginning and
+ * the indicator at the end rather than the other way around.
+ *
+ * Since: 1.3
+ */
+void
+adw_tab_overview_set_inverted (AdwTabOverview *self,
+ gboolean inverted)
+{
+ g_return_if_fail (ADW_IS_TAB_OVERVIEW (self));
+
+ inverted = !!inverted;
+
+ if (adw_tab_overview_get_inverted (self) == inverted)
+ return;
+
+ adw_tab_grid_set_inverted (self->grid, inverted);
+ adw_tab_grid_set_inverted (self->pinned_grid, inverted);
+
+ g_object_notify_by_pspec (G_OBJECT (self), props[PROP_INVERTED]);
+}
+
+/**
+ * adw_tab_overview_get_thumbnail_xalign: (attributes org.gtk.Method.get_property=thumbnail-xalign)
+ * @self: a tab overview
+ *
+ * Gets TODO
+ *
+ * Returns: TODO
+ *
+ * Since: 1.3
+ */
+float
+adw_tab_overview_get_thumbnail_xalign (AdwTabOverview *self)
+{
+ g_return_val_if_fail (ADW_IS_TAB_OVERVIEW (self), 0.0f);
+
+ return self->thumbnail_xalign;
+}
+
+/**
+ * adw_tab_overview_set_thumbnail_xalign: (attributes org.gtk.Method.set_property=thumbnail-xalign)
+ * @self: a tab overview
+ * @xalign: TODO
+ *
+ * Sets TODO
+ *
+ * Since: 1.3
+ */
+void
+adw_tab_overview_set_thumbnail_xalign (AdwTabOverview *self,
+ float xalign)
+{
+ g_return_if_fail (ADW_IS_TAB_OVERVIEW (self));
+
+ xalign = CLAMP (xalign, 0.0, 1.0);
+
+ if (self->thumbnail_xalign == xalign)
+ return;
+
+ self->thumbnail_xalign = xalign;
+
+ adw_tab_grid_set_thumbnail_align (self->grid,
+ self->thumbnail_xalign,
+ self->thumbnail_yalign);
+ adw_tab_grid_set_thumbnail_align (self->pinned_grid,
+ self->thumbnail_xalign,
+ self->thumbnail_yalign);
+
+ g_object_notify_by_pspec (G_OBJECT (self), props[PROP_THUMBNAIL_XALIGN]);
+}
+
+/**
+ * adw_tab_overview_get_thumbnail_yalign: (attributes org.gtk.Method.get_property=thumbnail-yalign)
+ * @self: a tab overview
+ *
+ * Gets TODO
+ *
+ * Returns: TODO
+ *
+ * Since: 1.3
+ */
+float
+adw_tab_overview_get_thumbnail_yalign (AdwTabOverview *self)
+{
+ g_return_val_if_fail (ADW_IS_TAB_OVERVIEW (self), 0.0f);
+
+ return self->thumbnail_yalign;
+}
+
+/**
+ * adw_tab_overview_set_thumbnail_xalign: (attributes org.gtk.Method.set_property=thumbnail-yalign)
+ * @self: a tab overview
+ * @xalign: TODO
+ *
+ * Sets TODO
+ *
+ * Since: 1.3
+ */
+void
+adw_tab_overview_set_thumbnail_yalign (AdwTabOverview *self,
+ float yalign)
+{
+ g_return_if_fail (ADW_IS_TAB_OVERVIEW (self));
+
+ yalign = CLAMP (yalign, 0.0, 1.0);
+
+ if (self->thumbnail_yalign == yalign)
+ return;
+
+ self->thumbnail_yalign = yalign;
+
+ adw_tab_grid_set_thumbnail_align (self->grid,
+ self->thumbnail_xalign,
+ self->thumbnail_yalign);
+ adw_tab_grid_set_thumbnail_align (self->pinned_grid,
+ self->thumbnail_xalign,
+ self->thumbnail_yalign);
+
+ g_object_notify_by_pspec (G_OBJECT (self), props[PROP_THUMBNAIL_YALIGN]);
+}
+
+/**
+ * adw_tab_overview_get_enable_search: (attributes org.gtk.Method.get_property=enable-search)
+ * @self: a tab overview
+ *
+ * Gets TODO
+ *
+ * Returns: TODO
+ *
+ * Since: 1.3
+ */
+gboolean
+adw_tab_overview_get_enable_search (AdwTabOverview *self)
+{
+ g_return_val_if_fail (ADW_IS_TAB_OVERVIEW (self), FALSE);
+
+ return self->enable_search;
+}
+
+/**
+ * adw_tab_overview_set_enable_search: (attributes org.gtk.Method.set_property=enable-search)
+ * @self: a tab overview
+ * @enable_search: TODO
+ *
+ * Sets TODO
+ *
+ * Since: 1.3
+ */
+void
+adw_tab_overview_set_enable_search (AdwTabOverview *self,
+ gboolean enable_search)
+{
+ g_return_if_fail (ADW_IS_TAB_OVERVIEW (self));
+
+ enable_search = !!enable_search;
+
+ if (self->enable_search == enable_search)
+ return;
+
+ self->enable_search = enable_search;
+
+ if (!enable_search)
+ gtk_search_bar_set_search_mode (GTK_SEARCH_BAR (self->search_bar), FALSE);
+
+ gtk_search_bar_set_key_capture_widget (GTK_SEARCH_BAR (self->search_bar),
+ enable_search ? self->overview : NULL);
+ gtk_widget_set_visible (self->search_button, enable_search);
+ update_header_bar (self);
+
+ g_object_notify_by_pspec (G_OBJECT (self), props[PROP_ENABLE_SEARCH]);
+}
+
+/**
+ * adw_tab_overview_get_search_active: (attributes org.gtk.Method.get_property=search-active)
+ * @self: a tab overview
+ *
+ * Gets TODO
+ *
+ * Returns: TODO
+ *
+ * Since: 1.3
+ */
+gboolean
+adw_tab_overview_get_search_active (AdwTabOverview *self)
+{
+ g_return_val_if_fail (ADW_IS_TAB_OVERVIEW (self), FALSE);
+
+ return self->search_active;
+}
+
+/**
+ * adw_tab_overview_get_enable_new_tab: (attributes org.gtk.Method.get_property=enable-new-tab)
+ * @self: a tab overview
+ *
+ * Gets TODO
+ *
+ * Returns: TODO
+ *
+ * Since: 1.3
+ */
+gboolean
+adw_tab_overview_get_enable_new_tab (AdwTabOverview *self)
+{
+ g_return_val_if_fail (ADW_IS_TAB_OVERVIEW (self), FALSE);
+
+ return self->enable_new_tab;
+}
+
+/**
+ * adw_tab_overview_set_enable_new_tab: (attributes org.gtk.Method.set_property=enable-new-tab)
+ * @self: a tab overview
+ * @enable_new_tab: TODO
+ *
+ * Sets TODO
+ *
+ * Since: 1.3
+ */
+void
+adw_tab_overview_set_enable_new_tab (AdwTabOverview *self,
+ gboolean enable_new_tab)
+{
+ g_return_if_fail (ADW_IS_TAB_OVERVIEW (self));
+
+ enable_new_tab = !!enable_new_tab;
+
+ if (self->enable_new_tab == enable_new_tab)
+ return;
+
+ self->enable_new_tab = enable_new_tab;
+
+ update_new_tab_button (self);
+
+ g_object_notify_by_pspec (G_OBJECT (self), props[PROP_ENABLE_NEW_TAB]);
+}
+
+/**
+ * adw_tab_overview_get_new_tab_action_name: (attributes org.gtk.Method.get_property=new-tab-action-name)
+ * @self: a tab overview
+ *
+ * Gets the TODO
+ *
+ * Returns: (nullable): the action name
+ *
+ * Since: 1.3
+ */
+const char *
+adw_tab_overview_get_new_tab_action_name (AdwTabOverview *self)
+{
+ g_return_val_if_fail (ADW_IS_TAB_OVERVIEW (self), NULL);
+
+ return gtk_actionable_get_action_name (GTK_ACTIONABLE (self->new_tab_button));
+}
+
+/**
+ * adw_tab_overview_set_new_tab_action_name: (attributes org.gtk.Method.set_property=new-tab-action-name)
+ * @self: a tab overview
+ * @action_name: (nullable): the action name
+ *
+ * TODO
+ *
+ * See [property@TabOverview:new-tab-action-target].
+ *
+ * Since: 1.3
+ */
+void
+adw_tab_overview_set_new_tab_action_name (AdwTabOverview *self,
+ const char *action_name)
+{
+ g_return_if_fail (ADW_IS_TAB_OVERVIEW (self));
+
+ gtk_actionable_set_action_name (GTK_ACTIONABLE (self->new_tab_button),
+ action_name);
+}
+
+/**
+ * adw_tab_overview_get_new_tab_action_target_value: (attributes
org.gtk.Method.get_property=new-tab-action-target)
+ * @self: a tab overview
+ *
+ * Gets the TODO
+ *
+ * Returns: (transfer none) (nullable): the action target
+ *
+ * Since: 1.3
+ */
+GVariant *
+adw_tab_overview_get_new_tab_action_target_value (AdwTabOverview *self)
+{
+ g_return_val_if_fail (ADW_IS_TAB_OVERVIEW (self), NULL);
+
+ return gtk_actionable_get_action_target_value (GTK_ACTIONABLE (self->new_tab_button));
+}
+
+/**
+ * adw_tab_overview_set_new_tab_action_target_value: (attributes
org.gtk.Method.set_property=new-tab-action-target)
+ * @self: a tab overview
+ * @action_target: (nullable): the action target
+ *
+ * Sets the parameter for action invocations. TODO
+ *
+ * If the @action_target variant has a floating reference this function
+ * will sink it.
+ *
+ * See [property@TabOverview:new-tab-action-name].
+ *
+ * Since: 1.3
+ */
+void
+adw_tab_overview_set_new_tab_action_target_value (AdwTabOverview *self,
+ GVariant *action_target)
+{
+ g_return_if_fail (ADW_IS_TAB_OVERVIEW (self));
+
+ gtk_actionable_set_action_target_value (GTK_ACTIONABLE (self->new_tab_button),
+ action_target);
+}
+
+/**
+ * adw_tab_overview_set_new_tab_action_target: (skip)
+ * @self: a tab overview
+ * @format_string: (nullable): a variant format string
+ * @...: arguments appropriate for @target_format
+ *
+ * Sets the parameter for action invocations. TODO
+ *
+ * This is a convenience function that calls [ctor GLib Variant new] for
+ * @format_string and uses the result to call
+ * [method@TabOverview.set_new_tab_action_target_value].
+ *
+ * If you are setting a string-valued target and want to set
+ * the action name at the same time, you can use
+ * [method@TabOverview.set_new_tab_detailed_action_name].
+
+ * Since: 1.3
+ */
+void
+adw_tab_overview_set_new_tab_action_target (AdwTabOverview *self,
+ const char *format_string,
+ ...)
+{
+ g_return_if_fail (ADW_IS_TAB_OVERVIEW (self));
+
+ va_list args;
+
+ va_start (args, format_string);
+ adw_tab_overview_set_new_tab_action_target_value (self,
+ g_variant_new_va (format_string,
+ NULL, &args));
+ va_end (args);
+}
+
+/**
+ * adw_tab_overview_set_new_tab_detailed_action_name:
+ * @self: a tab overview
+ * @detailed_action_name: (nullable): the detailed action name
+ *
+ * Sets the action name and its parameter. TODO
+ *
+ * @detailed_action_name is a string in the format accepted by
+ * [func@Gio.Action.parse_detailed_name].
+ *
+ * Since: 1.3
+ */
+void
+adw_tab_overview_set_new_tab_detailed_action_name (AdwTabOverview *self,
+ const char *detailed_action_name)
+{
+ g_return_if_fail (ADW_IS_TAB_OVERVIEW (self));
+
+ gtk_actionable_set_detailed_action_name (GTK_ACTIONABLE (self->new_tab_button),
+ detailed_action_name);
+}
+
+/**
+ * adw_tab_overview_get_extra_menu: (attributes org.gtk.Method.get_property=extra-menu)
+ * @self: a tab overview
+ *
+ * Gets TODO.
+ *
+ * Returns: (transfer none) (nullable): the TODO for @self
+ *
+ * Since: 1.3
+ */
+GMenuModel *
+adw_tab_overview_get_extra_menu (AdwTabOverview *self)
+{
+ g_return_val_if_fail (ADW_IS_TAB_OVERVIEW (self), NULL);
+
+ return gtk_menu_button_get_menu_model (GTK_MENU_BUTTON (self->extra_menu_button));
+}
+
+/**
+ * adw_tab_overview_set_extra_menu: (attributes org.gtk.Method.set_property=extra-menu)
+ * @self: a tab overview
+ * @menu_model: (nullable): a menu model
+ *
+ * Sets the TODO
+ *
+ * Since: 1.3
+ */
+void
+adw_tab_overview_set_extra_menu (AdwTabOverview *self,
+ GMenuModel *extra_menu)
+{
+ g_return_if_fail (ADW_IS_TAB_OVERVIEW (self));
+ g_return_if_fail (extra_menu == NULL || G_IS_MENU_MODEL (extra_menu));
+
+ if (extra_menu == adw_tab_overview_get_extra_menu (self))
+ return;
+
+ gtk_menu_button_set_menu_model (GTK_MENU_BUTTON (self->extra_menu_button),
+ extra_menu);
+ gtk_widget_set_visible (self->extra_menu_button, !!extra_menu);
+ update_header_bar (self);
+
+ g_object_notify_by_pspec (G_OBJECT (self), props[PROP_EXTRA_MENU]);
+}
+
+/**
+ * adw_tab_overview_setup_extra_drop_target:
+ * @self: a tab overview
+ * @actions: the supported actions
+ * @types: (nullable) (transfer none) (array length=n_types):
+ * all supported `GType`s that can be dropped
+ * @n_types: number of @types
+ *
+ * Sets the supported types for this drop target.
+ *
+ * Sets up an extra drop target on tabs.
+ *
+ * This allows to drag arbitrary content onto tabs, for example URLs in a web
+ * browser.
+ *
+ * If a tab is hovered for a certain period of time while dragging the content,
+ * it will be automatically selected.
+ *
+ * The [signal@TabOverview::extra-drag-drop] signal can be used to handle the
+ * drop.
+ *
+ * Since: 1.3
+ */
+void
+adw_tab_overview_setup_extra_drop_target (AdwTabOverview *self,
+ GdkDragAction actions,
+ GType *types,
+ gsize n_types)
+{
+ g_return_if_fail (ADW_IS_TAB_OVERVIEW (self));
+ g_return_if_fail (n_types == 0 || types != NULL);
+
+ adw_tab_grid_setup_extra_drop_target (self->grid, actions, types, n_types);
+ adw_tab_grid_setup_extra_drop_target (self->pinned_grid, actions, types, n_types);
+}
+
+gboolean
+adw_tab_overview_tabs_have_visible_focus (AdwTabOverview *self)
+{
+ GtkWidget *pinned_focus_child, *scroll_focus_child;
+
+ g_return_val_if_fail (ADW_IS_TAB_OVERVIEW (self), FALSE);
+
+ pinned_focus_child = gtk_widget_get_focus_child (GTK_WIDGET (self->pinned_grid));
+ scroll_focus_child = gtk_widget_get_focus_child (GTK_WIDGET (self->grid));
+
+ if (pinned_focus_child && gtk_widget_has_visible_focus (pinned_focus_child))
+ return TRUE;
+
+ if (scroll_focus_child && gtk_widget_has_visible_focus (scroll_focus_child))
+ return TRUE;
+
+ return FALSE;
+}
+
+AdwTabGrid *
+adw_tab_overview_get_tab_grid (AdwTabOverview *self)
+{
+ g_return_val_if_fail (ADW_IS_TAB_OVERVIEW (self), NULL);
+
+ return self->grid;
+}
+
+AdwTabGrid *
+adw_tab_overview_get_pinned_tab_grid (AdwTabOverview *self)
+{
+ g_return_val_if_fail (ADW_IS_TAB_OVERVIEW (self), NULL);
+
+ return self->pinned_grid;
+}
diff --git a/src/adw-tab-overview.h b/src/adw-tab-overview.h
new file mode 100644
index 00000000..27be2e45
--- /dev/null
+++ b/src/adw-tab-overview.h
@@ -0,0 +1,112 @@
+/*
+ * Copyright (C) 2021 Purism SPC
+ *
+ * SPDX-License-Identifier: LGPL-2.1+
+ *
+ * Author: Alexander Mikhaylenko <alexander mikhaylenko puri sm>
+ */
+
+#pragma once
+
+#if !defined(_ADWAITA_INSIDE) && !defined(ADWAITA_COMPILATION)
+#error "Only <adwaita.h> can be included directly."
+#endif
+
+#include "adw-version.h"
+
+#include <gtk/gtk.h>
+#include "adw-tab-view.h"
+
+G_BEGIN_DECLS
+
+#define ADW_TYPE_TAB_OVERVIEW (adw_tab_overview_get_type())
+
+ADW_AVAILABLE_IN_1_2
+G_DECLARE_FINAL_TYPE (AdwTabOverview, adw_tab_overview, ADW, TAB_OVERVIEW, GtkWidget)
+
+ADW_AVAILABLE_IN_1_2
+GtkWidget *adw_tab_overview_new (void) G_GNUC_WARN_UNUSED_RESULT;
+
+ADW_AVAILABLE_IN_1_2
+AdwTabView *adw_tab_overview_get_view (AdwTabOverview *self);
+ADW_AVAILABLE_IN_1_2
+void adw_tab_overview_set_view (AdwTabOverview *self,
+ AdwTabView *view);
+
+ADW_AVAILABLE_IN_1_2
+GtkWidget *adw_tab_overview_get_child (AdwTabOverview *self);
+ADW_AVAILABLE_IN_1_2
+void adw_tab_overview_set_child (AdwTabOverview *self,
+ GtkWidget *child);
+
+ADW_AVAILABLE_IN_1_2
+gboolean adw_tab_overview_get_open (AdwTabOverview *self);
+ADW_AVAILABLE_IN_1_2
+void adw_tab_overview_set_open (AdwTabOverview *self,
+ gboolean open);
+
+ADW_AVAILABLE_IN_1_2
+gboolean adw_tab_overview_get_inverted (AdwTabOverview *self);
+ADW_AVAILABLE_IN_1_2
+void adw_tab_overview_set_inverted (AdwTabOverview *self,
+ gboolean inverted);
+
+ADW_AVAILABLE_IN_1_2
+float adw_tab_overview_get_thumbnail_xalign (AdwTabOverview *self);
+ADW_AVAILABLE_IN_1_2
+void adw_tab_overview_set_thumbnail_xalign (AdwTabOverview *self,
+ float xalign);
+
+ADW_AVAILABLE_IN_1_2
+float adw_tab_overview_get_thumbnail_yalign (AdwTabOverview *self);
+ADW_AVAILABLE_IN_1_2
+void adw_tab_overview_set_thumbnail_yalign (AdwTabOverview *self,
+ float xalign);
+
+ADW_AVAILABLE_IN_1_2
+gboolean adw_tab_overview_get_enable_search (AdwTabOverview *self);
+ADW_AVAILABLE_IN_1_2
+void adw_tab_overview_set_enable_search (AdwTabOverview *self,
+ gboolean enable_search);
+
+ADW_AVAILABLE_IN_1_2
+gboolean adw_tab_overview_get_search_active (AdwTabOverview *self);
+
+ADW_AVAILABLE_IN_1_2
+gboolean adw_tab_overview_get_enable_new_tab (AdwTabOverview *self);
+ADW_AVAILABLE_IN_1_2
+void adw_tab_overview_set_enable_new_tab (AdwTabOverview *self,
+ gboolean enable_new_tab);
+
+ADW_AVAILABLE_IN_1_2
+const char *adw_tab_overview_get_new_tab_action_name (AdwTabOverview *self);
+ADW_AVAILABLE_IN_1_2
+void adw_tab_overview_set_new_tab_action_name (AdwTabOverview *self,
+ const char *action_name);
+
+ADW_AVAILABLE_IN_1_2
+GVariant *adw_tab_overview_get_new_tab_action_target_value (AdwTabOverview *self);
+ADW_AVAILABLE_IN_1_2
+void adw_tab_overview_set_new_tab_action_target_value (AdwTabOverview *self,
+ GVariant *action_target);
+ADW_AVAILABLE_IN_1_2
+void adw_tab_overview_set_new_tab_action_target (AdwTabOverview *self,
+ const char *format_string,
+ ...);
+ADW_AVAILABLE_IN_1_2
+void adw_tab_overview_set_new_tab_detailed_action_name (AdwTabOverview *self,
+ const char *detailed_action_name);
+
+ADW_AVAILABLE_IN_1_2
+GMenuModel *adw_tab_overview_get_extra_menu (AdwTabOverview *self);
+ADW_AVAILABLE_IN_1_2
+void adw_tab_overview_set_extra_menu (AdwTabOverview *self,
+ GMenuModel *extra_menu);
+
+ADW_AVAILABLE_IN_1_2
+void adw_tab_overview_setup_extra_drop_target (AdwTabOverview *self,
+ GdkDragAction actions,
+ GType *types,
+ gsize n_types);
+
+G_END_DECLS
diff --git a/src/adw-tab-overview.ui b/src/adw-tab-overview.ui
new file mode 100644
index 00000000..e28a2422
--- /dev/null
+++ b/src/adw-tab-overview.ui
@@ -0,0 +1,142 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<interface>
+ <requires lib="gtk" version="4.0"/>
+ <template class="AdwTabOverview" parent="GtkWidget">
+ <child>
+ <object class="AdwBin" id="child_bin">
+ <style>
+ <class name="background"/>
+ </style>
+ </object>
+ </child>
+ <child>
+ <object class="GtkBox" id="overview">
+ <property name="visible">False</property>
+ <property name="can-target">False</property>
+ <property name="orientation">vertical</property>
+ <style>
+ <class name="overview"/>
+ <class name="scrolled-to-top"/>
+ </style>
+ <child>
+ <object class="AdwHeaderBar" id="header_bar">
+ <child type="start">
+ <object class="GtkToggleButton" id="search_button">
+ <property name="icon-name">edit-find-symbolic</property>
+ <property name="tooltip-text" translatable="yes">Search Tabs</property>
+ </object>
+ </child>
+ <property name="title-widget">
+ <object class="AdwWindowTitle" id="title">
+ <style>
+ <class name="numeric"/>
+ </style>
+ </object>
+ </property>
+ <child type="end">
+ <object class="GtkMenuButton" id="extra_menu_button">
+ <property name="visible">False</property>
+ <property name="icon-name">view-more-symbolic</property>
+ <property name="primary">True</property>
+ </object>
+ </child>
+ </object>
+ </child>
+ <child>
+ <object class="GtkSearchBar" id="search_bar">
+ <property name="search-mode-enabled" bind-source="search_button" bind-property="active"
bind-flags="bidirectional"/>
+ <property name="key-capture-widget">overview</property>
+ <property name="child">
+ <object class="AdwClamp">
+ <property name="hexpand">True</property>
+ <property name="maximum-size">400</property>
+ <property name="child">
+ <object class="GtkSearchEntry" id="search_entry">
+ <property name="hexpand">True</property>
+ <property name="placeholder-text" translatable="yes">Search tabs</property>
+ <signal name="search-changed" handler="search_changed_cb" swapped="yes"/>
+ <signal name="stop-search" handler="stop_search_cb" swapped="yes"/>
+ </object>
+ </property>
+ </object>
+ </property>
+ </object>
+ </child>
+ <child>
+ <object class="GtkOverlay">
+ <property name="vexpand">True</property>
+ <property name="child">
+ <object class="GtkStack" id="stack">
+ <child>
+ <object class="GtkStackPage">
+ <property name="name">tabs</property>
+ <property name="child">
+ <object class="GtkScrolledWindow" id="scrolled_window">
+ <property name="hscrollbar-policy">never</property>
+ <property name="child">
+ <object class="AdwTabOverviewScrollable" id="scrollable">
+ <property name="overview">overview</property>
+ <property name="new-button">new_tab_button</property>
+ <property name="pinned-grid">
+ <object class="AdwTabGrid" id="pinned_grid">
+ <property name="pinned">True</property>
+ <property name="tab-overview">AdwTabOverview</property>
+ <signal name="extra-drag-drop" handler="extra_drag_drop_cb" swapped="yes"/>
+ <signal name="notify::empty" handler="empty_changed_cb" swapped="yes"/>
+ </object>
+ </property>
+ <property name="grid">
+ <object class="AdwTabGrid" id="grid">
+ <property name="tab-overview">AdwTabOverview</property>
+ <signal name="extra-drag-drop" handler="extra_drag_drop_cb" swapped="yes"/>
+ <signal name="notify::empty" handler="empty_changed_cb" swapped="yes"/>
+ </object>
+ </property>
+ </object>
+ </property>
+ </object>
+ </property>
+ </object>
+ </child>
+ <child>
+ <object class="GtkStackPage">
+ <property name="name">empty</property>
+ <property name="child">
+ <object class="AdwStatusPage" id="search_empty">
+ <property name="icon-name">edit-find-symbolic</property>
+ <property name="title" translatable="yes">No Tabs Found</property>
+ <property name="description" translatable="yes">Try a different search.</property>
+ </object>
+ </property>
+ </object>
+ </child>
+ </object>
+ </property>
+ <child type="overlay">
+ <object class="GtkButton" id="new_tab_button">
+ <property name="visible">False</property>
+ <property name="halign">center</property>
+ <property name="valign">end</property>
+ <signal name="notify::action-name" handler="notify_action_name_cb" swapped="yes"/>
+ <signal name="notify::action-target" handler="notify_action_target_cb" swapped="yes"/>
+ <signal name="clicked" handler="new_tab_clicked_cb" swapped="yes"/>
+ <property name="child">
+ <object class="AdwButtonContent">
+ <property name="icon-name">tab-new-symbolic</property>
+ <property name="label" translatable="yes">New _Tab</property>
+ <property name="use-underline">True</property>
+ </object>
+ </property>
+ <style>
+ <class name="pill"/>
+ <class name="suggested-action"/>
+ <class name="new-tab-button"/>
+ </style>
+ </object>
+ </child>
+ </object>
+ </child>
+ </object>
+ </child>
+ </template>
+</interface>
diff --git a/src/adw-tab-thumbnail-private.h b/src/adw-tab-thumbnail-private.h
new file mode 100644
index 00000000..c5c4f260
--- /dev/null
+++ b/src/adw-tab-thumbnail-private.h
@@ -0,0 +1,56 @@
+/*
+ * Copyright (C) 2020 Purism SPC
+ *
+ * SPDX-License-Identifier: LGPL-2.1-or-later
+ *
+ * Author: Alexander Mikhaylenko <alexander mikhaylenko puri sm>
+ */
+
+#pragma once
+
+#if !defined(_ADWAITA_INSIDE) && !defined(ADWAITA_COMPILATION)
+#error "Only <adwaita.h> can be included directly."
+#endif
+
+#include <gtk/gtk.h>
+
+#include "adw-tab-view.h"
+
+G_BEGIN_DECLS
+
+#define ADW_TYPE_TAB_THUMBNAIL (adw_tab_thumbnail_get_type())
+
+G_DECLARE_FINAL_TYPE (AdwTabThumbnail, adw_tab_thumbnail, ADW, TAB_THUMBNAIL, GtkWidget)
+
+AdwTabThumbnail *adw_tab_thumbnail_new (AdwTabView *view,
+ gboolean pinned) G_GNUC_WARN_UNUSED_RESULT;
+
+AdwTabPage *adw_tab_thumbnail_get_page (AdwTabThumbnail *self);
+void adw_tab_thumbnail_set_page (AdwTabThumbnail *self,
+ AdwTabPage *page);
+
+gboolean adw_tab_thumbnail_get_dragging (AdwTabThumbnail *self);
+void adw_tab_thumbnail_set_dragging (AdwTabThumbnail *self,
+ gboolean dragging);
+
+gboolean adw_tab_thumbnail_get_inverted (AdwTabThumbnail *self);
+void adw_tab_thumbnail_set_inverted (AdwTabThumbnail *self,
+ gboolean inverted);
+
+void adw_tab_thumbnail_set_fully_visible (AdwTabThumbnail *self,
+ gboolean fully_visible);
+
+void adw_tab_thumbnail_set_align (AdwTabThumbnail *self,
+ float xalign,
+ float yalign);
+
+void adw_tab_thumbnail_setup_extra_drop_target (AdwTabThumbnail *self,
+ GdkDragAction actions,
+ GType *types,
+ gsize n_types);
+
+GtkWidget *adw_tab_thumbnail_get_thumbnail (AdwTabThumbnail *self);
+
+void adw_tab_thumbnail_fade_out (AdwTabThumbnail *self);
+
+G_END_DECLS
diff --git a/src/adw-tab-thumbnail.c b/src/adw-tab-thumbnail.c
new file mode 100644
index 00000000..43ea06fa
--- /dev/null
+++ b/src/adw-tab-thumbnail.c
@@ -0,0 +1,874 @@
+/*
+ * Copyright (C) 2021 Purism SPC
+ *
+ * SPDX-License-Identifier: LGPL-2.1-or-later
+ *
+ * Author: Alexander Mikhaylenko <alexander mikhaylenko puri sm>
+ */
+
+#include "config.h"
+#include "adw-tab-thumbnail-private.h"
+
+#include "adw-fading-label-private.h"
+#include "adw-macros-private.h"
+#include "adw-timed-animation.h"
+
+#define MIN_ASPECT_RATIO 0.8
+#define MAX_ASPECT_RATIO 2.7
+
+#define ADW_TYPE_TAB_PAINTABLE (adw_tab_paintable_get_type ())
+
+G_DECLARE_FINAL_TYPE (AdwTabPaintable, adw_tab_paintable, ADW, TAB_PAINTABLE, GObject)
+
+struct _AdwTabPaintable
+{
+ GObject parent_instance;
+
+ GtkWidget *view;
+ GtkWidget *child;
+
+ GdkPaintable *view_paintable;
+ GdkPaintable *cached_paintable;
+
+ float xalign;
+ float yalign;
+
+ GdkRGBA cached_bg;
+ gboolean schedule_clear_cache;
+ gboolean frozen;
+};
+
+static double
+adw_tab_paintable_get_intrinsic_aspect_ratio (GdkPaintable *paintable)
+{
+ AdwTabPaintable *self = ADW_TAB_PAINTABLE (paintable);
+ int width = gtk_widget_get_width (self->view);
+ int height = gtk_widget_get_height (self->view);
+ double ratio = (double) width / height;
+
+ return CLAMP (ratio, MIN_ASPECT_RATIO, MAX_ASPECT_RATIO);
+}
+
+static void
+snapshot_paintable (GtkSnapshot *snapshot,
+ double width,
+ double height,
+ GdkPaintable *paintable,
+ double xalign,
+ double yalign)
+{
+ double snapshot_ratio = width / height;
+ double paintable_ratio = gdk_paintable_get_intrinsic_aspect_ratio (paintable);
+
+ if (paintable_ratio > snapshot_ratio) {
+ double new_width = height * paintable_ratio;
+
+ gtk_snapshot_translate (snapshot,
+ &GRAPHENE_POINT_INIT ((float) (width - new_width) * xalign, 0));
+
+ width = new_width;
+ } if (paintable_ratio < snapshot_ratio) {
+ double new_height = width / paintable_ratio;
+
+ gtk_snapshot_translate (snapshot,
+ &GRAPHENE_POINT_INIT (0, (float) (height - new_height) * yalign));
+
+ height = new_height;
+ }
+
+ gdk_paintable_snapshot (paintable, snapshot, width, height);
+}
+
+static GdkPaintable *
+adw_tab_paintable_get_current_image (GdkPaintable *paintable)
+{
+ AdwTabPaintable *self = ADW_TAB_PAINTABLE (paintable);
+ GtkSnapshot *snapshot = gtk_snapshot_new ();
+ int w = gtk_widget_get_width (self->view);
+ int h = gtk_widget_get_height (self->view);
+
+ gdk_paintable_snapshot (paintable, GDK_SNAPSHOT (snapshot), w, h);
+
+ return gtk_snapshot_free_to_paintable (snapshot,
+ &GRAPHENE_SIZE_INIT (w, h));
+}
+
+static void
+get_background_color (AdwTabPaintable *self,
+ GdkRGBA *rgba)
+{
+ GtkStyleContext *context = gtk_widget_get_style_context (self->view);
+
+ if (gtk_style_context_lookup_color (context, "window_bg_color", rgba))
+ return;
+
+ rgba->red = 1;
+ rgba->green = 1;
+ rgba->blue = 1;
+ rgba->alpha = 1;
+}
+
+static void
+adw_tab_paintable_snapshot (GdkPaintable *paintable,
+ GdkSnapshot *snapshot,
+ double width,
+ double height)
+{
+ AdwTabPaintable *self = ADW_TAB_PAINTABLE (paintable);
+ GdkRGBA bg;
+ double xalign = self->xalign;
+
+ if (gtk_widget_get_direction (self->view) == GTK_TEXT_DIR_RTL)
+ xalign = 1 - xalign;
+
+ if (self->cached_paintable) {
+ gtk_snapshot_append_color (GTK_SNAPSHOT (snapshot), &self->cached_bg,
+ &GRAPHENE_RECT_INIT (0, 0, width, height));
+
+ snapshot_paintable (GTK_SNAPSHOT (snapshot), width, height,
+ self->cached_paintable, xalign, self->yalign);
+
+ return;
+ }
+
+ if (!gtk_widget_get_mapped (self->child))
+ return;
+
+ get_background_color (self, &bg);
+ gtk_snapshot_append_color (GTK_SNAPSHOT (snapshot), &bg,
+ &GRAPHENE_RECT_INIT (0, 0, width, height));
+
+ snapshot_paintable (GTK_SNAPSHOT (snapshot), width, height,
+ self->view_paintable, xalign, self->yalign);
+}
+
+static void
+adw_tab_paintable_iface_init (GdkPaintableInterface *iface)
+{
+ iface->get_intrinsic_aspect_ratio = adw_tab_paintable_get_intrinsic_aspect_ratio;
+ iface->get_current_image = adw_tab_paintable_get_current_image;
+ iface->snapshot = adw_tab_paintable_snapshot;
+}
+
+G_DEFINE_FINAL_TYPE_WITH_CODE (AdwTabPaintable, adw_tab_paintable, G_TYPE_OBJECT,
+ G_IMPLEMENT_INTERFACE (GDK_TYPE_PAINTABLE, adw_tab_paintable_iface_init))
+
+static void
+adw_tab_paintable_dispose (GObject *object)
+{
+ AdwTabPaintable *self = ADW_TAB_PAINTABLE (object);
+
+ g_clear_object (&self->view_paintable);
+ g_clear_object (&self->cached_paintable);
+
+ G_OBJECT_CLASS (adw_tab_paintable_parent_class)->dispose (object);
+}
+
+static void
+adw_tab_paintable_class_init (AdwTabPaintableClass *klass)
+{
+ GObjectClass *object_class = G_OBJECT_CLASS (klass);
+
+ object_class->dispose = adw_tab_paintable_dispose;
+}
+
+static void
+adw_tab_paintable_init (AdwTabPaintable *self)
+{
+}
+
+static void
+invalidate_contents_cb (AdwTabPaintable *self)
+{
+ gdk_paintable_invalidate_contents (GDK_PAINTABLE (self));
+
+ if (self->schedule_clear_cache) {
+ g_clear_object (&self->cached_paintable);
+ self->schedule_clear_cache = FALSE;
+ }
+}
+
+static void
+child_map_cb (AdwTabPaintable *self)
+{
+ if (self->frozen)
+ return;
+
+ if (self->cached_paintable)
+ self->schedule_clear_cache = TRUE;
+}
+
+static void
+child_unmap_cb (AdwTabPaintable *self)
+{
+ if (self->frozen || self->cached_paintable)
+ return;
+
+ g_clear_object (&self->cached_paintable);
+ self->cached_paintable = gdk_paintable_get_current_image (self->view_paintable);
+ get_background_color (self, &self->cached_bg);
+}
+
+static GdkPaintable *
+adw_tab_paintable_new (AdwTabView *view,
+ AdwTabPage *page)
+{
+ AdwTabPaintable *self = g_object_new (ADW_TYPE_TAB_PAINTABLE, NULL);
+
+ self->view = GTK_WIDGET (view);
+ self->child = adw_tab_page_get_child (page);
+ self->xalign = 0.0;
+ self->yalign = 0.0;
+
+ self->view_paintable = gtk_widget_paintable_new (self->view);
+
+ g_signal_connect_swapped (self->view_paintable, "invalidate-contents", G_CALLBACK
(invalidate_contents_cb), self);
+ g_signal_connect_swapped (self->view_paintable, "invalidate-size", G_CALLBACK
(gdk_paintable_invalidate_size), self);
+
+ g_signal_connect_swapped (self->child, "map", G_CALLBACK (child_map_cb), self);
+ g_signal_connect_swapped (self->child, "unmap", G_CALLBACK (child_unmap_cb), self);
+
+ return GDK_PAINTABLE (self);
+}
+
+static void
+adw_tab_paintable_set_align (AdwTabPaintable *self,
+ float xalign,
+ float yalign)
+{
+ g_assert (ADW_IS_TAB_PAINTABLE (self));
+
+ self->xalign = xalign;
+ self->yalign = yalign;
+
+ gdk_paintable_invalidate_contents (GDK_PAINTABLE (self));
+}
+
+static void
+adw_tab_paintable_freeze (AdwTabPaintable *self)
+{
+ // FIXME need to do it before closing
+ child_unmap_cb (self);
+ self->schedule_clear_cache = FALSE;
+ self->frozen = TRUE;
+}
+
+
+
+
+
+
+
+
+
+#define FADE_TRANSITION_DURATION 150
+
+struct _AdwTabThumbnail
+{
+ GtkWidget parent_instance;
+
+ GtkWidget *contents;
+ GtkWidget *icon_title_box;
+ GtkWidget *overlay;
+ GtkPicture *picture;
+ GtkWidget *icon_stack;
+ GtkImage *icon;
+ GtkSpinner *spinner;
+ GtkImage *indicator_icon;
+ GtkWidget *indicator_btn;
+ GtkWidget *close_btn;
+ GtkWidget *unpin_btn;
+ GtkDropTarget *drop_target;
+
+ AdwTabView *view;
+ AdwTabPage *page;
+ gboolean pinned;
+ gboolean dragging;
+
+ gboolean inverted;
+
+ AdwAnimation *fade_animation;
+};
+
+G_DEFINE_FINAL_TYPE (AdwTabThumbnail, adw_tab_thumbnail, GTK_TYPE_WIDGET)
+
+enum {
+ PROP_0,
+ PROP_VIEW,
+ PROP_PINNED,
+ PROP_DRAGGING,
+ PROP_PAGE,
+ PROP_INVERTED,
+ LAST_PROP
+};
+
+static GParamSpec *props[LAST_PROP];
+
+enum {
+ SIGNAL_EXTRA_DRAG_DROP,
+ SIGNAL_LAST_SIGNAL,
+};
+
+static guint signals[SIGNAL_LAST_SIGNAL];
+
+static inline void
+set_style_class (GtkWidget *widget,
+ const char *style_class,
+ gboolean enabled)
+{
+ if (enabled)
+ gtk_widget_add_css_class (widget, style_class);
+ else
+ gtk_widget_remove_css_class (widget, style_class);
+}
+
+static void
+update_tooltip (AdwTabThumbnail *self)
+{
+ AdwTabPage *page = adw_tab_thumbnail_get_page (ADW_TAB_THUMBNAIL (self));
+ const char *tooltip = adw_tab_page_get_tooltip (page);
+
+ if (tooltip && g_strcmp0 (tooltip, "") != 0)
+ gtk_widget_set_tooltip_markup (GTK_WIDGET (self), tooltip);
+ else
+ gtk_widget_set_tooltip_text (GTK_WIDGET (self),
+ adw_tab_page_get_title (page));
+}
+
+static void
+update_spinner (AdwTabThumbnail *self)
+{
+ gboolean loading = self->page && adw_tab_page_get_loading (self->page);
+ gboolean mapped = gtk_widget_get_mapped (GTK_WIDGET (self));
+
+ /* Don't use CPU when not needed */
+ gtk_spinner_set_spinning (self->spinner, loading && mapped);
+}
+
+static void
+update_icon (AdwTabThumbnail *self)
+{
+ GIcon *gicon = adw_tab_page_get_icon (self->page);
+ gboolean loading = adw_tab_page_get_loading (self->page);
+ const char *name = loading ? "spinner" : "icon";
+
+ gtk_image_set_from_gicon (self->icon, gicon);
+ gtk_widget_set_visible (self->icon_stack,
+ (gicon != NULL || loading));
+ gtk_stack_set_visible_child_name (GTK_STACK (self->icon_stack), name);
+}
+
+static void
+update_loading (AdwTabThumbnail *self)
+{
+ update_icon (self);
+ update_spinner (self);
+ set_style_class (GTK_WIDGET (self), "loading",
+ adw_tab_page_get_loading (self->page));
+}
+
+static void
+update_indicator (AdwTabThumbnail *self)
+{
+ GIcon *indicator = adw_tab_page_get_indicator_icon (self->page);
+ gboolean activatable = self->page && adw_tab_page_get_indicator_activatable (self->page);
+
+ gtk_image_set_from_gicon (self->indicator_icon, indicator);
+ gtk_widget_set_visible (self->indicator_btn, indicator != NULL);
+ gtk_widget_set_can_target (self->indicator_btn, activatable);
+
+ set_style_class (GTK_WIDGET (self), "indicator", indicator != NULL);
+}
+
+static gboolean
+close_idle_cb (AdwTabThumbnail *self)
+{
+ adw_tab_view_close_page (self->view, self->page);
+
+ return G_SOURCE_REMOVE;
+}
+
+static void
+close_clicked_cb (AdwTabThumbnail *self)
+{
+ if (!self->page)
+ return;
+
+ /* When animations are disabled, we don't want to immediately remove the
+ * whole tab mid-click. Instead, defer it until the click has happened.
+ */
+ g_idle_add ((GSourceFunc) close_idle_cb, self);
+}
+
+static gboolean
+unpin_idle_cb (AdwTabThumbnail *self)
+{
+ adw_tab_view_set_page_pinned (self->view, self->page, FALSE);
+
+ return G_SOURCE_REMOVE;
+}
+
+static void
+unpin_clicked_cb (AdwTabThumbnail *self)
+{
+ if (!self->page)
+ return;
+
+ /* When animations are disabled, we don't want to immediately unpin the
+ * whole tab mid-click. Instead, defer it until the click has happened.
+ */
+ g_idle_add ((GSourceFunc) unpin_idle_cb, self);
+}
+
+static void
+indicator_clicked_cb (AdwTabThumbnail *self)
+{
+ if (!self->page)
+ return;
+
+ g_signal_emit_by_name (self->view, "indicator-activated", self->page);
+}
+
+static gboolean
+drop_cb (AdwTabThumbnail *self,
+ GValue *value)
+{
+ gboolean ret = GDK_EVENT_PROPAGATE;
+
+ g_signal_emit (self, signals[SIGNAL_EXTRA_DRAG_DROP], 0, value, &ret);
+
+ return ret;
+}
+
+static void
+fade_animation_value_cb (double value,
+ AdwTabThumbnail *self)
+{
+ if (self->pinned) {
+ gtk_widget_set_opacity (self->unpin_btn, value);
+ gtk_widget_set_opacity (self->icon_title_box, value);
+ } else {
+ gtk_widget_set_opacity (self->close_btn, value);
+ }
+
+ gtk_widget_set_opacity (self->indicator_btn, value);
+}
+
+static void
+adw_tab_thumbnail_map (GtkWidget *widget)
+{
+ AdwTabThumbnail *self = ADW_TAB_THUMBNAIL (widget);
+
+ GTK_WIDGET_CLASS (adw_tab_thumbnail_parent_class)->map (widget);
+
+ update_spinner (self);
+}
+
+static void
+adw_tab_thumbnail_unmap (GtkWidget *widget)
+{
+ AdwTabThumbnail *self = ADW_TAB_THUMBNAIL (widget);
+
+ GTK_WIDGET_CLASS (adw_tab_thumbnail_parent_class)->unmap (widget);
+
+ update_spinner (self);
+}
+
+static void
+adw_tab_thumbnail_constructed (GObject *object)
+{
+ AdwTabThumbnail *self = ADW_TAB_THUMBNAIL (object);
+
+ G_OBJECT_CLASS (adw_tab_thumbnail_parent_class)->constructed (object);
+
+ gtk_widget_set_visible (self->unpin_btn, self->pinned);
+ gtk_widget_set_visible (self->close_btn, !self->pinned);
+
+ if (self->pinned) {
+ gtk_widget_add_css_class (GTK_WIDGET (self), "pinned");
+
+ g_object_ref (self->icon_title_box);
+
+ gtk_box_remove (GTK_BOX (self->contents), self->icon_title_box);
+ gtk_overlay_add_overlay (GTK_OVERLAY (self->overlay), self->icon_title_box);
+
+ g_object_unref (self->icon_title_box);
+
+ gtk_overlay_set_measure_overlay (GTK_OVERLAY (self->overlay),
+ self->icon_title_box, TRUE);
+ gtk_widget_set_halign (self->icon_title_box, GTK_ALIGN_FILL);
+
+ gtk_widget_hide (GTK_WIDGET (self->picture));
+ }
+}
+
+static void
+adw_tab_thumbnail_dispose (GObject *object)
+{
+ AdwTabThumbnail *self = ADW_TAB_THUMBNAIL (object);
+
+ adw_tab_thumbnail_set_page (self, NULL);
+
+ g_clear_object (&self->fade_animation);
+
+ if (self->contents)
+ gtk_widget_unparent (self->contents);
+
+ G_OBJECT_CLASS (adw_tab_thumbnail_parent_class)->dispose (object);
+}
+
+static void
+adw_tab_thumbnail_get_property (GObject *object,
+ guint prop_id,
+ GValue *value,
+ GParamSpec *pspec)
+{
+ AdwTabThumbnail *self = ADW_TAB_THUMBNAIL (object);
+
+ switch (prop_id) {
+ case PROP_VIEW:
+ g_value_set_object (value, self->view);
+ break;
+
+ case PROP_PAGE:
+ g_value_set_object (value, adw_tab_thumbnail_get_page (self));
+ break;
+
+ case PROP_PINNED:
+ g_value_set_boolean (value, self->pinned);
+ break;
+
+ case PROP_DRAGGING:
+ g_value_set_boolean (value, adw_tab_thumbnail_get_dragging (self));
+ break;
+
+ case PROP_INVERTED:
+ g_value_set_boolean (value, adw_tab_thumbnail_get_inverted (self));
+ break;
+
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+ }
+}
+
+static void
+adw_tab_thumbnail_set_property (GObject *object,
+ guint prop_id,
+ const GValue *value,
+ GParamSpec *pspec)
+{
+ AdwTabThumbnail *self = ADW_TAB_THUMBNAIL (object);
+
+ switch (prop_id) {
+ case PROP_VIEW:
+ self->view = g_value_get_object (value);
+ break;
+
+ case PROP_PAGE:
+ adw_tab_thumbnail_set_page (self, g_value_get_object (value));
+ break;
+
+ case PROP_PINNED:
+ self->pinned = g_value_get_boolean (value);
+ break;
+
+ case PROP_DRAGGING:
+ adw_tab_thumbnail_set_dragging (self, g_value_get_boolean (value));
+ break;
+
+ case PROP_INVERTED:
+ adw_tab_thumbnail_set_inverted (self, g_value_get_boolean (value));
+ break;
+
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+ }
+}
+
+static void
+adw_tab_thumbnail_class_init (AdwTabThumbnailClass *klass)
+{
+ GObjectClass *object_class = G_OBJECT_CLASS (klass);
+ GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
+
+ object_class->dispose = adw_tab_thumbnail_dispose;
+ object_class->constructed = adw_tab_thumbnail_constructed;
+ object_class->get_property = adw_tab_thumbnail_get_property;
+ object_class->set_property = adw_tab_thumbnail_set_property;
+
+ widget_class->map = adw_tab_thumbnail_map;
+ widget_class->unmap = adw_tab_thumbnail_unmap;
+
+ props[PROP_VIEW] =
+ g_param_spec_object ("view", NULL, NULL,
+ ADW_TYPE_TAB_VIEW,
+ G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS);
+
+ props[PROP_PINNED] =
+ g_param_spec_boolean ("pinned", NULL, NULL,
+ FALSE,
+ G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS);
+
+ props[PROP_DRAGGING] =
+ g_param_spec_boolean ("dragging", NULL, NULL,
+ FALSE,
+ G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS | G_PARAM_EXPLICIT_NOTIFY);
+
+ props[PROP_PAGE] =
+ g_param_spec_object ("page", NULL, NULL,
+ ADW_TYPE_TAB_PAGE,
+ G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS | G_PARAM_EXPLICIT_NOTIFY);
+
+ props[PROP_INVERTED] =
+ g_param_spec_boolean ("inverted", NULL, NULL,
+ FALSE,
+ G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS | G_PARAM_EXPLICIT_NOTIFY);
+
+ g_object_class_install_properties (object_class, LAST_PROP, props);
+
+ signals[SIGNAL_EXTRA_DRAG_DROP] =
+ g_signal_new ("extra-drag-drop",
+ G_TYPE_FROM_CLASS (klass),
+ G_SIGNAL_RUN_LAST,
+ 0,
+ g_signal_accumulator_first_wins, NULL, NULL,
+ G_TYPE_BOOLEAN,
+ 1,
+ G_TYPE_VALUE);
+
+ gtk_widget_class_set_template_from_resource (widget_class,
+ "/org/gnome/Adwaita/ui/adw-tab-thumbnail.ui");
+ gtk_widget_class_bind_template_child (widget_class, AdwTabThumbnail, contents);
+ gtk_widget_class_bind_template_child (widget_class, AdwTabThumbnail, overlay);
+ gtk_widget_class_bind_template_child (widget_class, AdwTabThumbnail, icon_title_box);
+ gtk_widget_class_bind_template_child (widget_class, AdwTabThumbnail, picture);
+ gtk_widget_class_bind_template_child (widget_class, AdwTabThumbnail, icon_stack);
+ gtk_widget_class_bind_template_child (widget_class, AdwTabThumbnail, icon);
+ gtk_widget_class_bind_template_child (widget_class, AdwTabThumbnail, spinner);
+ gtk_widget_class_bind_template_child (widget_class, AdwTabThumbnail, indicator_icon);
+ gtk_widget_class_bind_template_child (widget_class, AdwTabThumbnail, indicator_btn);
+ gtk_widget_class_bind_template_child (widget_class, AdwTabThumbnail, close_btn);
+ gtk_widget_class_bind_template_child (widget_class, AdwTabThumbnail, unpin_btn);
+ gtk_widget_class_bind_template_child (widget_class, AdwTabThumbnail, drop_target);
+ gtk_widget_class_bind_template_callback (widget_class, close_clicked_cb);
+ gtk_widget_class_bind_template_callback (widget_class, unpin_clicked_cb);
+ gtk_widget_class_bind_template_callback (widget_class, indicator_clicked_cb);
+ gtk_widget_class_bind_template_callback (widget_class, drop_cb);
+
+ gtk_widget_class_set_layout_manager_type (widget_class, GTK_TYPE_BIN_LAYOUT);
+ gtk_widget_class_set_css_name (widget_class, "tabthumbnail");
+
+ g_type_ensure (ADW_TYPE_FADING_LABEL);
+}
+
+static void
+adw_tab_thumbnail_init (AdwTabThumbnail *self)
+{
+ AdwAnimationTarget *target;
+
+ gtk_widget_init_template (GTK_WIDGET (self));
+
+ gtk_widget_set_overflow (GTK_WIDGET (self), GTK_OVERFLOW_HIDDEN);
+
+ target = adw_callback_animation_target_new ((AdwAnimationTargetFunc) fade_animation_value_cb,
+ self, NULL);
+
+ self->fade_animation = adw_timed_animation_new (GTK_WIDGET (self),
+ 0, 1,
+ FADE_TRANSITION_DURATION,
+ target);
+}
+
+AdwTabThumbnail *
+adw_tab_thumbnail_new (AdwTabView *view,
+ gboolean pinned)
+{
+ g_return_val_if_fail (ADW_IS_TAB_VIEW (view), NULL);
+
+ return g_object_new (ADW_TYPE_TAB_THUMBNAIL,
+ "view", view,
+ "pinned", pinned,
+ NULL);
+}
+
+AdwTabPage *
+adw_tab_thumbnail_get_page (AdwTabThumbnail *self)
+{
+ g_return_val_if_fail (ADW_IS_TAB_THUMBNAIL (self), NULL);
+
+ return self->page;
+}
+
+void
+adw_tab_thumbnail_set_page (AdwTabThumbnail *self,
+ AdwTabPage *page)
+{
+ g_return_if_fail (ADW_IS_TAB_THUMBNAIL (self));
+ g_return_if_fail (page == NULL || ADW_IS_TAB_PAGE (page));
+
+ if (self->page == page)
+ return;
+
+ if (self->page) {
+ GdkPaintable *paintable = gtk_picture_get_paintable (GTK_PICTURE (self->picture));
+
+ g_assert (ADW_IS_TAB_PAINTABLE (paintable));
+
+ adw_tab_paintable_freeze (ADW_TAB_PAINTABLE (paintable));
+
+ g_signal_handlers_disconnect_by_func (self->page, update_tooltip, self);
+ g_signal_handlers_disconnect_by_func (self->page, update_icon, self);
+ g_signal_handlers_disconnect_by_func (self->page, update_indicator, self);
+ g_signal_handlers_disconnect_by_func (self->page, update_loading, self);
+ }
+
+ g_set_object (&self->page, page);
+
+ if (self->page) {
+ gtk_picture_set_paintable (GTK_PICTURE (self->picture),
+ adw_tab_paintable_new (self->view, self->page));
+
+ update_tooltip (self);
+ update_spinner (self);
+ update_icon (self);
+ update_indicator (self);
+ update_loading (self);
+
+ g_signal_connect_object (self->page, "notify::title",
+ G_CALLBACK (update_tooltip), self,
+ G_CONNECT_SWAPPED);
+ g_signal_connect_object (self->page, "notify::tooltip",
+ G_CALLBACK (update_tooltip), self,
+ G_CONNECT_SWAPPED);
+ g_signal_connect_object (self->page, "notify::icon",
+ G_CALLBACK (update_icon), self,
+ G_CONNECT_SWAPPED);
+ g_signal_connect_object (self->page, "notify::indicator-icon",
+ G_CALLBACK (update_indicator), self,
+ G_CONNECT_SWAPPED);
+ g_signal_connect_object (self->page, "notify::indicator-activatable",
+ G_CALLBACK (update_indicator), self,
+ G_CONNECT_SWAPPED);
+ g_signal_connect_object (self->page, "notify::loading",
+ G_CALLBACK (update_loading), self,
+ G_CONNECT_SWAPPED);
+ }
+
+ g_object_notify_by_pspec (G_OBJECT (self), props[PROP_PAGE]);
+}
+
+gboolean
+adw_tab_thumbnail_get_dragging (AdwTabThumbnail *self)
+{
+ g_return_val_if_fail (ADW_IS_TAB_THUMBNAIL (self), FALSE);
+
+ return self->dragging;
+}
+
+void
+adw_tab_thumbnail_set_dragging (AdwTabThumbnail *self,
+ gboolean dragging)
+{
+ g_return_if_fail (ADW_IS_TAB_THUMBNAIL (self));
+
+ dragging = !!dragging;
+
+ if (self->dragging == dragging)
+ return;
+
+ self->dragging = dragging;
+
+// update_state (self);
+// update_selected (self);
+
+ g_object_notify_by_pspec (G_OBJECT (self), props[PROP_DRAGGING]);
+}
+
+gboolean
+adw_tab_thumbnail_get_inverted (AdwTabThumbnail *self)
+{
+ g_return_val_if_fail (ADW_IS_TAB_THUMBNAIL (self), FALSE);
+
+ return self->inverted;
+}
+
+void
+adw_tab_thumbnail_set_inverted (AdwTabThumbnail *self,
+ gboolean inverted)
+{
+ g_return_if_fail (ADW_IS_TAB_THUMBNAIL (self));
+
+ inverted = !!inverted;
+
+ if (self->inverted == inverted)
+ return;
+
+ self->inverted = inverted;
+
+ if (inverted) {
+ gtk_widget_set_halign (self->close_btn, GTK_ALIGN_START);
+ gtk_widget_set_halign (self->unpin_btn, GTK_ALIGN_START);
+ gtk_widget_set_halign (self->indicator_btn, GTK_ALIGN_END);
+ } else {
+ gtk_widget_set_halign (self->close_btn, GTK_ALIGN_END);
+ gtk_widget_set_halign (self->unpin_btn, GTK_ALIGN_END);
+ gtk_widget_set_halign (self->indicator_btn, GTK_ALIGN_START);
+ }
+
+ gtk_widget_queue_allocate (GTK_WIDGET (self->overlay));
+
+ g_object_notify_by_pspec (G_OBJECT (self), props[PROP_INVERTED]);
+}
+
+void
+adw_tab_thumbnail_set_fully_visible (AdwTabThumbnail *self,
+ gboolean fully_visible)
+{
+ // TODO
+}
+
+void
+adw_tab_thumbnail_set_align (AdwTabThumbnail *self,
+ float xalign,
+ float yalign)
+{
+ GdkPaintable *paintable;
+
+ g_return_if_fail (ADW_IS_TAB_THUMBNAIL (self));
+
+ paintable = gtk_picture_get_paintable (self->picture);
+
+ g_assert (ADW_IS_TAB_PAINTABLE (paintable));
+
+ adw_tab_paintable_set_align (ADW_TAB_PAINTABLE (paintable), xalign, yalign);
+}
+
+void
+adw_tab_thumbnail_setup_extra_drop_target (AdwTabThumbnail *self,
+ GdkDragAction actions,
+ GType *types,
+ gsize n_types)
+{
+ g_return_if_fail (ADW_IS_TAB_THUMBNAIL (self));
+ g_return_if_fail (n_types == 0 || types != NULL);
+
+ gtk_drop_target_set_actions (self->drop_target, actions);
+ gtk_drop_target_set_gtypes (self->drop_target, types, n_types);
+}
+
+GtkWidget *
+adw_tab_thumbnail_get_thumbnail (AdwTabThumbnail *self)
+{
+ g_return_val_if_fail (ADW_IS_TAB_THUMBNAIL (self), NULL);
+
+ return self->overlay;
+}
+
+void
+adw_tab_thumbnail_fade_out (AdwTabThumbnail *self)
+{
+ g_return_if_fail (ADW_IS_TAB_THUMBNAIL (self));
+
+ adw_animation_play (self->fade_animation);
+}
+
diff --git a/src/adw-tab-thumbnail.ui b/src/adw-tab-thumbnail.ui
new file mode 100644
index 00000000..17903e63
--- /dev/null
+++ b/src/adw-tab-thumbnail.ui
@@ -0,0 +1,136 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<interface domain="libadwaita">
+ <requires lib="gtk" version="4.0"/>
+ <template class="AdwTabThumbnail" parent="GtkWidget">
+ <child>
+ <object class="GtkDropTarget" id="drop_target">
+ <signal name="drop" handler="drop_cb" swapped="true"/>
+ </object>
+ </child>
+ <child>
+ <object class="GtkBox" id="contents">
+ <property name="orientation">vertical</property>
+ <property name="spacing">6</property>
+ <property name="vexpand">False</property>
+ <child>
+ <object class="GtkOverlay" id="overlay">
+ <property name="overflow">hidden</property>
+ <style>
+ <class name="card"/>
+ </style>
+ <property name="child">
+ <object class="GtkPicture" id="picture">
+ <property name="can-shrink">True</property>
+ <property name="keep-aspect-ratio">False</property>
+ <property name="vexpand">True</property>
+ </object>
+ </property>
+ <child type="overlay">
+ <object class="GtkButton" id="close_btn">
+ <property name="can-focus">False</property>
+ <property name="tooltip-text" translatable="yes">Close Tab</property>
+ <property name="icon-name">window-close-symbolic</property>
+ <property name="valign">start</property>
+ <property name="halign">end</property>
+ <signal name="clicked" handler="close_clicked_cb" swapped="true"/>
+ <layout>
+ <property name="measure">True</property>
+ </layout>
+ <style>
+ <class name="circular"/>
+ <class name="tab-close-button"/>
+ </style>
+ </object>
+ </child>
+ <child type="overlay">
+ <object class="GtkButton" id="unpin_btn">
+ <property name="can-focus">False</property>
+ <property name="tooltip-text" translatable="yes">Unpin Tab</property>
+ <property name="icon-name">adw-tab-unpin-symbolic</property>
+ <property name="valign">start</property>
+ <property name="halign">end</property>
+ <signal name="clicked" handler="unpin_clicked_cb" swapped="true"/>
+ <layout>
+ <property name="measure">True</property>
+ </layout>
+ <style>
+ <class name="circular"/>
+ <class name="tab-close-button"/>
+ </style>
+ </object>
+ </child>
+ <child type="overlay">
+ <object class="GtkButton" id="indicator_btn">
+ <property name="can-focus">False</property>
+ <property name="valign">start</property>
+ <property name="halign">start</property>
+ <binding name="tooltip-markup">
+ <lookup name="indicator-tooltip" type="AdwTabPage">
+ <lookup name="page">AdwTabThumbnail</lookup>
+ </lookup>
+ </binding>
+ <signal name="clicked" handler="indicator_clicked_cb" swapped="true"/>
+ <layout>
+ <property name="measure">True</property>
+ </layout>
+ <style>
+ <class name="circular"/>
+ <class name="tab-indicator"/>
+ <class name="image-button"/>
+ </style>
+ <property name="child">
+ <object class="GtkImage" id="indicator_icon"/>
+ </property>
+ </object>
+ </child>
+ </object>
+ </child>
+ <child>
+ <object class="GtkBox" id="icon_title_box">
+ <property name="can-target">False</property>
+ <property name="orientation">horizontal</property>
+ <property name="halign">center</property>
+ <style>
+ <class name="icon-title-box"/>
+ </style>
+ <child>
+ <object class="GtkStack" id="icon_stack">
+ <property name="margin-start">4</property>
+ <property name="margin-end">2</property>
+ <child>
+ <object class="GtkStackPage">
+ <property name="name">icon</property>
+ <property name="child">
+ <object class="GtkImage" id="icon">
+ <style>
+ <class name="tab-icon"/>
+ </style>
+ </object>
+ </property>
+ </object>
+ </child>
+ <child>
+ <object class="GtkStackPage">
+ <property name="name">spinner</property>
+ <property name="child">
+ <object class="GtkSpinner" id="spinner"/>
+ </property>
+ </object>
+ </child>
+ </object>
+ </child>
+ <child>
+ <object class="AdwFadingLabel">
+ <binding name="label">
+ <lookup name="title" type="AdwTabPage">
+ <lookup name="page">AdwTabThumbnail</lookup>
+ </lookup>
+ </binding>
+ </object>
+ </child>
+ </object>
+ </child>
+ </object>
+ </child>
+ </template>
+</interface>
diff --git a/src/adw-tab-view.c b/src/adw-tab-view.c
index 62f52537..a1eb2c65 100644
--- a/src/adw-tab-view.c
+++ b/src/adw-tab-view.c
@@ -127,6 +127,7 @@ struct _AdwTabPage
char *indicator_tooltip;
gboolean indicator_activatable;
gboolean needs_attention;
+ char *keyword;
gboolean closing;
};
@@ -147,6 +148,7 @@ enum {
PAGE_PROP_INDICATOR_TOOLTIP,
PAGE_PROP_INDICATOR_ACTIVATABLE,
PAGE_PROP_NEEDS_ATTENTION,
+ PAGE_PROP_KEYWORD,
LAST_PAGE_PROP
};
@@ -300,6 +302,7 @@ adw_tab_page_finalize (GObject *object)
g_clear_object (&self->icon);
g_clear_object (&self->indicator_icon);
g_clear_pointer (&self->indicator_tooltip, g_free);
+ g_clear_pointer (&self->keyword, g_free);
G_OBJECT_CLASS (adw_tab_page_parent_class)->finalize (object);
}
@@ -361,6 +364,10 @@ adw_tab_page_get_property (GObject *object,
g_value_set_boolean (value, adw_tab_page_get_needs_attention (self));
break;
+ case PAGE_PROP_KEYWORD:
+ g_value_set_string (value, adw_tab_page_get_keyword (self));
+ break;
+
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
}
@@ -415,6 +422,10 @@ adw_tab_page_set_property (GObject *object,
adw_tab_page_set_needs_attention (self, g_value_get_boolean (value));
break;
+ case PAGE_PROP_KEYWORD:
+ adw_tab_page_set_keyword (self, g_value_get_string (value));
+ break;
+
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
}
@@ -623,6 +634,18 @@ adw_tab_page_class_init (AdwTabPageClass *klass)
FALSE,
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS | G_PARAM_EXPLICIT_NOTIFY);
+ /**
+ * AdwTabPage:keyword: (attributes org.gtk.Property.get=adw_tab_page_get_keyword
org.gtk.Property.set=adw_tab_page_set_keyword)
+ *
+ * TODO
+ *
+ * Since: 1.3
+ */
+ page_props[PAGE_PROP_KEYWORD] =
+ g_param_spec_string ("keyword", NULL, NULL,
+ "",
+ G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS | G_PARAM_EXPLICIT_NOTIFY);
+
g_object_class_install_properties (object_class, LAST_PAGE_PROP, page_props);
}
@@ -2249,6 +2272,48 @@ adw_tab_page_set_needs_attention (AdwTabPage *self,
g_object_notify_by_pspec (G_OBJECT (self), page_props[PAGE_PROP_NEEDS_ATTENTION]);
}
+/**
+ * adw_tab_page_get_keyword: (attributes org.gtk.Method.get_property=keyword)
+ * @self: a tab page
+ *
+ * Gets the TODO of @self.
+ *
+ * Returns: (nullable): the tooltip of @self
+ *
+ * Since: 1.3
+ */
+const char *
+adw_tab_page_get_keyword (AdwTabPage *self)
+{
+ g_return_val_if_fail (ADW_IS_TAB_PAGE (self), NULL);
+
+ return self->keyword;
+}
+
+/**
+ * adw_tab_page_set_keyword: (attributes org.gtk.Method.set_property=keyword)
+ * @self: a tab page
+ * @keyword: the keyword of @self
+ *
+ * Sets the TODO of @self.
+ *
+ * Since: 1.3
+ */
+void
+adw_tab_page_set_keyword (AdwTabPage *self,
+ const char *keyword)
+{
+ g_return_if_fail (ADW_IS_TAB_PAGE (self));
+
+ if (!g_strcmp0 (keyword, self->keyword))
+ return;
+
+ g_clear_pointer (&self->keyword, g_free);
+ self->keyword = g_strdup (keyword);
+
+ g_object_notify_by_pspec (G_OBJECT (self), page_props[PAGE_PROP_KEYWORD]);
+}
+
/**
* adw_tab_view_new:
*
diff --git a/src/adw-tab-view.h b/src/adw-tab-view.h
index 4c1af2da..4db3471b 100644
--- a/src/adw-tab-view.h
+++ b/src/adw-tab-view.h
@@ -101,6 +101,12 @@ ADW_AVAILABLE_IN_ALL
void adw_tab_page_set_needs_attention (AdwTabPage *self,
gboolean needs_attention);
+ADW_AVAILABLE_IN_1_2
+const char *adw_tab_page_get_keyword (AdwTabPage *self);
+ADW_AVAILABLE_IN_1_2
+void adw_tab_page_set_keyword (AdwTabPage *self,
+ const char *keyword);
+
#define ADW_TYPE_TAB_VIEW (adw_tab_view_get_type())
ADW_AVAILABLE_IN_ALL
diff --git a/src/adwaita.gresources.xml b/src/adwaita.gresources.xml
index 095d250e..159fc0e7 100644
--- a/src/adwaita.gresources.xml
+++ b/src/adwaita.gresources.xml
@@ -11,6 +11,7 @@
<file preprocess="xml-stripblanks">icons/scalable/status/adw-tab-counter-symbolic.svg</file>
<file preprocess="xml-stripblanks">icons/scalable/status/adw-tab-icon-missing-symbolic.svg</file>
<file preprocess="xml-stripblanks">icons/scalable/status/adw-tab-overflow-symbolic.svg</file>
+ <file preprocess="xml-stripblanks">icons/scalable/status/adw-tab-unpin-symbolic.svg</file>
</gresource>
<gresource prefix="/org/gnome/Adwaita/ui">
<file preprocess="xml-stripblanks">adw-about-window.ui</file>
@@ -27,6 +28,8 @@
<file preprocess="xml-stripblanks">adw-tab.ui</file>
<file preprocess="xml-stripblanks">adw-tab-bar.ui</file>
<file preprocess="xml-stripblanks">adw-tab-button.ui</file>
+ <file preprocess="xml-stripblanks">adw-tab-overview.ui</file>
+ <file preprocess="xml-stripblanks">adw-tab-thumbnail.ui</file>
<file preprocess="xml-stripblanks">adw-toast-widget.ui</file>
<file preprocess="xml-stripblanks">adw-view-switcher-bar.ui</file>
<file preprocess="xml-stripblanks">adw-view-switcher-button.ui</file>
diff --git a/src/adwaita.h b/src/adwaita.h
index 6707b57c..9e277ded 100644
--- a/src/adwaita.h
+++ b/src/adwaita.h
@@ -65,6 +65,7 @@ G_BEGIN_DECLS
#include "adw-swipeable.h"
#include "adw-tab-bar.h"
#include "adw-tab-button.h"
+#include "adw-tab-overview.h"
#include "adw-tab-view.h"
#include "adw-timed-animation.h"
#include "adw-toast-overlay.h"
diff --git a/src/icons/scalable/status/adw-tab-unpin-symbolic.svg
b/src/icons/scalable/status/adw-tab-unpin-symbolic.svg
new file mode 100644
index 00000000..72ff9184
--- /dev/null
+++ b/src/icons/scalable/status/adw-tab-unpin-symbolic.svg
@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<svg xmlns="http://www.w3.org/2000/svg"; xmlns:xlink="http://www.w3.org/1999/xlink"; width="16px"
height="16px" viewBox="0 0 16 16" version="1.1">
+<g id="surface76827">
+<path style=" stroke:none;fill-rule:nonzero;fill:rgb(13.333334%,13.333334%,13.333334%);fill-opacity:1;" d="M
9 11 L 7 11 L 7 14 L 8 15 L 9 14 Z M 9 11 "/>
+<path style=" stroke:none;fill-rule:nonzero;fill:rgb(13.333334%,13.333334%,13.333334%);fill-opacity:1;" d="M
11.222656 2.292969 C 11.035156 2.105469 10.78125 2 10.515625 2 L 5.5 2 C 4.945312 2 4.5 2.449219 4.5 3 C 4.5
3.550781 4.945312 4 5.5 4 L 10.515625 4 C 11.066406 4 11.515625 3.550781 11.515625 3 C 11.515625 2.734375
11.410156 2.480469 11.222656 2.292969 Z M 11.222656 2.292969 "/>
+<path style=" stroke:none;fill-rule:nonzero;fill:rgb(13.333334%,13.333334%,13.333334%);fill-opacity:1;" d="M
4 10 C 4 7.789062 5.789062 6 8 6 C 10.210938 6 12 7.789062 12 10 Z M 4 10 "/>
+<path style=" stroke:none;fill-rule:nonzero;fill:rgb(13.333334%,13.333334%,13.333334%);fill-opacity:1;" d="M
5.441406 2.972656 L 6.335938 8.136719 L 9.710938 8.136719 L 10.558594 3.027344 Z M 5.441406 2.972656 "/>
+</g>
+</svg>
diff --git a/src/meson.build b/src/meson.build
index dd6536a0..e14484ca 100644
--- a/src/meson.build
+++ b/src/meson.build
@@ -126,6 +126,7 @@ src_headers = [
'adw-swipeable.h',
'adw-tab-bar.h',
'adw-tab-button.h',
+ 'adw-tab-overview.h',
'adw-tab-view.h',
'adw-timed-animation.h',
'adw-toast.h',
@@ -191,6 +192,7 @@ src_sources = [
'adw-swipeable.c',
'adw-tab-bar.c',
'adw-tab-button.c',
+ 'adw-tab-overview.c',
'adw-tab-view.c',
'adw-timed-animation.c',
'adw-toast.c',
@@ -216,6 +218,8 @@ libadwaita_private_sources += files([
'adw-shadow-helper.c',
'adw-tab.c',
'adw-tab-box.c',
+ 'adw-tab-grid.c',
+ 'adw-tab-thumbnail.c',
'adw-toast-widget.c',
'adw-view-switcher-button.c',
'adw-widget-utils.c',
diff --git a/src/stylesheet/_colors.scss b/src/stylesheet/_colors.scss
index d33250cc..35216297 100644
--- a/src/stylesheet/_colors.scss
+++ b/src/stylesheet/_colors.scss
@@ -46,6 +46,9 @@ $dialog_fg_color: gtkcolor(dialog_fg_color);
$popover_bg_color: gtkcolor(popover_bg_color);
$popover_fg_color: gtkcolor(popover_fg_color);
+$thumbnail_bg_color: gtkcolor(thumbnail_bg_color);
+$thumbnail_fg_color: gtkcolor(thumbnail_fg_color);
+
$shade_color: gtkcolor(shade_color);
$scrollbar_outline_color: gtkcolor(scrollbar_outline_color);
diff --git a/src/stylesheet/_defaults.scss b/src/stylesheet/_defaults.scss
index e313d5f9..d671f4af 100644
--- a/src/stylesheet/_defaults.scss
+++ b/src/stylesheet/_defaults.scss
@@ -59,6 +59,10 @@
@define-color popover_bg_color #{if($variant == 'light', #ffffff, #383838)};
@define-color popover_fg_color #{if($variant == 'light', transparentize(black, .2), white)};
+// Thumbnails
+@define-color thumbnail_bg_color #{if($variant == 'light', #ffffff, #383838)};
+@define-color thumbnail_fg_color #{if($variant == 'light', transparentize(black, .2), white)};
+
// Miscellaneous
@define-color shade_color #{if($variant == 'light', transparentize(black, .93), transparentize(black, .64))};
@define-color scrollbar_outline_color #{if($variant == 'light', white, transparentize(black, .5))};
diff --git a/src/stylesheet/widgets/_tab-view.scss b/src/stylesheet/widgets/_tab-view.scss
index 1b140c40..3158550d 100644
--- a/src/stylesheet/widgets/_tab-view.scss
+++ b/src/stylesheet/widgets/_tab-view.scss
@@ -139,7 +139,89 @@ dnd {
}
}
+tabthumbnail {
+ > box {
+ margin: 6px;
+ }
+
+ .card {
+ outline: 1px solid $window_outline_color;
+ outline-offset: -1px;
+
+ background-color: $thumbnail_bg_color;
+ color: $thumbnail_fg_color;
+
+ @if $contrast == 'high' {
+ box-shadow: 0 0 0 1px transparentize(black, 0.5),
+ 0 1px 3px 1px transparentize(black, .93),
+ 0 2px 6px 2px transparentize(black, .97);
+ }
+ }
+
+ .icon-title-box {
+ border-spacing: 6px;
+ }
+
+ &.pinned {
+ .card {
+ outline: none;
+ }
+
+ .icon-title-box {
+ &:dir(ltr) {
+ margin-left: 6px;
+ margin-right: 30px;
+ }
+
+ &:dir(rtl) {
+ margin-right: 6px;
+ margin-left: 30px;
+ }
+ }
+
+ &.indicator .icon-title-box {
+ &:dir(ltr) { margin-left: 30px; }
+ &:dir(rtl) { margin-right: 30px; }
+ }
+ }
+
+ button.circular {
+ margin: 6px;
+ background-color: gtkalpha($thumbnail_bg_color, .75);
+ min-width: 24px;
+ min-height: 24px;
+
+ @if $contrast == 'high' {
+ box-shadow: 0 0 0 1px currentColor;
+ }
+
+ &:hover {
+ background-color: gtkalpha(gtkmix($thumbnail_bg_color, currentColor, 90%), .75);
+ }
+
+ &:active {
+ background-color: gtkalpha(gtkmix($thumbnail_bg_color, currentColor, 80%), .75);
+ }
+ }
+}
+
+taboverview > .overview {
+ &.scrolled-to-top {
+ headerbar,
+ searchbar > revealer > box {
+ background: none;
+ color: inherit;
+ box-shadow: none;
+ }
+ }
+
+ .new-tab-button {
+ margin: 18px;
+ }
+}
+
tabview:drop(active),
-tabbox:drop(active) {
+tabbox:drop(active),
+tabgrid:drop(active) {
box-shadow: none;
}
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
