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); }