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 WebViewTest::keyStroke(unsigned keyVal, unsigned keyModifiers)
{
g_assert(m_parentWindow);
GtkWidget* viewWidget = GTK_WIDGET(m_webView);
g_assert(gtk_widget_get_realized(viewWidget));
GOwnPtr<GdkEvent> event(gdk_event_new(GDK_KEY_PRESS));
event->key.keyval = keyVal;
event->key.time = GDK_CURRENT_TIME;
event->key.window = gtk_widget_get_window(viewWidget);
g_object_ref(event->key.window);
gdk_event_set_device(event.get(), gdk_device_manager_get_client_pointer(gdk_display_get_device_manager(gtk_widget_get_display(viewWidget))));
event->key.state = keyModifiers;
// When synthesizing an event, an invalid hardware_keycode value can cause it to be badly processed by GTK+.
GOwnPtr<GdkKeymapKey> keys;
int keysCount;
if (gdk_keymap_get_entries_for_keyval(gdk_keymap_get_default(), keyVal, &keys.outPtr(), &keysCount))
event->key.hardware_keycode = keys.get()[0].keycode;
gtk_main_do_event(event.get());
event->key.type = GDK_KEY_RELEASE;
gtk_main_do_event(event.get());
}
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;
}
void doMouseButtonEvent(GtkWidget* widget, GdkEventType eventType, int x, int y, unsigned int button, unsigned int modifiers)
{
g_assert(gtk_widget_get_realized(widget));
GdkEvent* event = gdk_event_new(eventType);
event->button.window = gtk_widget_get_window(widget);
g_object_ref(event->button.window);
event->button.time = GDK_CURRENT_TIME;
event->button.x = x;
event->button.y = y;
event->button.axes = 0;
event->button.state = modifiers;
event->button.button = button;
#ifndef GTK_API_VERSION_2
event->button.device = gdk_device_manager_get_client_pointer(gdk_display_get_device_manager(gtk_widget_get_display(widget)));
#endif
int xRoot, yRoot;
gdk_window_get_root_coords(gtk_widget_get_window(widget), x, y, &xRoot, &yRoot);
event->button.x_root = xRoot;
event->button.y_root = yRoot;
gtk_main_do_event(event);
}
static void
glade_app_event_handler (GdkEvent *event, gpointer data)
{
if (glade_app_do_event (event)) return;
gtk_main_do_event (event);
}
void WebViewTest::doMouseButtonEvent(GdkEventType eventType, int x, int y, unsigned button, unsigned mouseModifiers)
{
g_assert(m_parentWindow);
GtkWidget* viewWidget = GTK_WIDGET(m_webView);
g_assert(gtk_widget_get_realized(viewWidget));
GOwnPtr<GdkEvent> event(gdk_event_new(eventType));
event->button.window = gtk_widget_get_window(viewWidget);
g_object_ref(event->button.window);
event->button.time = GDK_CURRENT_TIME;
event->button.x = x;
event->button.y = y;
event->button.axes = 0;
event->button.state = mouseModifiers;
event->button.button = button;
event->button.device = gdk_device_manager_get_client_pointer(gdk_display_get_device_manager(gtk_widget_get_display(viewWidget)));
int xRoot, yRoot;
gdk_window_get_root_coords(gtk_widget_get_window(viewWidget), x, y, &xRoot, &yRoot);
event->button.x_root = xRoot;
event->button.y_root = yRoot;
gtk_main_do_event(event.get());
}
static void
sp_kde_gdk_event_handler (GdkEvent *event)
{
if (SPKDEModal) {
// KDE widget is modal, filter events
switch (event->type) {
case GDK_NOTHING:
case GDK_DELETE:
case GDK_SCROLL:
case GDK_BUTTON_PRESS:
case GDK_2BUTTON_PRESS:
case GDK_3BUTTON_PRESS:
case GDK_BUTTON_RELEASE:
case GDK_KEY_PRESS:
case GDK_KEY_RELEASE:
case GDK_DRAG_STATUS:
case GDK_DRAG_ENTER:
case GDK_DRAG_LEAVE:
case GDK_DRAG_MOTION:
case GDK_DROP_START:
case GDK_DROP_FINISHED:
return;
break;
default:
break;
}
}
gtk_main_do_event (event);
}
static void main_do_event(GdkEvent *event, wxArrayPtrVoid *queue)
{
switch (event->type)
{
case GDK_NOTHING:
// Ignore it
break;
case GDK_SELECTION_REQUEST:
case GDK_SELECTION_NOTIFY:
case GDK_SELECTION_CLEAR:
#if GTK_CHECK_VERSION(2,6,0)
case GDK_OWNER_CHANGE:
#endif
// process it now
gtk_main_do_event(event);
break;
default:
// process it later (but make a copy; the caller will free the event pointer)
queue->Add(gdk_event_copy(event));
break;
}
// don't allow idle callbacks while we're active
wxTheApp->SuspendIdleCallback();
return;
}
void PageClientImpl::doneWithKeyEvent(const NativeWebKeyboardEvent& event, bool wasEventHandled)
{
if (wasEventHandled)
return;
WebKitWebViewBase* webkitWebViewBase = WEBKIT_WEB_VIEW_BASE(m_viewWidget);
webkitWebViewBaseForwardNextKeyEvent(webkitWebViewBase);
gtk_main_do_event(event.nativeEvent());
}
static JSValueRef runPasteTestCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)
{
gtk_widget_grab_focus(GTK_WIDGET(currentFixture->webView));
// Simulate a paste keyboard sequence.
GdkEvent* event = gdk_event_new(GDK_KEY_PRESS);
event->key.keyval = gdk_unicode_to_keyval('v');
event->key.state = GDK_CONTROL_MASK;
event->key.window = gtk_widget_get_window(GTK_WIDGET(currentFixture->webView));
g_object_ref(event->key.window);
#ifndef GTK_API_VERSION_2
GdkDeviceManager* manager = gdk_display_get_device_manager(gdk_window_get_display(event->key.window));
gdk_event_set_device(event, gdk_device_manager_get_client_pointer(manager));
#endif
GdkKeymapKey* keys;
gint n_keys;
if (gdk_keymap_get_entries_for_keyval(gdk_keymap_get_default(), event->key.keyval, &keys, &n_keys)) {
event->key.hardware_keycode = keys[0].keycode;
g_free(keys);
}
gtk_main_do_event(event);
event->key.type = GDK_KEY_RELEASE;
gtk_main_do_event(event);
gdk_event_free(event);
JSStringRef scriptString = JSStringCreateWithUTF8CString("document.body.innerHTML;");
JSValueRef value = JSEvaluateScript(context, scriptString, 0, 0, 0, 0);
JSStringRelease(scriptString);
g_assert(JSValueIsString(context, value));
JSStringRef actual = JSValueToStringCopy(context, value, exception);
g_assert(!exception || !*exception);
g_assert(currentFixture->info->expectedContent);
JSStringRef expected = JSStringCreateWithUTF8CString(currentFixture->info->expectedContent);
g_assert(JSStringIsEqual(expected, actual));
JSStringRelease(expected);
JSStringRelease(actual);
g_main_loop_quit(currentFixture->loop);
return JSValueMakeUndefined(context);
}
static void
gdkevent_dispatcher (GdkEvent *event,
gpointer data)
{
GIOChannel *channel = data;
switch (event->type) {
case GDK_NOTHING:
break;
case GDK_DELETE:
gdkevent_handle_any(event, channel);
break;
case GDK_DESTROY:
gdkevent_handle_destroy(event, channel);
break;
case GDK_EXPOSE:
gdkevent_handle_expose(event, channel);
break;
case GDK_MOTION_NOTIFY:
gdkevent_handle_motion_notfiy(event, channel);
break;
case GDK_BUTTON_PRESS:
case GDK_2BUTTON_PRESS:
case GDK_3BUTTON_PRESS:
case GDK_BUTTON_RELEASE:
gdkevent_handle_button(event, channel);
break;
case GDK_KEY_PRESS:
case GDK_KEY_RELEASE:
gdkevent_handle_key(event, channel);
break;
case GDK_ENTER_NOTIFY:
case GDK_LEAVE_NOTIFY:
gdkevent_handle_crossing(event, channel);
break;
case GDK_FOCUS_CHANGE:
gdkevent_handle_focus(event, channel);
break;
case GDK_CONFIGURE:
gdkevent_handle_configure(event, channel);
break;
case GDK_MAP:
case GDK_UNMAP:
gdkevent_handle_any(event, channel);
break;
default:
/*
* TODO: Handle more of these specificaly.
*/
gdkevent_handle_any(event, channel);
break;
}
gtk_main_do_event(event);
}
static void doKeyStroke(GtkWidget* viewWidget, unsigned int keyVal)
{
GUniquePtr<GdkEvent> event(gdk_event_new(GDK_KEY_PRESS));
event->key.keyval = keyVal;
event->key.time = GDK_CURRENT_TIME;
event->key.state = 0;
event->key.window = gtk_widget_get_window(viewWidget);
g_object_ref(event->key.window);
gdk_event_set_device(event.get(), gdk_device_manager_get_client_pointer(gdk_display_get_device_manager(gtk_widget_get_display(viewWidget))));
// When synthesizing an event, an invalid hardware_keycode value can cause it to be badly processed by GTK+.
GOwnPtr<GdkKeymapKey> keys;
int keysCount;
if (gdk_keymap_get_entries_for_keyval(gdk_keymap_get_default(), keyVal, &keys.outPtr(), &keysCount))
event->key.hardware_keycode = keys.get()[0].keycode;
gtk_main_do_event(event.get());
event->key.type = GDK_KEY_RELEASE;
gtk_main_do_event(event.get());
}
void
awt_event_handler (GdkEvent *event)
{
/* keep synthetic AWT events from being processed recursively */
if (event->type & SYNTHETIC_EVENT_MASK && event->type != GDK_NOTHING)
{
event->type ^= SYNTHETIC_EVENT_MASK;
}
gtk_main_do_event (event);
}
static void
check_for_draw (GdkEvent *event, gpointer loop)
{
if (event->type == GDK_EXPOSE)
{
g_idle_add (quit_when_idle, loop);
gdk_event_handler_set ((GdkEventFunc) gtk_main_do_event, NULL, NULL);
}
gtk_main_do_event (event);
}
gboolean
sp_dialog_event_handler (GtkWindow *win, GdkEvent *event, gpointer data)
{
// if the focus is inside the Text and Font textview, do nothing
GObject *dlg = G_OBJECT(data);
if (g_object_get_data (dlg, "eatkeys")) {
return FALSE;
}
gboolean ret = FALSE;
switch (event->type) {
case GDK_KEY_PRESS:
switch (Inkscape::UI::Tools::get_group0_keyval (&event->key)) {
case GDK_KEY_Escape:
sp_dialog_defocus (win);
ret = TRUE;
break;
case GDK_KEY_F4:
case GDK_KEY_w:
case GDK_KEY_W:
// close dialog
if (MOD__CTRL_ONLY(event)) {
/* this code sends a delete_event to the dialog,
* instead of just destroying it, so that the
* dialog can do some housekeeping, such as remember
* its position.
*/
GdkEventAny event;
GtkWidget *widget = GTK_WIDGET(win);
event.type = GDK_DELETE;
event.window = gtk_widget_get_window (widget);
event.send_event = TRUE;
g_object_ref (G_OBJECT (event.window));
gtk_main_do_event(reinterpret_cast<GdkEvent*>(&event));
g_object_unref (G_OBJECT (event.window));
ret = TRUE;
}
break;
default: // pass keypress to the canvas
break;
}
default:
;
}
return ret;
}
static void
point_release (PointState *point,
guint button)
{
GdkDisplay *display;
GdkDevice *device;
GdkSeat *seat;
GdkEvent *ev;
if (point->widget == NULL)
return;
display = gtk_widget_get_display (point->widget);
seat = gdk_display_get_default_seat (display);
device = gdk_seat_get_pointer (seat);
if (!point->widget)
return;
if (point == &mouse_state)
{
if ((point->state & (GDK_BUTTON1_MASK << (button - 1))) == 0)
return;
ev = gdk_event_new (GDK_BUTTON_RELEASE);
ev->any.window = g_object_ref (gtk_widget_get_window (point->widget));
ev->button.time = GDK_CURRENT_TIME;
ev->button.x = point->x;
ev->button.y = point->y;
ev->button.state = point->state;
point->state &= ~(GDK_BUTTON1_MASK << (button - 1));
}
else
{
ev = gdk_event_new (GDK_TOUCH_END);
ev->any.window = g_object_ref (gtk_widget_get_window (point->widget));
ev->touch.time = GDK_CURRENT_TIME;
ev->touch.x = point->x;
ev->touch.y = point->y;
ev->touch.sequence = EVENT_SEQUENCE (point);
ev->touch.state = point->state;
if (point == &touch_state[0])
ev->touch.emulating_pointer = TRUE;
}
gdk_event_set_device (ev, device);
gtk_main_do_event (ev);
gdk_event_free (ev);
}
static void _event_handler(GdkEvent *event, gpointer data)
{
char *s;
if (event->type == GDK_CLIENT_EVENT) {
s = gdk_atom_name(((GdkEventClient *)event)->message_type);
if (s && !strcmp(s, "_GTK_READ_RCFILES")) {
mt_default_engine = NULL;
mt_first_engine = mt_get_engine();
}
}
gtk_main_do_event(event);
}
static void
point_update (PointState *point,
GtkWidget *widget,
gdouble x,
gdouble y)
{
GdkDisplay *display;
GdkDevice *device;
GdkSeat *seat;
GdkEvent *ev;
display = gtk_widget_get_display (widget);
seat = gdk_display_get_default_seat (display);
device = gdk_seat_get_pointer (seat);
point->x = x;
point->y = y;
if (point == &mouse_state)
{
ev = gdk_event_new (GDK_MOTION_NOTIFY);
ev->any.window = g_object_ref (gtk_widget_get_window (widget));
ev->button.time = GDK_CURRENT_TIME;
ev->motion.x = x;
ev->motion.y = y;
ev->motion.state = point->state;
}
else
{
if (!point->widget || widget != point->widget)
return;
ev = gdk_event_new (GDK_TOUCH_UPDATE);
ev->any.window = g_object_ref (gtk_widget_get_window (widget));
ev->touch.time = GDK_CURRENT_TIME;
ev->touch.x = x;
ev->touch.y = y;
ev->touch.sequence = EVENT_SEQUENCE (point);
ev->touch.state = 0;
if (point == &touch_state[0])
ev->touch.emulating_pointer = TRUE;
}
gdk_event_set_device (ev, device);
gtk_main_do_event (ev);
gdk_event_free (ev);
}
static void
exit_activated_cb (TrayProvider *tray)
{
GdkEventAny ev;
menu_selection_done_cb (tray);
ev.type = GDK_DELETE;
ev.window = tray->window->window;
ev.send_event = TRUE;
g_signal_handler_block (tray->window, tray->sig);
gtk_main_do_event ((GdkEvent *) &ev);
}
/*
* hide popup when clicking outside
*/
static gboolean
cb_dock_press (GtkWidget * widget, GdkEventButton * event, gpointer data)
{
BtVolumePopup *self = BT_VOLUME_POPUP (data);
//if(!gtk_widget_get_realized(GTK_WIDGET(self)) return FALSE;
if (event->type == GDK_BUTTON_PRESS) {
GdkEventButton *e;
//GST_INFO("type=%4d, window=%p, send_event=%3d, time=%8d",event->type,event->window,event->send_event,event->time);
//GST_INFO("x=%6.4lf, y=%6.4lf, axes=%p, state=%4d",event->x,event->y,event->axes,event->state);
//GST_INFO("button=%4d, device=%p, x_root=%6.4lf, y_root=%6.4lf\n",event->button,event->device,event->x_root,event->y_root);
/*
GtkWidget *parent=GTK_WIDGET(gtk_window_get_transient_for(GTK_WINDOW(self)));
//GtkWidget *parent=gtk_widget_get_parent(GTK_WIDGET(self));
//gboolean retval;
GST_INFO("FORWARD : popup=%p, widget=%p", self, widget);
GST_INFO("FORWARD : parent=%p, parent->window=%p", parent, parent->window);
*/
bt_volume_popup_hide (self);
// forward event
e = (GdkEventButton *) gdk_event_copy ((GdkEvent *) event);
//GST_INFO("type=%4d, window=%p, send_event=%3d, time=%8d",e->type,e->window,e->send_event,e->time);
//GST_INFO("x=%6.4lf, y=%6.4lf, axes=%p, state=%4d",e->x,e->y,e->axes,e->state);
//GST_INFO("button=%4d, device=%p, x_root=%6.4lf, y_root=%6.4lf\n",e->button,e->device,e->x_root,e->y_root);
//e->window = widget->window;
//e->window = parent->window;
//e->type = GDK_BUTTON_PRESS;
gtk_main_do_event ((GdkEvent *) e);
//retval=gtk_widget_event (widget, (GdkEvent *) e);
//retval=gtk_widget_event (parent, (GdkEvent *) e);
//retval=gtk_widget_event (self->parent_widget, (GdkEvent *) e);
//GST_INFO(" result =%d", retval);
//g_signal_emit_by_name(self->parent_widget, "event", 0, &retval, e);
//g_signal_emit_by_name(parent, "event", 0, &retval, e);
//GST_INFO(" result =%d", retval);
//e->window = event->window;
gdk_event_free ((GdkEvent *) e);
return TRUE;
}
return FALSE;
}
static void
thunar_abstract_dialog_close (GtkDialog *dialog)
{
GdkEvent *event;
/* verify that dialog is realized */
if (G_LIKELY (GTK_WIDGET_REALIZED (dialog)))
{
/* send a delete event to the dialog */
event = gdk_event_new (GDK_DELETE);
event->any.window = g_object_ref (GTK_WIDGET (dialog)->window);
event->any.send_event = TRUE;
gtk_main_do_event (event);
gdk_event_free (event);
}
}
static void
point_press (PointState *point,
GtkWidget *widget,
guint button)
{
GdkDisplay *display;
GdkDevice *device;
GdkSeat *seat;
GdkEvent *ev;
display = gtk_widget_get_display (widget);
seat = gdk_display_get_default_seat (display);
device = gdk_seat_get_pointer (seat);
if (point == &mouse_state)
{
ev = gdk_event_new (GDK_BUTTON_PRESS);
ev->any.window = g_object_ref (gtk_widget_get_window (widget));
ev->button.time = GDK_CURRENT_TIME;
ev->button.x = point->x;
ev->button.y = point->y;
ev->button.button = button;
ev->button.state = point->state;
point->state |= GDK_BUTTON1_MASK << (button - 1);
}
else
{
ev = gdk_event_new (GDK_TOUCH_BEGIN);
ev->any.window = g_object_ref (gtk_widget_get_window (widget));
ev->touch.time = GDK_CURRENT_TIME;
ev->touch.x = point->x;
ev->touch.y = point->y;
ev->touch.sequence = EVENT_SEQUENCE (point);
if (point == &touch_state[0])
ev->touch.emulating_pointer = TRUE;
}
gdk_event_set_device (ev, device);
gtk_main_do_event (ev);
gdk_event_free (ev);
point->widget = widget;
}
void Dialog::_close()
{
GtkWidget *dlg = GTK_WIDGET(_behavior->gobj());
GdkEventAny event;
event.type = GDK_DELETE;
event.window = gtk_widget_get_window(dlg);
event.send_event = TRUE;
if (event.window)
g_object_ref(G_OBJECT(event.window));
gtk_main_do_event ((GdkEvent*)&event);
if (event.window)
g_object_unref(G_OBJECT(event.window));
}
static void dispatchEvent(GdkEvent event)
{
webkit_web_frame_layout(mainFrame);
WebKitWebView* view = webkit_web_frame_get_web_view(mainFrame);
if (!view)
return;
gboolean returnValue;
if (event.type == GDK_BUTTON_PRESS || event.type == GDK_2BUTTON_PRESS || event.type == GDK_3BUTTON_PRESS)
g_signal_emit_by_name(view, "button_press_event", &event, &returnValue);
else if (event.type == GDK_BUTTON_RELEASE)
g_signal_emit_by_name(view, "button_release_event", &event, &returnValue);
else if (event.type == GDK_MOTION_NOTIFY)
g_signal_emit_by_name(view, "motion_notify_event", &event, &returnValue);
else if (event.type == GDK_SCROLL)
gtk_main_do_event(&event);
}
static JSValueRef mouseWheelToCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)
{
WebKitWebView* view = webkit_web_frame_get_web_view(mainFrame);
if (!view)
return JSValueMakeUndefined(context);
if (argumentCount < 2)
return JSValueMakeUndefined(context);
int horizontal = (int)JSValueToNumber(context, arguments[0], exception);
g_return_val_if_fail((!exception || !*exception), JSValueMakeUndefined(context));
int vertical = (int)JSValueToNumber(context, arguments[1], exception);
g_return_val_if_fail((!exception || !*exception), JSValueMakeUndefined(context));
// GTK+ doesn't support multiple direction scrolls in the same event!
g_return_val_if_fail((!vertical || !horizontal), JSValueMakeUndefined(context));
GdkEvent event;
event.type = GDK_SCROLL;
event.scroll.x = lastMousePositionX;
event.scroll.y = lastMousePositionY;
event.scroll.time = GDK_CURRENT_TIME;
event.scroll.window = GTK_WIDGET(view)->window;
if (horizontal < 0)
event.scroll.direction = GDK_SCROLL_LEFT;
else if (horizontal > 0)
event.scroll.direction = GDK_SCROLL_RIGHT;
else if (vertical < 0)
event.scroll.direction = GDK_SCROLL_UP;
else if (vertical > 0)
event.scroll.direction = GDK_SCROLL_DOWN;
else
g_assert_not_reached();
if (dragMode && down && !replayingSavedEvents) {
msgQueue[endOfQueue].event = event;
msgQueue[endOfQueue++].isDragEvent = true;
} else {
webkit_web_frame_layout(mainFrame);
gtk_main_do_event(&event);
}
return JSValueMakeUndefined(context);
}
static void
gimp_dialog_close (GtkDialog *dialog)
{
/* Synthesize delete_event to close dialog. */
GtkWidget *widget = GTK_WIDGET (dialog);
if (widget->window)
{
GdkEvent *event = gdk_event_new (GDK_DELETE);
event->any.window = g_object_ref (widget->window);
event->any.send_event = TRUE;
gtk_main_do_event (event);
gdk_event_free (event);
}
}
void gtksendkey(sPlayerInterface* player_interf,int keycode)
{
TRACEINFO;
GdkEvent *KeyEvent;
fprintf(stderr, "\x1b[%i;3%imKeyCode\x1b[0m: %d\n",1, 4,keycode);
KeyEvent = gdk_event_new (GDK_KEY_PRESS);
/* Key Value */
KeyEvent->key.keyval = gdk_unicode_to_keyval(keycode);
/* GDK_BUTTON1_MASK refers to left mouse button */
KeyEvent->key.state = GDK_BUTTON1_MASK;
/* Send the key event to Web Window */
KeyEvent->key.window = player_interf->ui->pWebWindow->window;
gtk_main_do_event (KeyEvent);
//gdk_event_free(KeyEvent);
}
/* This is an IBus workaround. The flow of events with IBus is that every time
* it gets gets a key event, it:
*
* Sends it to the daemon via D-Bus asynchronously
* When it gets an reply, synthesizes a new GdkEvent and puts it into the
* GDK event queue with gdk_event_put(), including
* IBUS_FORWARD_MASK = 1 << 25 in the state to prevent a loop.
*
* (Normally, IBus uses the GTK+ key snooper mechanism to get the key
* events early, but since our key events aren't visible to GTK+ key snoopers,
* IBus will instead get the events via the standard
* GtkIMContext.filter_keypress() mechanism.)
*
* There are a number of potential problems here; probably the worst
* problem is that IBus doesn't forward the timestamp with the event
* so that every key event that gets delivered ends up with
* GDK_CURRENT_TIME. This creates some very subtle bugs; for example
* if you have IBus running and a keystroke is used to trigger
* launching an application, focus stealing prevention won't work
* right. http://code.google.com/p/ibus/issues/detail?id=1184
*
* In any case, our normal flow of key events is:
*
* GDK filter function => clutter_x11_handle_event => clutter actor
*
* So, if we see a key event that gets delivered via the GDK event handler
* function - then we know it must be one of these synthesized events, and
* we should push it back to clutter.
*
* To summarize, the full key event flow with IBus is:
*
* GDK filter function
* => Mutter
* => gnome_cinnamon_plugin_xevent_filter()
* => clutter_x11_handle_event()
* => clutter event delivery to actor
* => gtk_im_context_filter_event()
* => sent to IBus daemon
* => response received from IBus daemon
* => gdk_event_put()
* => GDK event handler
* => <this function>
* => clutter_event_put()
* => clutter event delivery to actor
*
* Anything else we see here we just pass on to the normal GDK event handler
* gtk_main_do_event().
*/
static void
gnome_cinnamon_gdk_event_handler (GdkEvent *event_gdk,
gpointer data)
{
if (event_gdk->type == GDK_KEY_PRESS || event_gdk->type == GDK_KEY_RELEASE)
{
ClutterActor *stage;
Window stage_xwindow;
stage = clutter_stage_get_default ();
stage_xwindow = clutter_x11_get_stage_window (CLUTTER_STAGE (stage));
if (GDK_WINDOW_XID (event_gdk->key.window) == stage_xwindow)
{
ClutterDeviceManager *device_manager = clutter_device_manager_get_default ();
ClutterInputDevice *keyboard = clutter_device_manager_get_core_device (device_manager,
CLUTTER_KEYBOARD_DEVICE);
ClutterEvent *event_clutter = clutter_event_new ((event_gdk->type == GDK_KEY_PRESS) ?
CLUTTER_KEY_PRESS : CLUTTER_KEY_RELEASE);
event_clutter->key.time = event_gdk->key.time;
event_clutter->key.flags = CLUTTER_EVENT_NONE;
event_clutter->key.stage = CLUTTER_STAGE (stage);
event_clutter->key.source = NULL;
/* This depends on ClutterModifierType and GdkModifierType being
* identical, which they are currently. (They both match the X
* modifier state in the low 16-bits and have the same extensions.) */
event_clutter->key.modifier_state = event_gdk->key.state;
event_clutter->key.keyval = event_gdk->key.keyval;
event_clutter->key.hardware_keycode = event_gdk->key.hardware_keycode;
event_clutter->key.unicode_value = gdk_keyval_to_unicode (event_clutter->key.keyval);
event_clutter->key.device = keyboard;
clutter_event_put (event_clutter);
clutter_event_free (event_clutter);
return;
}
}
gtk_main_do_event (event_gdk);
}
static void
gtk_form_send_configure(GtkForm *form)
{
GtkWidget *widget;
GdkEventConfigure event;
GtkAllocation allocation;
widget = GTK_WIDGET(form);
gtk_widget_get_allocation(widget, &allocation);
event.type = GDK_CONFIGURE;
event.window = gtk_widget_get_window(widget);
event.x = allocation.x;
event.y = allocation.y;
event.width = allocation.width;
event.height = allocation.height;
gtk_main_do_event((GdkEvent*)&event);
}
static void doMouseButtonEvent(GtkWidget* viewWidget, GdkEventType eventType, int x, int y, unsigned int button)
{
GUniquePtr<GdkEvent> event(gdk_event_new(eventType));
event->button.x = x;
event->button.y = y;
event->button.button = button;
event->button.time = GDK_CURRENT_TIME;
event->button.axes = 0;
event->button.state = 0;
event->button.window = gtk_widget_get_window(viewWidget);
g_object_ref(event->button.window);
event->button.device = gdk_device_manager_get_client_pointer(gdk_display_get_device_manager(gtk_widget_get_display(viewWidget)));
int xRoot, yRoot;
gdk_window_get_root_coords(gtk_widget_get_window(viewWidget), x, y, &xRoot, &yRoot);
event->button.x_root = xRoot;
event->button.y_root = yRoot;
gtk_main_do_event(event.get());
}
