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