static gboolean emitKeyStroke(WebKitWebView* webView) { GdkEvent* pressEvent = gdk_event_new(GDK_KEY_PRESS); pressEvent->key.keyval = GDK_KEY_f; GdkWindow* window = gtk_widget_get_window(GTK_WIDGET(webView)); pressEvent->key.window = window; g_object_ref(pressEvent->key.window); #ifndef GTK_API_VERSION_2 GdkDeviceManager* manager = gdk_display_get_device_manager(gdk_window_get_display(window)); gdk_event_set_device(pressEvent, gdk_device_manager_get_client_pointer(manager)); #endif // When synthesizing an event, an invalid hardware_keycode value // can cause it to be badly processed by Gtk+. GdkKeymapKey* keys; gint n_keys; if (gdk_keymap_get_entries_for_keyval(gdk_keymap_get_default(), GDK_KEY_f, &keys, &n_keys)) { pressEvent->key.hardware_keycode = keys[0].keycode; g_free(keys); } GdkEvent* releaseEvent = gdk_event_copy(pressEvent); gtk_main_do_event(pressEvent); gdk_event_free(pressEvent); releaseEvent->key.type = GDK_KEY_RELEASE; gtk_main_do_event(releaseEvent); gdk_event_free(releaseEvent); return FALSE; }
static gboolean touch_release_in_button (GtkButton *button) { GtkButtonPrivate *priv; gint width, height; GdkEvent *event; gdouble x, y; priv = button->priv; event = gtk_get_current_event (); if (!event) return FALSE; if (event->type != GDK_TOUCH_END || event->touch.window != priv->event_window) { gdk_event_free (event); return FALSE; } gdk_event_get_coords (event, &x, &y); width = gdk_window_get_width (priv->event_window); height = gdk_window_get_height (priv->event_window); gdk_event_free (event); if (x >= 0 && x <= width && y >= 0 && y <= height) return TRUE; return FALSE; }
static gboolean colpalwidgetgtk_event(GtkWidget* glow, GdkEvent* event) { if (event->type == GDK_MOTION_NOTIFY) { GdkEvent* next = gdk_event_peek(); if (next && next->type == GDK_MOTION_NOTIFY) { gdk_event_free(next); return TRUE; } else if (next) gdk_event_free(next); } ((GlowDrawGtk*)((ColPalCtx*)((ColPalWidgetGtk*)glow)->colpal_ctx)->gdraw) ->event_handler(*event); return TRUE; }
static gboolean conversation_nick_clicked(PurpleConversation* conv, gchar* nick, guint button) { GdkEvent* next_event = NULL; PidginConversation* pidgin_conv = NULL; gint event_timeout = 100; /* milliseconds */ if (purple_conversation_get_type(conv) != PURPLE_CONV_TYPE_CHAT) { purple_debug_warning(USERCAST_PLUGIN_NAME, "Conversation `%s' is not a chat\n", conv->name); return FALSE; } if (!PIDGIN_IS_PIDGIN_CONVERSATION(conv)) { purple_debug_warning(USERCAST_PLUGIN_NAME, "Conversation `%s' is not a pidgin conversation\n", conv->name); return FALSE; } if (button != 1) return FALSE; /* Wait for either GDK_2BUTTON_EVENT or something else to arrive */ for (; event_timeout > 0; event_timeout--) { if ((next_event = gdk_event_peek())) break; g_usleep(1000); /* 1 millisecond */ } /* Pingin handles GDK_2BUTTON_PRESS separately */ if (next_event && next_event->type == GDK_2BUTTON_PRESS) { /* Remove GDK_2BUTTON_PRESS from event queue */ gdk_event_free(next_event); gdk_event_free(gdk_event_get()); pidgin_conv = PIDGIN_CONVERSATION(conv); cast_nick(pidgin_conv, nick); gtk_widget_grab_focus(pidgin_conv->entry); purple_debug_info(USERCAST_PLUGIN_NAME, "Casted user `%s' to `%s'\n", nick, conv->name); return TRUE; } return FALSE; }
/*! Wait for a click from one of the mouse button. \param blocking [in] : Blocking behavior. - When set to true, this method waits until a mouse button is pressed and then returns always true. - When set to false, returns true only if a mouse button is pressed, otherwise returns false. \return - true if a button was clicked. This is always the case if blocking is set to \e true. - false if no button was clicked. This can occur if blocking is set to \e false. */ bool vpDisplayGTK::getClick(bool blocking) { bool ret = false; if (displayHasBeenInitialized) { // flushDisplay() ; //int cpt =0; do { GdkEvent *ev = NULL; while ((ev = gdk_event_get())!=NULL){ //cpt++; // printf("event %d type %d on window %p My window %p\n", //cpt, ev->type, ev->any.window, widget->window); if (ev->any.window == widget->window && ev->type == GDK_BUTTON_PRESS){ ret = true ; //printf("Click detection\n"); } gdk_event_free(ev) ; } if (blocking){ flushDisplay(); vpTime::wait(100); } } while ( ret == false && blocking == true); } else { vpERROR_TRACE("GTK not initialized " ) ; throw(vpDisplayException(vpDisplayException::notInitializedError, "GTK not initialized")) ; } return ret; }
gboolean button_press_cb (GtkWidget* window, GdkEventButton* event) { (void) window; gint context; gboolean propagate = FALSE, sendev = FALSE; context = get_click_context(NULL); if(event->type == GDK_BUTTON_PRESS) { if(uzbl.state.last_button) gdk_event_free((GdkEvent *)uzbl.state.last_button); uzbl.state.last_button = (GdkEventButton *)gdk_event_copy((GdkEvent *)event); /* left click */ if(event->button == 1) { if((context & WEBKIT_HIT_TEST_RESULT_CONTEXT_EDITABLE)) send_event(FORM_ACTIVE, NULL, TYPE_NAME, "button1", NULL); else if((context & WEBKIT_HIT_TEST_RESULT_CONTEXT_DOCUMENT)) send_event(ROOT_ACTIVE, NULL, TYPE_NAME, "button1", NULL); else { sendev = TRUE; propagate = TRUE; } } else if(event->button == 2 && !(context & WEBKIT_HIT_TEST_RESULT_CONTEXT_EDITABLE)) { sendev = TRUE; propagate = TRUE; } else if(event->button > 3) { sendev = TRUE; propagate = TRUE; } if(sendev) { button_to_event(event->button, event->state, GDK_BUTTON_PRESS); } } if(event->type == GDK_2BUTTON_PRESS || event->type == GDK_3BUTTON_PRESS) { if(event->button == 1 && !(context & WEBKIT_HIT_TEST_RESULT_CONTEXT_EDITABLE) && (context & WEBKIT_HIT_TEST_RESULT_CONTEXT_DOCUMENT)) { sendev = TRUE; propagate = TRUE; } else if(event->button == 2 && !(context & WEBKIT_HIT_TEST_RESULT_CONTEXT_EDITABLE)) { sendev = TRUE; propagate = TRUE; } else if(event->button > 3) { sendev = TRUE; propagate = TRUE; } if(sendev) { button_to_event(event->button, event->state, event->type); } } return propagate; }
/* 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 structGraphicsScreen :: v_getMouseLocation (double *xWC, double *yWC) { #if cairo GdkEvent *gevent = gdk_display_get_event (d_display); if (gevent != NULL) { if (gevent -> type == GDK_BUTTON_RELEASE) { theMouseDown = false; } gdk_event_free (gevent); } gint xDC, yDC; gdk_window_get_pointer (d_window, & xDC, & yDC, NULL); Graphics_DCtoWC (this, xDC, yDC, xWC, yWC); #elif cocoa #elif win POINT pos; if (! GetCursorPos (& pos)) { Melder_warning (L"Cannot get cursor position."); return; } ScreenToClient (d_winWindow, & pos); Graphics_DCtoWC (this, pos. x, pos. y, xWC, yWC); #elif mac if (HIGetMousePosition != NULL && false) { // AVAILABLE_MAC_OS_X_VERSION_10_5_AND_LATER //Melder_casual ("HIGetMousePosition exists"); HIPoint mouseLoc; HIGetMousePosition (kHICoordSpaceWindow, GetWindowFromPort (d_macPort), & mouseLoc); Graphics_DCtoWC (this, mouseLoc. x, mouseLoc. y, xWC, yWC); } else { Point mouseLoc; GetMouse (& mouseLoc); // AVAILABLE_MAC_OS_X_VERSION_10_0_AND_LATER_BUT_DEPRECATED_IN_MAC_OS_X_VERSION_10_5 Graphics_DCtoWC (this, mouseLoc. h, mouseLoc. v, xWC, yWC); } #endif }
/* From gtkcontainer.c */ void _container_propagate_expose (GtkContainer *container, GtkWidget *child, GdkEventExpose *event) { GdkEvent *child_event; g_return_if_fail (GTK_IS_CONTAINER (container)); g_return_if_fail (GTK_IS_WIDGET (child)); g_return_if_fail (event != NULL); g_assert (child->parent == GTK_WIDGET (container)); if (GTK_WIDGET_DRAWABLE (child) && GTK_WIDGET_NO_WINDOW (child) && (child->window == event->window)&& AWN_IS_CAIRO_MENU_ITEM(child)) { child_event = gdk_event_new (GDK_EXPOSE); child_event->expose = *event; g_object_ref (child_event->expose.window); child_event->expose.region = gtk_widget_region_intersect (child, event->region); if (!gdk_region_empty (child_event->expose.region)) { gdk_region_get_clipbox (child_event->expose.region, &child_event->expose.area); gtk_widget_send_expose (child, child_event); } gdk_event_free (child_event); } }
static void day_selected_cb (GtkCalendar *calendar, gpointer user_data) { cairo_rectangle_int_t rect; GtkAllocation allocation; GtkWidget *popover; GdkEvent *event; event = gtk_get_current_event (); if (event->type != GDK_BUTTON_PRESS) return; gdk_window_coords_to_parent (event->button.window, event->button.x, event->button.y, &event->button.x, &event->button.y); gtk_widget_get_allocation (GTK_WIDGET (calendar), &allocation); rect.x = event->button.x - allocation.x; rect.y = event->button.y - allocation.y; rect.width = rect.height = 1; popover = create_popover (GTK_WIDGET (calendar), gtk_entry_new (), GTK_POS_BOTTOM); gtk_popover_set_pointing_to (GTK_POPOVER (popover), &rect); gtk_widget_show (popover); gdk_event_free (event); }
void ephy_gui_get_current_event (GdkEventType *otype, guint *ostate, guint *obutton) { GdkEvent *event; GdkEventType type = GDK_NOTHING; guint state = 0, button = (guint) - 1; event = gtk_get_current_event (); if (event != NULL) { type = event->type; if (type == GDK_KEY_PRESS || type == GDK_KEY_RELEASE) { state = event->key.state; } else if (type == GDK_BUTTON_PRESS || type == GDK_BUTTON_RELEASE || type == GDK_2BUTTON_PRESS || type == GDK_3BUTTON_PRESS) { button = event->button.button; state = event->button.state; } gdk_event_free (event); } if (otype) *otype = type; if (ostate) *ostate = state & gtk_accelerator_get_default_mod_mask (); if (obutton) *obutton = button; }
static void tap_and_hold_simulate_click (GtkWidget *w, gpointer btn_ptr) { GdkEvent *press; GdkEvent *release; guint button; button = GPOINTER_TO_UINT (btn_ptr); press = g_object_get_data (G_OBJECT (w), "press"); if (press) { /* Generate a release event for button 1 */ release = gdk_event_copy (press); release->button.type = GDK_BUTTON_RELEASE; release->button.state = GDK_BUTTON1_MASK; /* Make the press event right/middle click */ press->button.button = button; /* Release button 1 */ gtk_main_do_event (release); /* Simulate click */ gtk_main_do_event (press); /* Free the release event - the press one is * freed in tap_and_hold_button_press_filter() */ gdk_event_free (release); } }
void Ctrl::Event::Free() { if(event) { gdk_event_free(event); event = NULL; } }
/*! Wait for a click from one of the mouse button and get the position of the clicked image point. \param ip [out] : The coordinates of the clicked image point. \param blocking [in] : true for a blocking behaviour waiting a mouse button click, false for a non blocking behaviour. \return - true if a button was clicked. This is always the case if blocking is set to \e true. - false if no button was clicked. This can occur if blocking is set to \e false. */ bool vpDisplayGTK::getClick(vpImagePoint &ip, bool blocking) { bool ret = false; if (displayHasBeenInitialized) { double u, v ; do { GdkEvent *ev = NULL; while ((ev = gdk_event_get())!=NULL){ if (ev->any.window == widget->window && ev->type == GDK_BUTTON_PRESS) { u = ((GdkEventButton *)ev)->x ; v = ((GdkEventButton *)ev)->y ; ip.set_u( u ); ip.set_v( v ); ret = true ; } gdk_event_free(ev) ; } if (blocking){ flushDisplay(); vpTime::wait(100); } } while ( ret == false && blocking == true); } else { vpERROR_TRACE("GTK not initialized " ) ; throw(vpDisplayException(vpDisplayException::notInitializedError, "GTK not initialized")) ; } return ret ; }
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 void next_button_clicked (GtkWidget *button, SoliPrintPreview *preview) { GdkEvent *event; gint page; gint n_pages = get_n_pages (preview); event = gtk_get_current_event (); if (event->button.state & GDK_SHIFT_MASK) { page = n_pages - 1; } else { page = preview->cur_page + preview->n_columns; } goto_page (preview, MIN (page, n_pages - 1)); gtk_widget_grab_focus (GTK_WIDGET (preview->layout)); gdk_event_free (event); }
/** * ephy_node_view_popup: * @view: an #EphyNodeView widget * @menu: a #GtkMenu to be shown * * Triggers the popup of @menu in @view. **/ void ephy_node_view_popup (EphyNodeView *view, GtkWidget *menu) { GdkEvent *event; event = gtk_get_current_event (); if (event) { if (event->type == GDK_KEY_PRESS) { GdkEventKey *key = (GdkEventKey *) event; gtk_menu_popup (GTK_MENU (menu), NULL, NULL, ephy_gui_menu_position_tree_selection, view, 0, key->time); gtk_menu_shell_select_first (GTK_MENU_SHELL (menu), FALSE); } else if (event->type == GDK_BUTTON_PRESS) { GdkEventButton *button = (GdkEventButton *) event; gtk_menu_popup (GTK_MENU (menu), NULL, NULL, NULL, NULL, button->button, button->time); } gdk_event_free (event); } }
static void gtk_menu_button_clicked (GtkButton *button) { GtkMenuButton *menu_button = GTK_MENU_BUTTON (button); GtkMenuButtonPrivate *priv = menu_button->priv; gboolean active = TRUE; if (priv->menu && !gtk_widget_get_visible (priv->menu)) { GdkEvent *event; event = gtk_get_current_event (); popup_menu (menu_button, (event && event->type != GDK_BUTTON_RELEASE) ? (GdkEventButton *) event : NULL); if (!event || event->type == GDK_KEY_PRESS || event->type == GDK_KEY_RELEASE) gtk_menu_shell_select_first (GTK_MENU_SHELL (priv->menu), FALSE); if (event) gdk_event_free (event); } else if (priv->popover && !gtk_widget_get_visible (priv->popover)) gtk_widget_show (priv->popover); else active = FALSE; GTK_BUTTON_CLASS (gtk_menu_button_parent_class)->clicked (button); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), active); gtk_toggle_button_toggled (GTK_TOGGLE_BUTTON (button)); }
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); }
/* * Strategy to painting a Widget: * 1.) do not paint if there is no GtkWidget set * 2.) We assume that GTK_NO_WINDOW is set and that geometryChanged positioned * the widget correctly. ATM we do not honor the GraphicsContext translation. */ void Widget::paint(GraphicsContext* context, const IntRect&) { if (!gtkWidget()) return; GtkWidget* widget = gtkWidget(); ASSERT(GTK_WIDGET_NO_WINDOW(widget)); GdkEvent* event = gdk_event_new(GDK_EXPOSE); event->expose = *context->gdkExposeEvent(); event->expose.region = gtk_widget_region_intersect(widget, event->expose.region); /* * This will be unref'ed by gdk_event_free. */ g_object_ref(event->expose.window); /* * If we are going to paint do the translation and GtkAllocation manipulation. */ if (!gdk_region_empty(event->expose.region)) { gdk_region_get_clipbox(event->expose.region, &event->expose.area); gtk_widget_send_expose(widget, event); } gdk_event_free(event); }
static gboolean st_im_text_key_release_event (ClutterActor *actor, ClutterKeyEvent *event) { StIMText *self = ST_IM_TEXT (actor); StIMTextPrivate *priv = self->priv; ClutterText *clutter_text = CLUTTER_TEXT (actor); GdkEventKey *event_gdk; gboolean result = FALSE; if (clutter_text_get_editable (clutter_text)) { event_gdk = key_event_to_gdk (event); if (gtk_im_context_filter_keypress (priv->im_context, event_gdk)) { priv->need_im_reset = TRUE; result = TRUE; } gdk_event_free ((GdkEvent *)event_gdk); } if (!result && CLUTTER_ACTOR_CLASS (st_im_text_parent_class)->key_release_event) result = CLUTTER_ACTOR_CLASS (st_im_text_parent_class)->key_release_event (actor, event); return result; }
static gboolean gdk_mir_event_source_dispatch (GSource *g_source, GSourceFunc callback, gpointer user_data) { GdkMirEventSource *source = (GdkMirEventSource *) g_source; GdkEvent *event; /* First, run the queue of events from the thread */ gdk_mir_event_source_convert_events (source); /* Next, dispatch one single event from the display's queue. * * If there is more than one event then we will soon find ourselves * back here again. */ gdk_threads_enter (); event = gdk_display_get_event (source->display); if (event) { _gdk_event_emit (event); gdk_event_free (event); } gdk_threads_leave (); 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 void gtk_scale_button_popup (GtkWidget *widget) { GdkEvent *ev; ev = gdk_event_new (GDK_KEY_RELEASE); gtk_scale_popup (widget, ev, GDK_CURRENT_TIME); gdk_event_free (ev); }
static gboolean growwidgetgtk_event( GtkWidget *glow, GdkEvent *event) { if ( event->type == GDK_MOTION_NOTIFY) { gdk_display_flush( ((GlowDrawGtk *)((GrowCtx *)((GrowWidgetGtk *)glow)->grow_ctx)->gdraw)->display); GdkEvent *next = gdk_event_peek(); if ( next && next->type == GDK_MOTION_NOTIFY) { gdk_event_free( next); return TRUE; } else if ( next) gdk_event_free( next); } else if ( event->type == GDK_CONFIGURE) { ((GrowWidgetGtk *)glow)->scroll_configure = 1; } ((GlowDrawGtk *)((GrowCtx *)((GrowWidgetGtk *)glow)->grow_ctx)->gdraw)->event_handler( *event); return TRUE; }
static void clutter_backend_gdk_free_event_data (ClutterBackend *backend, ClutterEvent *event) { GdkEvent *gdk_event; gdk_event = _clutter_event_get_platform_data (event); if (gdk_event != NULL) gdk_event_free (gdk_event); }
void _fcitx_im_context_forward_key_cb(FcitxClient* im, guint keyval, guint state, gint type, void* user_data) { FcitxLog(LOG_LEVEL, "_fcitx_im_context_forward_key_cb"); FcitxIMContext* context = FCITX_IM_CONTEXT(user_data); FcitxKeyEventType tp = (FcitxKeyEventType) type; GdkEventKey* event = _create_gdk_event(context, keyval, state, tp); event->state |= FcitxKeyState_IgnoredMask; gdk_event_put((GdkEvent *)event); gdk_event_free((GdkEvent *)event); }
JNIEXPORT void JNICALL Java_gnu_java_awt_dnd_peer_gtk_GtkDragSourceContextPeer_nativeStartDrag (JNIEnv *env, jobject obj, jobject img, jint x, jint y, jint act, jstring target) { void *ptr; const gchar *data; GtkTargetEntry tar[1]; GdkEvent *event; GdkPixbuf *image = NULL; GdkDragContext *context = NULL; GdkDragAction action = GDK_ACTION_DEFAULT; gdk_threads_enter (); ptr = NSA_GET_GLOBAL_REF (env, obj); data = (*env)->GetStringUTFChars (env, target, NULL); tar[0].target = (gchar *) data; event = gdk_event_new (GDK_ALL_EVENTS_MASK); switch (act) { case ACTION_COPY: action = GDK_ACTION_COPY; break; case ACTION_MOVE: action = GDK_ACTION_MOVE; break; case ACTION_COPY_OR_MOVE: action = GDK_ACTION_COPY | GDK_ACTION_MOVE; break; case ACTION_LINK: action = GDK_ACTION_LINK; break; default: action = GDK_ACTION_DEFAULT; } gtk_drag_highlight (widget); context = gtk_drag_begin (widget, gtk_target_list_new (tar, sizeof (tar) / sizeof (GtkTargetEntry)), action, GDK_BUTTON1_MASK | GDK_BUTTON2_MASK, event); if (img != NULL) { image = cp_gtk_image_get_pixbuf (env, img); gtk_drag_set_icon_pixbuf (context, image, x, y); } gdk_event_free (event); (*env)->ReleaseStringUTFChars (env, target, data); gdk_threads_leave (); }
static void dispatchEvent(GdkEvent* event) { webkit_web_frame_layout(mainFrame); WebKitWebView* view = webkit_web_frame_get_web_view(mainFrame); if (!view) { gdk_event_free(event); return; } gtk_main_do_event(event); if (!currentDragSourceContext) { gdk_event_free(event); return; } if (event->type == GDK_MOTION_NOTIFY) { // WebKit has called gtk_drag_start(), but because the main loop isn't // running GDK internals don't know that the drag has started yet. Pump // the main loop a little bit so that GDK is in the correct state. while (gtk_events_pending()) gtk_main_iteration(); // Simulate a drag motion on the top-level GDK window. GtkWidget* parentWidget = gtk_widget_get_parent(GTK_WIDGET(view)); GdkWindow* parentWidgetWindow = gtk_widget_get_window(parentWidget); gdk_drag_motion(currentDragSourceContext, parentWidgetWindow, GDK_DRAG_PROTO_XDND, event->motion.x_root, event->motion.y_root, gdk_drag_context_get_selected_action(currentDragSourceContext), gdk_drag_context_get_actions(currentDragSourceContext), GDK_CURRENT_TIME); } else if (currentDragSourceContext && event->type == GDK_BUTTON_RELEASE) { // We've released the mouse button, we should just be able to spin the // event loop here and have GTK+ send the appropriate notifications for // the end of the drag. while (gtk_events_pending()) gtk_main_iteration(); } gdk_event_free(event); }
static gboolean handle_event_later (EmitLater *data) { GtkWidget *canvas = GTK_WIDGET(data->arg1); GdkEvent *event = (GdkEvent *)data->arg2; handle_event(canvas, event); gdk_event_free(event); g_free(data); return FALSE; }