static void
gtk_switch_multipress_gesture_pressed (GtkGestureMultiPress *gesture,
gint n_press,
gdouble x,
gdouble y,
GtkSwitch *sw)
{
GtkSwitchPrivate *priv = sw->priv;
GtkAllocation allocation;
gtk_widget_get_allocation (GTK_WIDGET (sw), &allocation);
gtk_gesture_set_state (GTK_GESTURE (gesture), GTK_EVENT_SEQUENCE_CLAIMED);
if (priv->is_active)
priv->offset = allocation.width / 2;
else
priv->offset = 0;
/* If the press didn't happen in the draggable handle,
* cancel the pan gesture right away
*/
if ((priv->is_active && x <= allocation.width / 2) ||
(!priv->is_active && x > allocation.width / 2))
gtk_gesture_set_state (priv->pan_gesture, GTK_EVENT_SEQUENCE_DENIED);
}
static void
gtk_switch_pan_gesture_pan (GtkGesturePan *gesture,
GtkPanDirection direction,
gdouble offset,
GtkSwitch *sw)
{
GtkWidget *widget = GTK_WIDGET (sw);
GtkSwitchPrivate *priv = sw->priv;
gint width;
if (direction == GTK_PAN_DIRECTION_LEFT)
offset = -offset;
gtk_gesture_set_state (GTK_GESTURE (gesture), GTK_EVENT_SEQUENCE_CLAIMED);
width = gtk_widget_get_allocated_width (widget);
if (priv->is_active)
offset += width / 2;
offset /= width / 2;
/* constrain the handle within the trough width */
priv->handle_pos = CLAMP (offset, 0, 1.0);
/* we need to redraw the handle */
gtk_widget_queue_allocate (widget);
}
static void
gtk_switch_pan_gesture_drag_end (GtkGestureDrag *gesture,
gdouble x,
gdouble y,
GtkSwitch *sw)
{
GtkSwitchPrivate *priv = sw->priv;
GdkEventSequence *sequence;
GtkAllocation allocation;
gboolean active;
sequence = gtk_gesture_single_get_current_sequence (GTK_GESTURE_SINGLE (gesture));
if (gtk_gesture_get_sequence_state (GTK_GESTURE (gesture), sequence) == GTK_EVENT_SEQUENCE_CLAIMED)
{
gtk_widget_get_allocation (GTK_WIDGET (sw), &allocation);
/* if half the handle passed the middle of the switch, then we
* consider it to be on
*/
active = priv->handle_pos >= 0.5;
}
else if (!gtk_gesture_handles_sequence (priv->multipress_gesture, sequence))
active = priv->is_active;
else
return;
priv->handle_pos = active ? 1.0 : 0.0;
gtk_switch_set_active (sw, active);
gtk_widget_queue_allocate (GTK_WIDGET (sw));
}
static void
photos_preview_nav_buttons_multi_press_released (PhotosPreviewNavButtons *self)
{
gtk_gesture_set_state (GTK_GESTURE (self->tap_gesture), GTK_EVENT_SEQUENCE_CLAIMED);
self->visible_internal = !self->visible_internal;
photos_preview_nav_buttons_unqueue_auto_hide (self);
photos_preview_nav_buttons_update_visibility (self);
}
static gboolean
_gtk_gesture_long_press_timeout (gpointer user_data)
{
GtkGestureLongPress *gesture = user_data;
GtkGestureLongPressPrivate *priv;
GdkEventSequence *sequence;
gdouble x, y;
priv = gtk_gesture_long_press_get_instance_private (gesture);
sequence = gtk_gesture_get_last_updated_sequence (GTK_GESTURE (gesture));
gtk_gesture_get_point (GTK_GESTURE (gesture), sequence, &x, &y);
priv->timeout_id = 0;
priv->triggered = TRUE;
g_signal_emit (gesture, signals[PRESSED], 0, x, y);
return G_SOURCE_REMOVE;
}
static void
hold_action (GtkGestureLongPress *gesture,
gdouble x,
gdouble y,
GtkColorSwatch *swatch)
{
do_popup (swatch);
gtk_gesture_set_state (GTK_GESTURE (gesture), GTK_EVENT_SEQUENCE_CLAIMED);
}
static void
photos_preview_nav_buttons_multi_press_end (PhotosPreviewNavButtons *self, GdkEventSequence *sequence)
{
GtkEventSequenceState state;
state = gtk_gesture_get_sequence_state (self->tap_gesture, sequence);
if (state == GTK_EVENT_SEQUENCE_DENIED)
return;
gtk_gesture_set_state (GTK_GESTURE (self->tap_gesture), GTK_EVENT_SEQUENCE_CLAIMED);
self->visible_internal = !self->visible_internal;
photos_preview_nav_buttons_unqueue_auto_hide (self);
photos_preview_nav_buttons_update_visibility (self);
}
static void
_gtk_gesture_multi_press_stop (GtkGestureMultiPress *gesture)
{
GtkGestureMultiPressPrivate *priv;
priv = gtk_gesture_multi_press_get_instance_private (gesture);
if (priv->n_presses == 0)
return;
priv->current_button = 0;
priv->n_presses = 0;
g_signal_emit (gesture, signals[STOPPED], 0);
_gtk_gesture_check (GTK_GESTURE (gesture));
}
static void
gtk_switch_multipress_gesture_released (GtkGestureMultiPress *gesture,
gint n_press,
gdouble x,
gdouble y,
GtkSwitch *sw)
{
GtkSwitchPrivate *priv = sw->priv;
GdkEventSequence *sequence;
sequence = gtk_gesture_single_get_current_sequence (GTK_GESTURE_SINGLE (gesture));
if (priv->in_switch &&
gtk_gesture_handles_sequence (GTK_GESTURE (gesture), sequence))
gtk_switch_begin_toggle_animation (sw);
}
static void
drag_update_cb (GtkGestureDrag *gesture,
double offset_x,
double offset_y,
gpointer user_data)
{
CbMediaImageWidget *self = user_data;
GtkAdjustment *adjustment;
adjustment = gtk_scrolled_window_get_hadjustment (GTK_SCROLLED_WINDOW (self));
gtk_adjustment_set_value (adjustment, self->drag_start_hvalue - offset_x);
adjustment = gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (self));
gtk_adjustment_set_value (adjustment, self->drag_start_vvalue - offset_y);
gtk_gesture_set_state (GTK_GESTURE (gesture), GTK_EVENT_SEQUENCE_CLAIMED);
}
static void
gtk_switch_pan_gesture_pan (GtkGesturePan *gesture,
GtkPanDirection direction,
gdouble offset,
GtkSwitch *sw)
{
GtkWidget *widget = GTK_WIDGET (sw);
GtkSwitchPrivate *priv = sw->priv;
GtkAllocation allocation;
GtkStyleContext *context;
GtkStateFlags state;
GtkBorder padding;
gint width, position;
if (direction == GTK_PAN_DIRECTION_LEFT)
offset = -offset;
gtk_gesture_set_state (GTK_GESTURE (gesture), GTK_EVENT_SEQUENCE_CLAIMED);
position = priv->offset + offset;
context = gtk_widget_get_style_context (widget);
state = gtk_widget_get_state_flags (widget);
gtk_style_context_save (context);
gtk_style_context_add_class (context, GTK_STYLE_CLASS_SLIDER);
gtk_style_context_get_padding (context, state, &padding);
gtk_style_context_restore (context);
gtk_widget_get_allocation (widget, &allocation);
width = allocation.width;
/* constrain the handle within the trough width */
if (position > (width / 2) - padding.right)
priv->handle_x = width / 2 - padding.right;
else if (position < padding.left)
priv->handle_x = 0;
else
priv->handle_x = position;
/* we need to redraw the handle */
gtk_widget_queue_draw (widget);
}
static void
multipress_pressed_cb (GtkGestureMultiPress *gesture,
guint n_press,
gdouble x,
gdouble y,
IdeOmniBar *self)
{
GtkStyleContext *style_context;
GtkStateFlags state_flags;
g_assert (IDE_IS_OMNI_BAR (self));
gtk_popover_popup (self->popover);
style_context = gtk_widget_get_style_context (GTK_WIDGET (self));
state_flags = gtk_style_context_get_state (style_context);
gtk_style_context_set_state (style_context, state_flags | GTK_STATE_FLAG_ACTIVE);
gtk_gesture_set_state (GTK_GESTURE (gesture), GTK_EVENT_SEQUENCE_CLAIMED);
}
static void
multipress_pressed_cb (GtkGestureMultiPress *gesture,
guint n_press,
gdouble x,
gdouble y,
GtkWidget *widget)
{
GtkButton *button = GTK_BUTTON (widget);
GtkButtonPrivate *priv = button->priv;
if (gtk_widget_get_focus_on_click (widget) && !gtk_widget_has_focus (widget))
gtk_widget_grab_focus (widget);
priv->in_button = TRUE;
if (!priv->activate_timeout)
{
priv->button_down = TRUE;
gtk_button_update_state (button);
}
gtk_gesture_set_state (GTK_GESTURE (gesture), GTK_EVENT_SEQUENCE_CLAIMED);
}
static void
ide_frame_pan_update (IdeFrame *self,
GdkEventSequence *sequence,
GtkGestureSwipe *gesture)
{
IdeFramePrivate *priv = ide_frame_get_instance_private (self);
GtkAllocation alloc;
GtkWidget *grid;
gdouble x, y;
IDE_ENTRY;
g_assert (IDE_IS_FRAME (self));
g_assert (GTK_IS_GESTURE_PAN (gesture));
g_assert (!priv->pan_theatric || DZL_IS_BOX_THEATRIC (priv->pan_theatric));
if (priv->pan_theatric == NULL)
{
if (sequence != NULL)
gtk_gesture_set_state (GTK_GESTURE (gesture), GTK_EVENT_SEQUENCE_DENIED);
IDE_EXIT;
}
gtk_gesture_drag_get_offset (GTK_GESTURE_DRAG (gesture), &x, &y);
gtk_widget_get_allocation (GTK_WIDGET (self), &alloc);
grid = gtk_widget_get_ancestor (GTK_WIDGET (self), IDE_TYPE_GRID);
gtk_widget_translate_coordinates (GTK_WIDGET (priv->top_stack), grid, 0, 0,
&alloc.x, &alloc.y);
g_object_set (priv->pan_theatric,
"x", alloc.x + (gint)x,
NULL);
IDE_EXIT;
}
static gboolean
gtk_gesture_single_handle_event (GtkEventController *controller,
const GdkEvent *event)
{
GdkEventSequence *sequence = NULL;
GtkGestureSinglePrivate *priv;
GdkDevice *source_device;
GdkInputSource source;
guint button = 0, i;
gboolean retval, test_touchscreen = FALSE;
source_device = gdk_event_get_source_device (event);
if (!source_device)
return FALSE;
priv = gtk_gesture_single_get_instance_private (GTK_GESTURE_SINGLE (controller));
source = gdk_device_get_source (source_device);
if (source != GDK_SOURCE_TOUCHSCREEN)
test_touchscreen = gtk_simulate_touchscreen ();
switch (event->type)
{
case GDK_TOUCH_BEGIN:
case GDK_TOUCH_END:
case GDK_TOUCH_UPDATE:
if (priv->exclusive && !event->touch.emulating_pointer)
return FALSE;
sequence = event->touch.sequence;
button = 1;
break;
case GDK_BUTTON_PRESS:
case GDK_BUTTON_RELEASE:
if (priv->touch_only && !test_touchscreen && source != GDK_SOURCE_TOUCHSCREEN)
return FALSE;
button = event->button.button;
break;
case GDK_MOTION_NOTIFY:
if (!gtk_gesture_handles_sequence (GTK_GESTURE (controller), sequence))
return FALSE;
if (priv->touch_only && !test_touchscreen && source != GDK_SOURCE_TOUCHSCREEN)
return FALSE;
if (priv->current_button > 0 && priv->current_button <= 5 &&
(event->motion.state & (GDK_BUTTON1_MASK << (priv->current_button - 1))))
button = priv->current_button;
else if (priv->current_button == 0)
{
/* No current button, find out from the mask */
for (i = 0; i < 3; i++)
{
if ((event->motion.state & (GDK_BUTTON1_MASK << i)) == 0)
continue;
button = i + 1;
break;
}
}
break;
case GDK_TOUCH_CANCEL:
case GDK_GRAB_BROKEN:
return GTK_EVENT_CONTROLLER_CLASS (gtk_gesture_single_parent_class)->handle_event (controller,
event);
break;
default:
return FALSE;
}
if (button == 0 ||
(priv->button != 0 && priv->button != button) ||
(priv->current_button != 0 && priv->current_button != button))
{
if (gtk_gesture_is_active (GTK_GESTURE (controller)))
gtk_event_controller_reset (controller);
return FALSE;
}
if (event->type == GDK_BUTTON_PRESS || event->type == GDK_TOUCH_BEGIN ||
event->type == GDK_MOTION_NOTIFY || event->type == GDK_TOUCH_UPDATE)
{
if (!gtk_gesture_is_active (GTK_GESTURE (controller)))
priv->current_sequence = sequence;
priv->current_button = button;
}
retval = GTK_EVENT_CONTROLLER_CLASS (gtk_gesture_single_parent_class)->handle_event (controller, event);
if (sequence == priv->current_sequence &&
(event->type == GDK_BUTTON_RELEASE || event->type == GDK_TOUCH_END))
priv->current_button = 0;
else if (priv->current_sequence == sequence &&
!gtk_gesture_handles_sequence (GTK_GESTURE (controller), sequence))
{
if (button == priv->current_button && event->type == GDK_BUTTON_PRESS)
priv->current_button = 0;
else if (sequence == priv->current_sequence && event->type == GDK_TOUCH_BEGIN)
priv->current_sequence = NULL;
}
return retval;
}
static void
photos_preview_nav_buttons_multi_press_stopped (PhotosPreviewNavButtons *self)
{
gtk_gesture_set_state (GTK_GESTURE (self->tap_gesture), GTK_EVENT_SEQUENCE_DENIED);
}
static gboolean
ide_frame_pan_begin (IdeFrame *self,
GdkEventSequence *sequence,
GtkGesturePan *gesture)
{
IdeFramePrivate *priv = ide_frame_get_instance_private (self);
GtkAllocation alloc;
cairo_surface_t *surface = NULL;
IdePage *page;
GdkWindow *window;
GtkWidget *grid;
cairo_t *cr;
gdouble x, y;
gboolean enable_animations;
IDE_ENTRY;
g_assert (IDE_IS_FRAME (self));
g_assert (GTK_IS_GESTURE_PAN (gesture));
g_assert (priv->pan_theatric == NULL);
page = ide_frame_get_visible_child (self);
if (page != NULL)
gtk_widget_get_allocation (GTK_WIDGET (page), &alloc);
g_object_get (gtk_settings_get_default (),
"gtk-enable-animations", &enable_animations,
NULL);
if (sequence != NULL ||
page == NULL ||
!enable_animations ||
is_uninitialized (&alloc) ||
NULL == (window = gtk_widget_get_window (GTK_WIDGET (page))) ||
NULL == (surface = gdk_window_create_similar_surface (window,
CAIRO_CONTENT_COLOR,
alloc.width,
alloc.height)))
{
if (sequence != NULL)
gtk_gesture_set_state (GTK_GESTURE (gesture), GTK_EVENT_SEQUENCE_DENIED);
IDE_RETURN (FALSE);
}
gtk_gesture_drag_get_offset (GTK_GESTURE_DRAG (gesture), &x, &y);
cr = cairo_create (surface);
gtk_widget_draw (GTK_WIDGET (page), cr);
cairo_destroy (cr);
grid = gtk_widget_get_ancestor (GTK_WIDGET (self), IDE_TYPE_GRID);
gtk_widget_translate_coordinates (GTK_WIDGET (priv->top_stack), grid, 0, 0,
&alloc.x, &alloc.y);
priv->pan_page = g_object_ref (page);
priv->pan_theatric = g_object_new (DZL_TYPE_BOX_THEATRIC,
"surface", surface,
"target", grid,
"x", alloc.x + (gint)x,
"y", alloc.y,
"width", alloc.width,
"height", alloc.height,
NULL);
g_clear_pointer (&surface, cairo_surface_destroy);
/* Hide the page while we begin the possible transition to another
* layout stack.
*/
gtk_widget_hide (GTK_WIDGET (priv->pan_page));
/*
* Hide the mouse cursor until ide_frame_pan_end() is called.
* It can be distracting otherwise (and we want to warp it to the new
* grid column too).
*/
ide_frame_set_cursor (self, "none");
IDE_RETURN (TRUE);
}
/* The multi-press gesture used by the flowbox to select a child
* forbid us to use dnd so we need to catch it here and select yourself
* the child
*/
static void
gstyle_color_widget_multipress_gesture_pressed (GtkGestureMultiPress *gesture,
guint n_press,
gdouble x,
gdouble y,
GstyleColorWidget *self)
{
GtkWidget *container;
GtkWidget *child;
GtkWidget *popover;
GtkBuilder *builder;
GtkWidget *button_rename;
GtkWidget *button_remove;
GtkWidget *ancestor;
gint button;
button = gtk_gesture_single_get_current_button (GTK_GESTURE_SINGLE (gesture));
gtk_gesture_set_state (GTK_GESTURE (gesture), GTK_EVENT_SEQUENCE_CLAIMED);
child = gtk_widget_get_parent (GTK_WIDGET (self));
if (child != NULL && button == GDK_BUTTON_PRIMARY)
{
if (GTK_IS_LIST_BOX_ROW (child))
{
container = gtk_widget_get_parent (GTK_WIDGET (child));
if (container != NULL && GTK_IS_LIST_BOX (container))
{
gtk_list_box_select_row (GTK_LIST_BOX (container), GTK_LIST_BOX_ROW (child));
gtk_widget_grab_focus (GTK_WIDGET (self));
if (n_press == 2)
g_signal_emit_by_name (container, "row-activated", child);
}
}
else if (GTK_IS_FLOW_BOX_CHILD (child))
{
container = gtk_widget_get_parent (GTK_WIDGET (child));
if (container != NULL && GTK_IS_FLOW_BOX (container))
{
gtk_flow_box_select_child (GTK_FLOW_BOX (container), GTK_FLOW_BOX_CHILD (child));
gtk_widget_grab_focus (GTK_WIDGET (self));
if (n_press == 2)
g_signal_emit_by_name (container, "child-activated", child);
}
}
}
if (button == GDK_BUTTON_SECONDARY)
{
ancestor = gtk_widget_get_ancestor (GTK_WIDGET (self), GSTYLE_TYPE_PALETTE_WIDGET);
if (ancestor != NULL)
{
builder = gtk_builder_new_from_resource ("/org/gnome/libgstyle/ui/gstyle-color-widget.ui");
popover = GTK_WIDGET (gtk_builder_get_object (builder, "popover"));
button_rename = GTK_WIDGET (gtk_builder_get_object (builder, "button_rename"));
g_signal_connect_object (button_rename, "button-release-event",
G_CALLBACK (popover_button_rename_clicked_cb), self, G_CONNECT_SWAPPED);
button_remove = GTK_WIDGET (gtk_builder_get_object (builder, "button_remove"));
g_signal_connect_object (button_remove, "button-release-event",
G_CALLBACK (popover_button_remove_clicked_cb), self, G_CONNECT_SWAPPED);
gtk_popover_set_relative_to (GTK_POPOVER (popover), GTK_WIDGET (self));
g_signal_connect_swapped (popover, "closed", G_CALLBACK (contextual_popover_closed_cb), self);
gtk_widget_show (popover);
g_object_unref (builder);
}
}
}
static void
gstyle_color_widget_drag_gesture_update (GtkGestureDrag *gesture,
gdouble offset_x,
gdouble offset_y,
GstyleColorWidget *self)
{
GdkDragContext *context;
GdkEventSequence *sequence;
const GdkEvent *event;
gdouble start_x, start_y;
GtkAllocation allocation;
GstylePaletteWidgetDndLockFlags dnd_lock;
GtkWidget *container;
GdkDragAction drag_action;
gint button;
g_assert (GTK_IS_GESTURE (gesture));
g_assert (GSTYLE_IS_COLOR_WIDGET (self));
dnd_lock = get_palette_widget_dnd_lock (self);
if ((dnd_lock & GSTYLE_PALETTE_WIDGET_DND_LOCK_FLAGS_DRAG) != 0)
return;
button = gtk_gesture_single_get_current_button (GTK_GESTURE_SINGLE (gesture));
if (!gtk_drag_check_threshold (GTK_WIDGET (self), 0, 0, offset_x, offset_y) ||
button != GDK_BUTTON_PRIMARY)
return;
gtk_widget_get_allocation (GTK_WIDGET (self), &allocation);
self->dnd_color_widget = gstyle_color_widget_copy (self);
if (self->filter_func != NULL && GSTYLE_IS_COLOR (self->filtered_color))
gstyle_color_widget_set_color (self->dnd_color_widget, self->filtered_color);
self->dnd_window = gtk_window_new (GTK_WINDOW_POPUP);
gtk_widget_set_size_request (self->dnd_window, allocation.width, allocation.height);
gtk_window_set_screen (GTK_WINDOW (self->dnd_window), gtk_widget_get_screen (GTK_WIDGET (self)));
gtk_container_add (GTK_CONTAINER (self->dnd_window), GTK_WIDGET (self->dnd_color_widget));
gtk_widget_show_all (self->dnd_window);
gtk_widget_set_opacity (self->dnd_window, GSTYLE_COLOR_WIDGET_DRAG_ICON_OPACITY);
sequence = gtk_gesture_single_get_current_sequence (GTK_GESTURE_SINGLE (gesture));
gtk_gesture_drag_get_start_point (GTK_GESTURE_DRAG (gesture), &start_x, &start_y);
event = gtk_gesture_get_last_event (GTK_GESTURE (gesture), sequence);
container = gtk_widget_get_ancestor (GTK_WIDGET (self), GSTYLE_TYPE_PALETTE_WIDGET);
if (container != NULL && GSTYLE_IS_PALETTE_WIDGET (container))
drag_action = (GDK_ACTION_MOVE | GDK_ACTION_COPY);
else
drag_action = GDK_ACTION_COPY;
context = gtk_drag_begin_with_coordinates (GTK_WIDGET (self),
self->target_list,
drag_action,
button,
(GdkEvent*)event,
start_x, start_y);
gtk_drag_set_icon_widget (context, self->dnd_window, 0, 0);
}
