static void gtk_gesture_long_press_update (GtkGesture *gesture, GdkEventSequence *sequence) { GtkGestureLongPressPrivate *priv; GtkWidget *widget; gdouble x, y; widget = gtk_event_controller_get_widget (GTK_EVENT_CONTROLLER (gesture)); priv = gtk_gesture_long_press_get_instance_private (GTK_GESTURE_LONG_PRESS (gesture)); gtk_gesture_get_point (gesture, sequence, &x, &y); if (gtk_drag_check_threshold (widget, priv->initial_x, priv->initial_y, x, y)) { if (priv->timeout_id) { g_source_remove (priv->timeout_id); priv->timeout_id = 0; g_signal_emit (gesture, signals[CANCELLED], 0); } priv->cancelled = TRUE; _gtk_gesture_check (gesture); } }
static VALUE rg_m_threshold_p(G_GNUC_UNUSED VALUE self, VALUE widget, VALUE start_x, VALUE start_y, VALUE current_x, VALUE current_y) { return CBOOL2RVAL(gtk_drag_check_threshold(RVAL2WIDGET(widget), NUM2INT(start_x), NUM2INT(start_y), NUM2INT(current_x), NUM2INT(current_y))); }
static gboolean hand_display_motion (GtkWidget *hand, GdkEventMotion *event) { HandDisplay *handdisp = HAND_DISPLAY(hand); int card = which_card(handdisp, event->x, event->y); if (handdisp->drag && handdisp->cur_click >= 0 && handdisp->cur_click < 52 && gtk_drag_check_threshold (hand, handdisp->drag_x, handdisp->drag_y, event->x, event->y)) { if (! target_list) target_list = gtk_target_list_new (target_entry, 1); handdisp->cur_drag = handdisp->cur_click; gtk_drag_begin (hand, target_list, GDK_ACTION_COPY, 1, (GdkEvent *) event); } if (handdisp->cur_focus != card) { if (handdisp->cur_focus != -1) { redraw_card (hand, handdisp->cur_focus); g_signal_emit_by_name (handdisp, "card-leave", handdisp->cur_focus); } handdisp->cur_focus = card; if (card != -1) { redraw_card (hand, card); g_signal_emit_by_name (handdisp, "card-enter", card); } } gdk_window_get_pointer(gtk_widget_get_window (hand), NULL, NULL, NULL); /* request more pointer hints */ return FALSE; }
static gboolean egg_tree_multi_drag_motion_event (GtkWidget *widget, GdkEventMotion *event, gpointer data) { EggTreeMultiDndData *priv_data; priv_data = g_object_get_data (G_OBJECT (widget), EGG_TREE_MULTI_DND_STRING); if (gtk_drag_check_threshold (widget, priv_data->x, priv_data->y, event->x, event->y)) { GList *path_list = NULL; GtkTreeSelection *selection; GtkTreeModel *model; GdkDragContext *context; TreeViewDragInfo *di; di = get_info (GTK_TREE_VIEW (widget)); if (di == NULL) return FALSE; selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (widget)); stop_drag_check (widget); gtk_tree_selection_selected_foreach (selection, selection_foreach, &path_list); path_list = g_list_reverse (path_list); model = gtk_tree_view_get_model (GTK_TREE_VIEW (widget)); if (egg_tree_multi_drag_source_row_draggable (EGG_TREE_MULTI_DRAG_SOURCE (model), path_list)) { context = gtk_drag_begin (widget, #if GTK_CHECK_VERSION (2, 14, 0) gtk_drag_source_get_target_list (widget), #else di->source_target_list, #endif di->source_actions, priv_data->pressed_button, (GdkEvent*)event); set_context_data (context, path_list); gtk_drag_set_icon_default (context); } else { path_list_free (path_list); } } return TRUE; }
static gboolean egg_tree_multi_drag_motion_event (GtkWidget *widget, GdkEventMotion *event, gpointer data) { EggTreeMultiDndData *priv_data; priv_data = g_object_get_data (G_OBJECT (widget), EGG_TREE_MULTI_DND_STRING); if (gtk_drag_check_threshold (widget, priv_data->x, priv_data->y, event->x, event->y)) { GList *path_list = NULL; GtkTreeSelection *selection; GtkTreeModel *model; GdkDragContext *context; stop_drag_check (widget); selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (widget)); gtk_tree_selection_selected_foreach (selection, selection_foreach, &path_list); if (path_list == NULL) return FALSE; path_list = g_list_reverse (path_list); model = gtk_tree_view_get_model (GTK_TREE_VIEW (widget)); if (egg_tree_multi_drag_source_row_draggable (EGG_TREE_MULTI_DRAG_SOURCE (model), path_list)) { GtkTargetList *target_list = gtk_target_list_new (target_table, G_N_ELEMENTS (target_table)); context = gtk_drag_begin (widget, target_list, GDK_ACTION_COPY, priv_data->pressed_button, (GdkEvent*)event); set_context_data (context, path_list); gtk_drag_set_icon_default (context); gtk_target_list_unref (target_list); } else { path_list_free (path_list); } } return TRUE; }
static gboolean etfci_maybe_start_drag (ETableFieldChooserItem *etfci, gint x, gint y) { GnomeCanvasItem *item; if (!etfci->maybe_drag) return FALSE; item = GNOME_CANVAS_ITEM (etfci); return gtk_drag_check_threshold (GTK_WIDGET (item->canvas), etfci->click_x, etfci->click_y, x, y); }
static gboolean motion_notify_cb (CeditNotebook *notebook, GdkEventMotion *event, gpointer data) { CeditNotebook *dest; gint page_num; gint result; if (notebook->priv->drag_in_progress == FALSE) { if (notebook->priv->tab_drag_and_drop_enabled == FALSE) return FALSE; if (gtk_drag_check_threshold (GTK_WIDGET (notebook), notebook->priv->x_start, notebook->priv->y_start, event->x_root, event->y_root)) { drag_start (notebook, event->time); return TRUE; } return FALSE; } result = find_notebook_and_tab_at_pos ((gint)event->x_root, (gint)event->y_root, &dest, &page_num); if (result != NOT_IN_APP_WINDOWS) { if (dest != notebook) { move_current_tab_to_another_notebook (notebook, dest, event, page_num); } else { g_return_val_if_fail (page_num >= -1, FALSE); move_current_tab (notebook, page_num); } } return FALSE; }
static gboolean gdl_dock_tablabel_motion_event (GtkWidget *widget, GdkEventMotion *event) { GdlDockTablabel *tablabel; GtkAllocation widget_allocation; gboolean event_handled; g_return_val_if_fail (widget != NULL, FALSE); g_return_val_if_fail (GDL_IS_DOCK_TABLABEL (widget), FALSE); g_return_val_if_fail (event != NULL, FALSE); tablabel = GDL_DOCK_TABLABEL (widget); event_handled = FALSE; if (event->window != tablabel->event_window) return FALSE; if (tablabel->pre_drag) { if (gtk_drag_check_threshold (widget, tablabel->drag_start_event.x, tablabel->drag_start_event.y, event->x, event->y)) { tablabel->pre_drag = FALSE; g_signal_emit (widget, dock_tablabel_signals [BUTTON_PRESSED_HANDLE], 0, &tablabel->drag_start_event); event_handled = TRUE; } } if (!event_handled) { /* propagate the event to the parent's gdkwindow */ GdkEventMotion e; e = *event; e.window = gtk_widget_get_parent_window (widget); gtk_widget_get_allocation (widget, &widget_allocation); e.x += widget_allocation.x; e.y += widget_allocation.y; gdk_event_put ((GdkEvent *) &e); }; return event_handled; }
static gboolean gth_image_rotator_motion_notify (GthImageViewerTool *base, GdkEventMotion *event) { GthImageRotator *self = GTH_IMAGE_ROTATOR (base); if (! self->priv->dragging && gtk_drag_check_threshold (GTK_WIDGET (self->priv->viewer), self->priv->drag_p1.x, self->priv->drag_p1.y, self->priv->drag_p2.x, self->priv->drag_p2.y)) { GdkCursor *cursor; self->priv->angle_before_dragging = self->priv->angle; self->priv->dragging = TRUE; cursor = gdk_cursor_new_from_name (gtk_widget_get_display (GTK_WIDGET (self->priv->viewer)), "grabbing"); gth_image_viewer_set_cursor (self->priv->viewer, cursor); if (cursor != NULL) g_object_unref (cursor); } if (self->priv->dragging) { GdkPoint center; double angle1; double angle2; double angle; self->priv->drag_p2.x = event->x; self->priv->drag_p2.y = event->y; center.x = self->priv->center.x * self->priv->preview_zoom + self->priv->preview_image_area.x; center.y = self->priv->center.y * self->priv->preview_zoom + self->priv->preview_image_area.y; angle1 = get_angle (¢er, &self->priv->drag_p1); angle2 = get_angle (¢er, &self->priv->drag_p2); angle = self->priv->angle_before_dragging + (angle2 - angle1); if (angle < - G_PI) angle = G_2_PI + angle; if (angle > + G_PI) angle = angle - G_2_PI; g_signal_emit (self, signals[ANGLE_CHANGED], 0, CLAMP (RAD_TO_DEG (angle), -180.0, 180)); } return FALSE; }
void GestureController::DragGesture::update(DragGesture* dragGesture, double x, double y, GtkGesture* gesture) { GdkEventSequence* sequence = gtk_gesture_single_get_current_sequence(GTK_GESTURE_SINGLE(gesture)); gtk_gesture_set_sequence_state(gesture, sequence, GTK_EVENT_SEQUENCE_CLAIMED); GtkWidget* widget = gtk_event_controller_get_widget(GTK_EVENT_CONTROLLER(gesture)); if (!dragGesture->m_inDrag && gtk_drag_check_threshold(widget, dragGesture->m_start.x(), dragGesture->m_start.y(), dragGesture->m_start.x() + x, dragGesture->m_start.y() + y)) { dragGesture->m_inDrag = true; dragGesture->m_longPressTimeout.cancel(); } if (dragGesture->m_inDrag) dragGesture->handleDrag(gtk_gesture_get_last_event(gesture, sequence), x, y); dragGesture->m_offset.set(x, y); }
static gboolean rb_tree_dnd_motion_notify_event_cb (GtkWidget *widget, GdkEventMotion *event, gpointer data) { RbTreeDndData *priv_data; priv_data = g_object_get_data (G_OBJECT (widget), RB_TREE_DND_STRING); if (gtk_drag_check_threshold (widget, priv_data->x, priv_data->y, event->x, event->y)) { GList *path_list = NULL; GtkTreeSelection *selection; GtkTreeModel *model; GdkDragContext *context; selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (widget)); stop_drag_check (widget); gtk_tree_selection_selected_foreach (selection, selection_foreach, &path_list); path_list = g_list_reverse (path_list); model = gtk_tree_view_get_model (GTK_TREE_VIEW (widget)); if (rb_tree_drag_source_row_draggable (RB_TREE_DRAG_SOURCE (model), path_list)) { rb_debug ("drag begin"); context = gtk_drag_begin (widget, priv_data->source_target_list, priv_data->source_actions, priv_data->pressed_button, (GdkEvent*)event); set_context_data (context, path_list); gtk_drag_set_icon_default (context); } else { path_list_free (path_list); } } return TRUE; }
static gboolean on_motion_event( GtkWidget *widget, GdkEventMotion *event, EggTreeMultiDragSource *drag_source ) { EggTreeMultiDndData *priv_data; priv_data = g_object_get_data( G_OBJECT( widget ), EGG_TREE_MULTI_DND_STRING ); if( gtk_drag_check_threshold( widget, priv_data->x, priv_data->y, event->x, event->y )){ GList *path_list = NULL; GtkTreeSelection *selection; GtkTreeModel *model; GdkDragContext *context; stop_drag_check( widget ); selection = gtk_tree_view_get_selection( GTK_TREE_VIEW( widget )); gtk_tree_selection_selected_foreach( selection, ( GtkTreeSelectionForeachFunc ) selection_foreach, &path_list ); path_list = g_list_reverse( path_list ); model = gtk_tree_view_get_model( GTK_TREE_VIEW( widget )); if( egg_tree_multi_drag_source_row_draggable( EGG_TREE_MULTI_DRAG_SOURCE( model ), path_list )){ GtkTargetList *target_list = v_get_target_list( drag_source ); GdkDragAction actions = v_get_drag_actions( drag_source ); context = gtk_drag_begin( widget, target_list, actions, priv_data->pressed_button, ( GdkEvent * ) event ); set_treeview_data( widget, path_list ); gtk_drag_set_icon_default( context ); v_free_target_list( drag_source, target_list ); } else { path_list_free( path_list ); } } return( TRUE ); }
static gboolean gul_gestures_motion_cb (GtkWidget *widget, GdkEventMotion *e, GulGestures *as) { GulGesturesPrivate *p = as->priv; if (p->autocancel_timeout) { if (gtk_drag_check_threshold (p->widget, p->start_x, p->start_y, e->x_root, e->y_root)) { g_source_remove (p->autocancel_timeout); p->autocancel_timeout = 0; } } stroke_record (e->x_root, e->y_root); return TRUE; }
static gboolean motion_notify_cb (GtkWidget *widget, GdkEventMotion *event, EphyNodeView *view) { GdkDragContext *context; GList *ref_list; if (event->window != gtk_tree_view_get_bin_window (GTK_TREE_VIEW (widget))) { return FALSE; } if (view->priv->drag_button != 0) { if (gtk_drag_check_threshold (widget, view->priv->drag_x, view->priv->drag_y, event->x, event->y) && can_drag_selection (view)) { context = gtk_drag_begin (widget, view->priv->source_target_list, GDK_ACTION_ASK | GDK_ACTION_COPY | GDK_ACTION_LINK, view->priv->drag_button, (GdkEvent*)event); stop_drag_check (view); view->priv->drag_started = TRUE; ref_list = get_selection_refs (GTK_TREE_VIEW (widget)); g_object_set_data_full (G_OBJECT (context), "drag-info", ref_list, (GDestroyNotify)ref_list_free); gtk_drag_set_icon_default (context); } } return TRUE; }
int clip_GTK_DRAGCHECKTHRESHOLD(ClipMachine * cm) { C_widget *cwid = _fetch_cw_arg(cm); gint start_x = _clip_parni(cm, 2); gint start_y = _clip_parni(cm, 3); gint current_x = _clip_parni(cm, 4); gint current_y = _clip_parni(cm, 5); CHECKCWID(cwid, GTK_IS_WIDGET); CHECKARG(2, NUMERIC_t); CHECKARG(3, NUMERIC_t); CHECKARG(5, NUMERIC_t); CHECKARG(4, NUMERIC_t); _clip_retl(cm, gtk_drag_check_threshold(GTK_WIDGET(cwid->widget), start_x, start_y, current_x, current_y )); return 0; err: return 1; }
static void released_cb (GtkGestureMultiPress *gesture, gint n_press, gdouble x, gdouble y, GtkIMContextWayland *context) { GtkInputHints hints; if (!global->current) return; g_object_get (context, "input-hints", &hints, NULL); if (n_press == 1 && (hints & GTK_INPUT_HINT_INHIBIT_OSK) == 0 && !gtk_drag_check_threshold (context->widget, context->press_x, context->press_y, x, y)) { enable_text_input (GTK_IM_CONTEXT_WAYLAND (context), TRUE); } }
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); }
static gboolean egg_tree_multi_drag_motion_event (GtkWidget *widget, GdkEventMotion *event, gpointer data) { EggTreeMultiDndData *priv_data; priv_data = g_object_get_data (G_OBJECT (widget), EGG_TREE_MULTI_DND_STRING); if (gtk_drag_check_threshold (widget, priv_data->x, priv_data->y, event->x, event->y)) { GList *path_list = NULL; GtkTreeSelection *selection; GtkTreeModel *model; GdkDragContext *context; TreeViewDragInfo *di; di = get_info (GTK_TREE_VIEW (widget)); if (di == NULL) return FALSE; selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (widget)); if (priv_data->motion_notify_handler) { g_signal_handler_disconnect (widget, priv_data->motion_notify_handler); priv_data->motion_notify_handler = 0; } if (priv_data->button_release_handler) { g_signal_handler_disconnect (widget, priv_data->button_release_handler); priv_data->button_release_handler = 0; } stop_drag_check (widget); gtk_tree_selection_selected_foreach (selection, selection_foreach, &path_list); path_list = g_list_reverse (path_list); model = gtk_tree_view_get_model (GTK_TREE_VIEW (widget)); if (egg_tree_multi_drag_source_row_draggable (EGG_TREE_MULTI_DRAG_SOURCE (model), path_list)) { gulong sig; /* This is to disconnect the default signal handler for treeviews as * it sometimes gives a warning. The default handler just sets the * icon which we do as well in our callback so it is fine. */ sig = g_signal_connect (widget, "drag-begin", G_CALLBACK (egg_tree_multi_drag_begin), NULL); context = gtk_drag_begin (widget, gtk_drag_source_get_target_list (widget), di->source_actions, priv_data->pressed_button, (GdkEvent*)event); g_signal_handler_disconnect (widget, sig); set_context_data (context, path_list); } else { path_list_free (path_list); } } return TRUE; }
static gboolean egg_tree_multi_drag_motion_event (GtkWidget *widget, GdkEventMotion *event, gpointer data) { EggTreeMultiDndData *priv_data; priv_data = g_object_get_data (G_OBJECT (widget), EGG_TREE_MULTI_DND_STRING); if (! priv_data->pending_event) return FALSE; if (gtk_drag_check_threshold (widget, priv_data->x, priv_data->y, event->x, event->y)) { GList *path_list = NULL; GtkTreeSelection *selection; GtkTreeModel *model; GdkDragContext *context; stop_drag_check (widget); selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (widget)); gtk_tree_selection_selected_foreach (selection, selection_foreach, &path_list); if (path_list == NULL) return FALSE; path_list = g_list_reverse (path_list); model = gtk_tree_view_get_model (GTK_TREE_VIEW (widget)); if (egg_tree_multi_drag_source_row_draggable (EGG_TREE_MULTI_DRAG_SOURCE (model), path_list)) { GtkTargetList *target_list; GtkTreePath *tree_path; int cell_x; int cell_y; target_list = gtk_target_list_new (target_table, G_N_ELEMENTS (target_table)); context = gtk_drag_begin_with_coordinates (widget, target_list, GDK_ACTION_COPY, priv_data->pressed_button, (GdkEvent*) event, event->x, event->y); set_context_data (context, path_list); if (gtk_tree_view_get_path_at_pos (GTK_TREE_VIEW (widget), priv_data->x, priv_data->y, &tree_path, NULL, &cell_x, &cell_y)) { cairo_surface_t *drag_icon; drag_icon = gtk_tree_view_create_row_drag_icon (GTK_TREE_VIEW (widget), tree_path); if (path_list->next != NULL) { /* create a multi row drag icon */ const int icon_offset = DRAG_ICON_OFFSET; GdkRectangle icon_extents; cairo_surface_t *multi_drag_icon; cairo_t *cr; int n_icons, i, offset; n_icons = MIN (DRAG_ICON_MAX_ROWS, g_list_length (path_list)); _gtk_cairo_surface_extents (drag_icon, &icon_extents); multi_drag_icon = gdk_window_create_similar_surface (gtk_tree_view_get_bin_window (GTK_TREE_VIEW (widget)), CAIRO_CONTENT_COLOR_ALPHA, icon_extents.width + (icon_offset * (n_icons - 1)), icon_extents.height + (icon_offset * (n_icons - 1))); cr = cairo_create (multi_drag_icon); cairo_set_source_rgba (cr, 0.0, 0.0, 0.0, 0.0); cairo_rectangle(cr, 0, 0, icon_extents.width + icon_offset, icon_extents.height + icon_offset); cairo_fill (cr); offset = icon_offset * (n_icons - 1); for (i = 0; i < n_icons; i++) { cairo_set_source_surface (cr, drag_icon, -icon_extents.x + offset, -icon_extents.y + offset); cairo_rectangle (cr, offset, offset, icon_extents.width, icon_extents.height); cairo_fill (cr); offset -= icon_offset; } cairo_destroy (cr); cairo_surface_set_device_offset (multi_drag_icon, - (cell_x + 1), - (cell_y + 1)); gtk_drag_set_icon_surface (context, multi_drag_icon); cairo_surface_destroy (multi_drag_icon); } else { cairo_surface_set_device_offset (drag_icon, - (cell_x + 1), - (cell_y + 1)); gtk_drag_set_icon_surface (context, drag_icon); } cairo_surface_destroy (drag_icon); gtk_tree_path_free (tree_path); } else gtk_drag_set_icon_default (context); gtk_target_list_unref (target_list); } else { path_list_free (path_list); } } return TRUE; }