static gint gtk_combo_button_release (GtkWidget * widget, GdkEvent * event, GtkCombo * combo) { GtkWidget *child; if ((combo->current_button != 0) && (event->button.button == 1)) { /* This was the initial button press */ GdkEventCrossing tmp_event; combo->current_button = 0; if (widget != combo->button) gtk_widget_event (combo->button, event); /* Un-pre-hightlight */ tmp_event.type = GDK_LEAVE_NOTIFY; tmp_event.window = combo->button->window; tmp_event.send_event = TRUE; tmp_event.subwindow = NULL; tmp_event.detail = GDK_NOTIFY_ANCESTOR; gtk_widget_event (combo->button, (GdkEvent *)&tmp_event); /* Check to see if we released inside the button */ child = gtk_get_event_widget ((GdkEvent*) event); while (child && child != (combo->button)) child = child->parent; if (child == combo->button) { gtk_grab_add (combo->popwin); gdk_pointer_grab (combo->popwin->window, TRUE, GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_MASK, NULL, NULL, GDK_CURRENT_TIME); return FALSE; } } else { /* The user has clicked inside the popwin and released */ if (GTK_WIDGET_HAS_GRAB (combo->popwin)) { gtk_grab_remove (combo->popwin); gdk_pointer_ungrab (event->button.time); } } gtk_widget_hide (combo->popwin); return TRUE; }
/* * This action is the pressing of the button on the combo box. * The behavior is different depending on whether the list is being * displayed or removed. * * A button press event is simulated on the appropriate widget and * a button release event is simulated in an idle function. */ static gboolean idle_do_action (gpointer data) { GtkCombo *combo; GtkWidget *action_widget; GtkWidget *widget; GailCombo *gail_combo; gboolean do_popup; GdkEvent tmp_event; gail_combo = GAIL_COMBO (data); gail_combo->action_idle_handler = 0; widget = GTK_ACCESSIBLE (gail_combo)->widget; if (widget == NULL /* State is defunct */ || !gtk_widget_get_sensitive (widget) || !gtk_widget_get_visible (widget)) return FALSE; combo = GTK_COMBO (widget); do_popup = !gtk_widget_get_mapped (combo->popwin); tmp_event.button.type = GDK_BUTTON_PRESS; tmp_event.button.window = widget->window; tmp_event.button.button = 1; tmp_event.button.send_event = TRUE; tmp_event.button.time = GDK_CURRENT_TIME; tmp_event.button.axes = NULL; if (do_popup) { /* Pop up list */ action_widget = combo->button; gtk_widget_event (action_widget, &tmp_event); /* FIXME !*/ g_idle_add (_gail_combo_button_release, combo); } else { /* Pop down list */ tmp_event.button.window = combo->list->window; gdk_window_set_user_data (combo->list->window, combo->button); action_widget = combo->popwin; gtk_widget_event (action_widget, &tmp_event); /* FIXME !*/ g_idle_add (_gail_combo_popup_release, combo); } return FALSE; }
gint bar_pane_keywords_event(GtkWidget *bar, GdkEvent *event) { PaneKeywordsData *pkd; pkd = g_object_get_data(G_OBJECT(bar), "pane_data"); if (!pkd) return FALSE; #if GTK_CHECK_VERSION(2,20,0) if (gtk_widget_has_focus(pkd->keyword_view)) return gtk_widget_event(pkd->keyword_view, event); #else if (GTK_WIDGET_HAS_FOCUS(pkd->keyword_view)) return gtk_widget_event(pkd->keyword_view, event); #endif return FALSE; }
static gint columns_expose(GtkWidget *widget, GdkEventExpose *event) { Columns *cols; ColumnsChild *child; GList *children; GdkEventExpose child_event; g_return_val_if_fail(widget != NULL, FALSE); g_return_val_if_fail(IS_COLUMNS(widget), FALSE); g_return_val_if_fail(event != NULL, FALSE); if (GTK_WIDGET_DRAWABLE(widget)) { cols = COLUMNS(widget); child_event = *event; for (children = cols->children; children && (child = children->data); children = children->next) { if (child->widget && GTK_WIDGET_DRAWABLE(child->widget) && GTK_WIDGET_NO_WINDOW(child->widget) && gtk_widget_intersect(child->widget, &event->area, &child_event.area)) gtk_widget_event(child->widget, (GdkEvent *)&child_event); } } return FALSE; }
/* Cut and paste from gtkwindow.c */ static void send_focus_change (GtkWidget *widget, gboolean in) { GdkEvent *fevent = gdk_event_new (GDK_FOCUS_CHANGE); #if !GTK_CHECK_VERSION (2,21,0) g_object_ref (widget); if (in) GTK_WIDGET_SET_FLAGS (widget, GTK_HAS_FOCUS); else GTK_WIDGET_UNSET_FLAGS (widget, GTK_HAS_FOCUS); #endif fevent->focus_change.type = GDK_FOCUS_CHANGE; fevent->focus_change.window = g_object_ref (gtk_widget_get_window (widget)); fevent->focus_change.in = in; #if !GTK_CHECK_VERSION (2,21,0) gtk_widget_event (widget, fevent); g_object_notify (G_OBJECT (widget), "has-focus"); g_object_unref (widget); #else gtk_widget_send_focus_change (widget, fevent); #endif gdk_event_free (fevent); }
void file_list_key_press(GtkWidget *widget, GdkEventKey *event, gpointer data) { if( event->keyval == GDK_Return ) { pthread_create(&load_thread, NULL, add_selected_to_playlist_and_play, NULL); DEBUG_MSG("Adding all selected files"); } else { gboolean forward = TRUE; DEBUG_MSG("Key pressed: %i", event->keyval); switch(event->keyval) { case GDK_Page_Up: case GDK_Page_Down: case GDK_Up: case GDK_Down: case GDK_Return: forward = FALSE; break; }; if(forward) { DEBUG_MSG("Forwarding to search field"); gtk_widget_event( GTK_WIDGET(search_field), (GdkEvent*)event); g_signal_stop_emission_by_name(GTK_OBJECT(widget), "key-press-event"); } return TRUE; } }
static gint panels_expose(GtkWidget *widget, GdkEventExpose *event) { Panels *panels; GtkWidget *child; GList *children; GdkEventExpose child_event; g_return_val_if_fail(widget != NULL, FALSE); g_return_val_if_fail(IS_PANELS(widget), FALSE); g_return_val_if_fail(event != NULL, FALSE); if (GTK_WIDGET_DRAWABLE(widget)) { panels = PANELS(widget); child_event = *event; for (children = panels->children; children && (child = children->data); children = children->next) { if (child && GTK_WIDGET_DRAWABLE(child) && GTK_WIDGET_NO_WINDOW(child) && gtk_widget_intersect(child, &event->area, &child_event.area)) gtk_widget_event(child, (GdkEvent *)&child_event); } } return FALSE; }
static gboolean button_press_event_cb (GtkWidget *tree, GdkEventButton *event, EomPluginManager *pm) { /* We want the treeview selection to be updated before showing the menu. * This code is evil, thanks to Federico Mena Quintero's black magic. * See: http://mail.gnome.org/archives/gtk-devel-list/2006-February/msg00168.html * FIXME: Let's remove it asap. */ static gboolean in_press = FALSE; gboolean handled; if (in_press) return FALSE; /* we re-entered */ if (GDK_BUTTON_PRESS != event->type || 3 != event->button) return FALSE; /* let the normal handler run */ in_press = TRUE; handled = gtk_widget_event (tree, (GdkEvent *) event); in_press = FALSE; if (!handled) return FALSE; /* The selection is fully updated by now */ show_tree_popup_menu (GTK_TREE_VIEW (tree), pm, event); return TRUE; }
void _exo_gtk_widget_send_focus_change (GtkWidget *widget, gboolean in) { GdkEvent *fevent; #if !GTK_CHECK_VERSION(2, 22, 0) g_object_ref (G_OBJECT (widget)); #endif gtk_widget_set_can_focus (widget, in); fevent = gdk_event_new (GDK_FOCUS_CHANGE); fevent->focus_change.type = GDK_FOCUS_CHANGE; fevent->focus_change.window = g_object_ref (gtk_widget_get_window (widget)); fevent->focus_change.in = in; #if GTK_CHECK_VERSION(2, 22, 0) gtk_widget_send_focus_change (widget, fevent); #else if (in) GTK_OBJECT_FLAGS (widget) |= GTK_HAS_FOCUS; else GTK_OBJECT_FLAGS (widget) &= ~(GTK_HAS_FOCUS); gtk_widget_event (widget, fevent); g_object_notify (G_OBJECT (widget), "has-focus"); g_object_unref (G_OBJECT (widget)); #endif gdk_event_free (fevent); }
static gint awt_gtk_panel_expose (GtkWidget *widget, GdkEventExpose *event) { AWTGtkPanel *panel; GtkWidget *child; GdkEventExpose child_event; GList *children; g_return_val_if_fail (widget != NULL, FALSE); g_return_val_if_fail (event != NULL, FALSE); if (GTK_WIDGET_DRAWABLE (widget)) { panel = AWT_GTK_PANEL (widget); child_event = *event; children = panel->children; while (children) { child = children->data; children = children->next; if (GTK_WIDGET_NO_WINDOW (child) && gtk_widget_intersect (child, &event->area, &child_event.area)) gtk_widget_event (child, (GdkEvent*) &child_event); } } return FALSE; }
static gboolean gstyle_slidein_event_box_key_pressed_cb (GstyleSlidein *self, GdkEventKey *event, GtkWidget *widget) { GtkWidget *focus; g_assert (GSTYLE_IS_SLIDEIN (self)); g_assert (event != NULL); g_assert (GTK_IS_WIDGET (widget)); focus = gtk_window_get_focus (GTK_WINDOW (gtk_widget_get_toplevel (widget))); if (focus == NULL) return GDK_EVENT_PROPAGATE; if (event->keyval == GDK_KEY_Escape && !GTK_IS_ENTRY (focus)) { gstyle_slidein_reveal_slide (self, FALSE); return GDK_EVENT_STOP; } if (gtk_widget_is_ancestor (focus, widget)) return gtk_widget_event (focus, (GdkEvent*) event); return GDK_EVENT_PROPAGATE; }
static gboolean gnm_notebook_button_press (GtkWidget *widget, GdkEventButton *event) { GnmNotebook *nb = GNM_NOTEBOOK (widget); unsigned ui; for (ui = 0; /* Nothing */; ui++) { GtkWidget *child = gnm_notebook_get_nth_label (nb, ui); GtkAllocation child_allocation; if (!child) break; if (!gtk_widget_get_child_visible (child)) continue; gtk_widget_get_allocation (child, &child_allocation); if (event->x >= child_allocation.x && event->x < child_allocation.x + child_allocation.width && event->y >= child_allocation.y && event->y < child_allocation.y + child_allocation.height) { if (0) g_printerr ("Button %d pressed\n", ui); if (gtk_widget_event (child, (GdkEvent*)event)) return TRUE; else break; } } return GTK_WIDGET_CLASS(gnm_notebook_parent_class) ->button_press_event (widget, event); }
static gboolean gpw_key_press_event (GtkWidget *box, GdkEventKey *key_event) { GncPopupEntry *widget = GNC_POPUP_ENTRY (box); GdkEvent tmp_event; if (key_event->keyval == GDK_Escape) { widget->editing_canceled = TRUE; gtk_cell_editable_editing_done (GTK_CELL_EDITABLE (widget)); gtk_cell_editable_remove_widget (GTK_CELL_EDITABLE (widget)); return TRUE; } gtk_widget_grab_focus (widget->entry); /* Hackish :/ Synthesize a key press event for the entry. */ memcpy (&tmp_event, key_event, sizeof (GdkEventKey)); tmp_event.key.window = widget->entry->window; tmp_event.key.send_event = TRUE; gtk_widget_event (widget->entry, &tmp_event); return GTK_WIDGET_CLASS (parent_class)->key_press_event (GTK_WIDGET (widget), key_event); }
static void send_focus_event (MateIconTextItem *iti, gboolean in) { MateIconTextItemPrivate *priv; GtkWidget *widget; gboolean has_focus; GdkEvent fake_event; g_return_if_fail (in == FALSE || in == TRUE); priv = iti->_priv; if (priv->entry == NULL) { g_assert (!in); return; } widget = GTK_WIDGET (priv->entry); has_focus = GTK_WIDGET_HAS_FOCUS (widget); if (has_focus == in) { return; } memset (&fake_event, 0, sizeof (fake_event)); fake_event.focus_change.type = GDK_FOCUS_CHANGE; fake_event.focus_change.window = widget->window; fake_event.focus_change.in = in; gtk_widget_event (widget, &fake_event); /* FIXME: this is failing */ #if 0 g_return_if_fail (GTK_WIDGET_HAS_FOCUS (widget) == in); #endif }
static gint _gail_combo_button_release (gpointer data) { GtkCombo *combo; GtkWidget *action_widget; GdkEvent tmp_event; GDK_THREADS_ENTER (); combo = GTK_COMBO (data); if (combo->current_button == 0) { GDK_THREADS_LEAVE (); return FALSE; } tmp_event.button.type = GDK_BUTTON_RELEASE; tmp_event.button.button = 1; tmp_event.button.window = combo->list->window; tmp_event.button.time = GDK_CURRENT_TIME; gdk_window_set_user_data (combo->list->window, combo->button); action_widget = combo->list; gtk_widget_event (action_widget, &tmp_event); GDK_THREADS_LEAVE (); return FALSE; }
void _exo_gtk_widget_send_focus_change (GtkWidget *widget, gboolean in) { GdkEvent *fevent; g_object_ref (G_OBJECT (widget)); if (in) GTK_WIDGET_SET_FLAGS (widget, GTK_HAS_FOCUS); else GTK_WIDGET_UNSET_FLAGS (widget, GTK_HAS_FOCUS); fevent = gdk_event_new (GDK_FOCUS_CHANGE); fevent->focus_change.type = GDK_FOCUS_CHANGE; fevent->focus_change.window = g_object_ref (widget->window); fevent->focus_change.in = in; gtk_widget_event (widget, fevent); g_object_notify (G_OBJECT (widget), "has-focus"); g_object_unref (G_OBJECT (widget)); gdk_event_free (fevent); }
static void gtk_scale_button_release_grab (GtkScaleButton *button, GdkEventButton *event) { GdkEventButton *e; GdkDisplay *display; GtkScaleButtonPrivate *priv; priv = button->priv; /* ungrab focus */ display = gtk_widget_get_display (GTK_WIDGET (button)); gdk_display_keyboard_ungrab (display, event->time); gdk_display_pointer_ungrab (display, event->time); gtk_grab_remove (priv->dock); /* hide again */ gtk_widget_hide (priv->dock); priv->timeout = FALSE; e = (GdkEventButton *) gdk_event_copy ((GdkEvent *) event); e->window = GTK_WIDGET (button)->window; e->type = GDK_BUTTON_RELEASE; gtk_widget_event (GTK_WIDGET (button), (GdkEvent *) e); e->window = event->window; gdk_event_free ((GdkEvent *) e); }
static gboolean gimp_curves_tool_key_press (GimpTool *tool, GdkEventKey *kevent, GimpDisplay *display) { GimpCurvesTool *c_tool = GIMP_CURVES_TOOL (tool); return gtk_widget_event (c_tool->graph, (GdkEvent *) kevent); }
static gboolean nemo_context_menu_menu_item_motion (GtkWidget *widget, GdkEventMotion *event) { g_return_val_if_fail (event != NULL, FALSE); update_toggle_appearance_from_event (widget, event->x, event->y, TRUE); return gtk_widget_event (gtk_widget_get_parent (widget), (GdkEvent *) event); }
void PageClientImpl::doneWithTouchEvent(const NativeWebTouchEvent& event, bool wasEventHandled) { if (wasEventHandled) return; #if HAVE(GTK_GESTURES) GestureController& gestureController = webkitWebViewBaseGestureController(WEBKIT_WEB_VIEW_BASE(m_viewWidget)); if (gestureController.handleEvent(event.nativeEvent())) return; #endif // Emulate pointer events if unhandled. const GdkEvent* touchEvent = event.nativeEvent(); if (!touchEvent->touch.emulating_pointer) return; GUniquePtr<GdkEvent> pointerEvent; if (touchEvent->type == GDK_TOUCH_UPDATE) { pointerEvent.reset(gdk_event_new(GDK_MOTION_NOTIFY)); pointerEvent->motion.time = touchEvent->touch.time; pointerEvent->motion.x = touchEvent->touch.x; pointerEvent->motion.y = touchEvent->touch.y; pointerEvent->motion.x_root = touchEvent->touch.x_root; pointerEvent->motion.y_root = touchEvent->touch.y_root; pointerEvent->motion.state = touchEvent->touch.state | GDK_BUTTON1_MASK; } else { switch (touchEvent->type) { case GDK_TOUCH_END: pointerEvent.reset(gdk_event_new(GDK_BUTTON_RELEASE)); pointerEvent->button.state = touchEvent->touch.state | GDK_BUTTON1_MASK; break; case GDK_TOUCH_BEGIN: pointerEvent.reset(gdk_event_new(GDK_BUTTON_PRESS)); break; default: ASSERT_NOT_REACHED(); } pointerEvent->button.button = 1; pointerEvent->button.time = touchEvent->touch.time; pointerEvent->button.x = touchEvent->touch.x; pointerEvent->button.y = touchEvent->touch.y; pointerEvent->button.x_root = touchEvent->touch.x_root; pointerEvent->button.y_root = touchEvent->touch.y_root; } gdk_event_set_device(pointerEvent.get(), gdk_event_get_device(touchEvent)); gdk_event_set_source_device(pointerEvent.get(), gdk_event_get_source_device(touchEvent)); pointerEvent->any.window = GDK_WINDOW(g_object_ref(touchEvent->any.window)); pointerEvent->any.send_event = TRUE; gtk_widget_event(m_viewWidget, pointerEvent.get()); }
/** * gtk_search_bar_handle_event: * @bar: a #GtkSearchBar * @event: a #GdkEvent containing key press events * * This function should be called when the top-level * window which contains the search bar received a key event. * * If the key event is handled by the search bar, the bar will * be shown, the entry populated with the entered text and %GDK_EVENT_STOP * will be returned. The caller should ensure that events are * not propagated further. * * If no entry has been connected to the search bar, using * gtk_search_bar_connect_entry(), this function will return * immediately with a warning. * * ## Showing the search bar on key presses * * |[<!-- language="C" --> * static gboolean * on_key_press_event (GtkWidget *widget, * GdkEvent *event, * gpointer user_data) * { * GtkSearchBar *bar = GTK_SEARCH_BAR (user_data); * return gtk_search_bar_handle_event (bar, event); * } * * g_signal_connect (window, * "key-press-event", * G_CALLBACK (on_key_press_event), * search_bar); * ]| * * Returns: %GDK_EVENT_STOP if the key press event resulted * in text being entered in the search entry (and revealing * the search bar if necessary), %GDK_EVENT_PROPAGATE otherwise. * * Since: 3.10 */ gboolean gtk_search_bar_handle_event (GtkSearchBar *bar, GdkEvent *event) { GtkSearchBarPrivate *priv = gtk_search_bar_get_instance_private (bar); guint keyval; gboolean handled; gboolean preedit_changed; guint preedit_change_id; gboolean res; char *old_text, *new_text; if (priv->entry == NULL) { g_warning ("The search bar does not have an entry connected to it. Call gtk_search_bar_connect_entry() to connect one."); return GDK_EVENT_PROPAGATE; } /* Exit early if the search bar is already shown, * the event doesn't contain a key press, * or the event is a navigation or space bar key press */ if (priv->reveal_child || !gdk_event_get_keyval (event, &keyval) || is_keynav_event (event, keyval) || keyval == GDK_KEY_space || keyval == GDK_KEY_Menu) return GDK_EVENT_PROPAGATE; if (!gtk_widget_get_realized (priv->entry)) gtk_widget_realize (priv->entry); handled = GDK_EVENT_PROPAGATE; preedit_changed = FALSE; preedit_change_id = g_signal_connect (priv->entry, "preedit-changed", G_CALLBACK (preedit_changed_cb), &preedit_changed); old_text = g_strdup (gtk_entry_get_text (GTK_ENTRY (priv->entry))); res = gtk_widget_event (priv->entry, event); new_text = g_strdup (gtk_entry_get_text (GTK_ENTRY (priv->entry))); g_signal_handler_disconnect (priv->entry, preedit_change_id); if ((res && g_strcmp0 (new_text, old_text) != 0) || preedit_changed) { handled = GDK_EVENT_STOP; gtk_revealer_set_reveal_child (GTK_REVEALER (priv->revealer), TRUE); } g_free (old_text); g_free (new_text); return handled; }
static gboolean key_press_popup_cb (GtkWidget *widget, GdkEventKey *event, gpointer data) { GncItemEdit *item_edit = GNC_ITEM_EDIT (data); g_signal_stop_emission_by_name (widget, "key_press_event"); gtk_widget_event (GTK_WIDGET(item_edit->sheet), (GdkEvent *) event); return TRUE; }
static gint bar_pane_comment_event(GtkWidget *bar, GdkEvent *event) { PaneCommentData *pcd; pcd = g_object_get_data(G_OBJECT(bar), "pane_data"); if (!pcd) return FALSE; if (gtk_widget_has_focus(pcd->comment_view)) return gtk_widget_event(pcd->comment_view, event); return FALSE; }
static gint bar_pane_gps_event(GtkWidget *bar, GdkEvent *event) { PaneGPSData *pgd; pgd = g_object_get_data(G_OBJECT(bar), "pane_data"); if (!pgd) return FALSE; if (GTK_WIDGET_HAS_FOCUS(pgd->widget)) return gtk_widget_event(GTK_WIDGET(pgd->widget), event); return FALSE; }
gint bar_pane_keywords_event(GtkWidget *bar, GdkEvent *event) { PaneKeywordsData *pkd; pkd = g_object_get_data(G_OBJECT(bar), "pane_data"); if (!pkd) return FALSE; if (gtk_widget_has_focus(pkd->keyword_view)) return gtk_widget_event(pkd->keyword_view, event); return FALSE; }
static void show_search () { GtkWidget *w, *f, *a, *e; GdkEvent *fev; w = gtk_window_new (GTK_WINDOW_POPUP); gtk_window_set_transient_for (GTK_WINDOW (w), GTK_WINDOW (gtk_widget_get_toplevel (text_view))); gtk_window_set_position (GTK_WINDOW (w), GTK_WIN_POS_CENTER_ON_PARENT); /* next two lines needs for get focus to search window */ gtk_window_set_type_hint (GTK_WINDOW (w), GDK_WINDOW_TYPE_HINT_UTILITY); gtk_window_set_modal (GTK_WINDOW (w), TRUE); g_signal_connect (G_OBJECT (w), "key-press-event", G_CALLBACK (search_key_cb), w); f = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (f), GTK_SHADOW_ETCHED_IN); gtk_container_add (GTK_CONTAINER (w), f); a = gtk_alignment_new (0.5, 0.5, 1.0, 1.0); gtk_alignment_set_padding (GTK_ALIGNMENT (a), 2, 2, 2, 2); gtk_container_add (GTK_CONTAINER (f), a); e = gtk_entry_new (); if (pattern) gtk_entry_set_text (GTK_ENTRY (e), pattern); gtk_container_add (GTK_CONTAINER (a), e); g_signal_connect (G_OBJECT (e), "activate", G_CALLBACK (do_search), w); g_signal_connect (G_OBJECT (e), "changed", G_CALLBACK (search_changed), NULL); g_signal_connect (G_OBJECT (e), "key-press-event", G_CALLBACK (search_key_cb), w); gtk_widget_show_all (w); /* send focus event to search entry (so complex due to popup window) */ fev = gdk_event_new (GDK_FOCUS_CHANGE); fev->focus_change.type = GDK_FOCUS_CHANGE; fev->focus_change.in = TRUE; fev->focus_change.window = gtk_widget_get_window (e); if (fev->focus_change.window != NULL) g_object_ref (fev->focus_change.window); #if GTK_CHECK_VERSION(2,22,0) gtk_widget_send_focus_change (e, fev); #else g_object_ref (e); GTK_OBJECT_FLAGS (e) |= GTK_HAS_FOCUS; gtk_widget_event (e, fev); g_object_notify (G_OBJECT (e), "has-focus"); g_object_unref (e); #endif gdk_event_free (fev); }
static gboolean scroll_callback(GtkWidget *widget, GdkEvent *event, gpointer data){ static gboolean bret; static GdkEvent tmp; tmp = *event; if(tmp.scroll.direction == GDK_SCROLL_SMOOTH){ tmp.scroll.direction = event->scroll.delta_y > 0 ? GDK_SCROLL_DOWN : GDK_SCROLL_UP; } gtk_widget_event(g_FRManager.spice, &tmp); g_signal_emit_by_name(g_FRManager.spice, "scroll-event", &tmp, &bret); return TRUE; }
static void DispatchSelectionNotifyEvent(GtkWidget *widget, XEvent *xevent) { GdkEvent event; event.selection.type = GDK_SELECTION_NOTIFY; event.selection.window = widget->window; event.selection.selection = gdk_x11_xatom_to_atom(xevent->xselection.selection); event.selection.target = gdk_x11_xatom_to_atom(xevent->xselection.target); event.selection.property = gdk_x11_xatom_to_atom(xevent->xselection.property); event.selection.time = xevent->xselection.time; gtk_widget_event(widget, &event); }
void gnc_item_edit_focus_out (GncItemEdit *item_edit) { GdkEventFocus ev; g_return_if_fail (item_edit != NULL); g_return_if_fail (GNC_IS_ITEM_EDIT(item_edit)); ev.type = GDK_FOCUS_CHANGE; ev.window = gtk_widget_get_window (GTK_WIDGET (item_edit->sheet)); ev.in = FALSE; gtk_widget_event (item_edit->editor, (GdkEvent*) &ev); }
static void DispatchPropertyNotifyEvent(GtkWidget *widget, XEvent *xevent) { if (((GdkWindowObject *) widget->window)->event_mask & GDK_PROPERTY_CHANGE_MASK) { GdkEvent event; event.property.type = GDK_PROPERTY_NOTIFY; event.property.window = widget->window; event.property.atom = gdk_x11_xatom_to_atom(xevent->xproperty.atom); event.property.time = xevent->xproperty.time; event.property.state = xevent->xproperty.state; gtk_widget_event(widget, &event); } }