static void
get_bounding_box (GtkWidget *widget,
GdkRectangle *bounds)
{
GdkWindow *window;
gint x, y;
gint w, h;
gint x1, y1;
gint x2, y2;
gint x3, y3;
gint x4, y4;
window = gtk_widget_get_parent_window (widget);
x = widget->allocation.x;
y = widget->allocation.y;
w = widget->allocation.width;
h = widget->allocation.height;
gdk_window_get_root_coords (window, x, y, &x1, &y1);
gdk_window_get_root_coords (window, x + w, y, &x2, &y2);
gdk_window_get_root_coords (window, x, y + h, &x3, &y3);
gdk_window_get_root_coords (window, x + w, y + h, &x4, &y4);
#define MIN4(a,b,c,d) MIN(MIN(a,b),MIN(c,d))
#define MAX4(a,b,c,d) MAX(MAX(a,b),MAX(c,d))
bounds->x = floor (MIN4 (x1, x2, x3, x4));
bounds->y = floor (MIN4 (y1, y2, y3, y4));
bounds->width = ceil (MAX4 (x1, x2, x3, x4)) - bounds->x;
bounds->height = ceil (MAX4 (y1, y2, y3, y4)) - bounds->y;
}
static void m_menu_position(GtkMenu *menu,
gint *x,
gint *y,
gint *push_in,
gpointer user_data)
{
GtkWidget *active = gtk_menu_get_active(menu);
GdkEventButton *event = (GdkEventButton *) user_data;
int menu_xpos = event->x;
int menu_ypos = event->y;
GtkAllocation allocation;
GdkRectangle display_rect = m_get_monitor_geo();
if (active) {
gtk_menu_shell_select_item(GTK_MENU_SHELL(m_popup), active);
gtk_widget_get_allocation(active, &allocation);
}
gtk_widget_get_allocation(GTK_WIDGET(menu), &allocation);
if (display_rect.height - event->y_root < allocation.height)
menu_ypos -= allocation.height;
printf("DEBUG: %s (%d, %d)\n", __func__, menu_xpos, menu_ypos);
gdk_window_get_root_coords(gtk_widget_get_window(m_window),
menu_xpos, menu_ypos, &menu_xpos, &menu_ypos);
printf("DEBUG: %s (%d, %d)\n", __func__, menu_xpos, menu_ypos);
*x = menu_xpos;
*y = menu_ypos;
*push_in = TRUE;
}
bool prepareMouseButtonEvent(GdkEvent* event, int eventSenderButtonNumber, guint modifiers)
{
WebKitWebView* view = webkit_web_frame_get_web_view(mainFrame);
if (!view)
return false;
// The logic for mapping EventSender button numbers to GDK button
// numbers originates from the Windows EventSender.
int gdkButtonNumber = 3;
if (eventSenderButtonNumber >= 0 && eventSenderButtonNumber <= 2)
gdkButtonNumber = eventSenderButtonNumber + 1;
// fast/events/mouse-click-events expects the 4th button
// to be event->button = 1, so send a middle-button event.
else if (eventSenderButtonNumber == 3)
gdkButtonNumber = 2;
event->button.button = gdkButtonNumber;
event->button.x = lastMousePositionX;
event->button.y = lastMousePositionY;
event->button.window = gtk_widget_get_window(GTK_WIDGET(view));
g_object_ref(event->button.window);
event->button.device = getDefaultGDKPointerDevice(event->button.window);
event->button.state = modifiers | getStateFlags();
event->button.time = GDK_CURRENT_TIME;
event->button.axes = 0;
int xRoot, yRoot;
gdk_window_get_root_coords(gtk_widget_get_window(GTK_WIDGET(view)), lastMousePositionX, lastMousePositionY, &xRoot, &yRoot);
event->button.x_root = xRoot;
event->button.y_root = yRoot;
return true;
}
static JSValueRef mouseMoveToCallback(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);
lastMousePositionX = (int)JSValueToNumber(context, arguments[0], exception);
g_return_val_if_fail((!exception || !*exception), JSValueMakeUndefined(context));
lastMousePositionY = (int)JSValueToNumber(context, arguments[1], exception);
g_return_val_if_fail((!exception || !*exception), JSValueMakeUndefined(context));
GdkEvent* event = gdk_event_new(GDK_MOTION_NOTIFY);
event->motion.x = lastMousePositionX;
event->motion.y = lastMousePositionY;
event->motion.time = GDK_CURRENT_TIME;
event->motion.window = gtk_widget_get_window(GTK_WIDGET(view));
g_object_ref(event->motion.window);
event->button.device = getDefaultGDKPointerDevice(event->motion.window);
event->motion.state = getStateFlags();
event->motion.axes = 0;
int xRoot, yRoot;
gdk_window_get_root_coords(gtk_widget_get_window(GTK_WIDGET(view)), lastMousePositionX, lastMousePositionY, &xRoot, &yRoot);
event->motion.x_root = xRoot;
event->motion.y_root = yRoot;
sendOrQueueEvent(event, false);
return JSValueMakeUndefined(context);
}
bool prepareMouseButtonEvent(GdkEvent* event, int button)
{
WebKitWebView* view = webkit_web_frame_get_web_view(mainFrame);
if (!view)
return false;
memset(event, 0, sizeof(event));
event->button.button = button;
event->button.x = lastMousePositionX;
event->button.y = lastMousePositionY;
event->button.window = GTK_WIDGET(view)->window;
event->button.device = gdk_device_get_core_pointer();
event->button.state = getStateFlags();
// Mouse up & down events dispatched via g_signal_emit_by_name must offset
// their time value, so that WebKit can detect where sequences of mouse
// clicks begin and end. This should not interfere with GDK or GTK+ event
// processing, because the event is only seen by the widget.
event->button.time = GDK_CURRENT_TIME + timeOffset;
int xRoot, yRoot;
#if GTK_CHECK_VERSION(2, 17, 3)
gdk_window_get_root_coords(GTK_WIDGET(view)->window, lastMousePositionX, lastMousePositionY, &xRoot, &yRoot);
#else
getRootCoords(GTK_WIDGET(view), &xRoot, &yRoot);
#endif
event->button.x_root = xRoot;
event->button.y_root = yRoot;
return true;
}
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());
}
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
nimf_gtk_im_context_set_cursor_location (GtkIMContext *context,
GdkRectangle *area)
{
g_debug (G_STRLOC ": %s", G_STRFUNC);
NimfGtkIMContext *nimf_context = NIMF_GTK_IM_CONTEXT (context);
if (memcmp (&nimf_context->cursor_area, area, sizeof (GdkRectangle)) == 0)
return;
nimf_context->cursor_area = *area;
GdkRectangle root_area = *area;
if (nimf_context->client_window)
{
gdk_window_get_root_coords (nimf_context->client_window,
area->x,
area->y,
&root_area.x,
&root_area.y);
nimf_im_set_cursor_location (NIMF_GTK_IM_CONTEXT (context)->im,
(const NimfRectangle *) &root_area);
}
}
static void
dasom_gtk_im_context_set_cursor_location (GtkIMContext *context,
GdkRectangle *area)
{
g_debug (G_STRLOC ": %s", G_STRFUNC);
DasomGtkIMContext *dasom_context = DASOM_GTK_IM_CONTEXT (context);
if (memcmp (&dasom_context->cursor_area, area, sizeof (GdkRectangle)) == 0)
return;
dasom_context->cursor_area = *area;
GdkRectangle root_area = *area;
if (dasom_context->client_window)
{
gdk_window_get_root_coords (dasom_context->client_window,
area->x,
area->y,
&root_area.x,
&root_area.y);
dasom_im_set_cursor_location (DASOM_GTK_IM_CONTEXT (context)->im,
(const DasomRectangle *) &root_area);
}
}
/**
* gtk_tooltip_trigger_tooltip_query:
* @display: a #GdkDisplay
*
* Triggers a new tooltip query on @display, in order to update the current
* visible tooltip, or to show/hide the current tooltip. This function is
* useful to call when, for example, the state of the widget changed by a
* key press.
*
* Since: 2.12
*/
void
gtk_tooltip_trigger_tooltip_query (GdkDisplay *display)
{
gint x, y;
GdkWindow *window;
GdkEvent event;
GdkDevice *device;
/* Trigger logic as if the mouse moved */
device = gdk_device_manager_get_client_pointer (gdk_display_get_device_manager (display));
window = gdk_device_get_window_at_position (device, &x, &y);
if (!window)
return;
event.type = GDK_MOTION_NOTIFY;
event.motion.window = window;
event.motion.x = x;
event.motion.y = y;
event.motion.is_hint = FALSE;
gdk_window_get_root_coords (window, x, y, &x, &y);
event.motion.x_root = x;
event.motion.y_root = y;
_gtk_tooltip_handle_event (&event);
}
static void
menu_position_func (GtkMenu * menu,
gint * x,
gint * y,
gboolean* push_in,
gpointer user_data)
{
GtkRequisition requisition;
GtkAllocation allocation;
GdkRectangle monitor_geometry;
GdkScreen * screen;
int monitor;
screen = gtk_widget_get_screen (GTK_WIDGET (menu));
gtk_widget_get_allocation (user_data, &allocation);
gtk_widget_size_request (GTK_WIDGET (menu), &requisition);
gdk_window_get_root_coords (gtk_widget_get_parent_window (user_data),
allocation.x, allocation.y,
&allocation.x, &allocation.y);
monitor = gdk_screen_get_monitor_at_window (screen, GTK_WIDGET (user_data)->window);
gtk_menu_set_monitor (menu, monitor);
gdk_screen_get_monitor_geometry (screen, monitor, &monitor_geometry);
if (allocation.y >= monitor_geometry.y &&
allocation.y + allocation.height + requisition.height <= monitor_geometry.y + monitor_geometry.height)
{
*y = allocation.y + allocation.height;
}
else if (allocation.y - requisition.height >= monitor_geometry.y &&
allocation.y <= monitor_geometry.y + monitor_geometry.height)
{
*y = allocation.y - requisition.height;
}
else
{
g_warning ("implement menu somewhere else");
*y = allocation.y;
}
switch (gtk_widget_get_direction (user_data))
{
case GTK_TEXT_DIR_RTL:
*x = allocation.x + allocation.width - requisition.width;
break;
case GTK_TEXT_DIR_LTR:
case GTK_TEXT_DIR_NONE:
*x = allocation.x;
break;
default:
g_warn_if_reached ();
*x = allocation.x;
break;
}
}
static JSValueRef mouseDownCallback(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);
down = true;
GdkEvent event;
memset(&event, 0, sizeof(event));
event.type = GDK_BUTTON_PRESS;
event.button.button = 1;
if (argumentCount == 1) {
event.button.button = (int)JSValueToNumber(context, arguments[0], exception) + 1;
g_return_val_if_fail((!exception || !*exception), JSValueMakeUndefined(context));
}
currentEventButton = event.button.button;
event.button.x = lastMousePositionX;
event.button.y = lastMousePositionY;
event.button.window = GTK_WIDGET(view)->window;
event.button.time = GDK_CURRENT_TIME;
event.button.device = gdk_device_get_core_pointer();
int x_root, y_root;
#if GTK_CHECK_VERSION(2,17,3)
gdk_window_get_root_coords(GTK_WIDGET(view)->window, lastMousePositionX, lastMousePositionY, &x_root, &y_root);
#else
getRootCoords(GTK_WIDGET(view), &x_root, &y_root);
#endif
event.button.x_root = x_root;
event.button.y_root = y_root;
updateClickCount(event.button.button);
if (!msgQueue[endOfQueue].delay) {
webkit_web_frame_layout(mainFrame);
gboolean return_val;
g_signal_emit_by_name(view, "button_press_event", &event, &return_val);
if (clickCount == 2) {
event.type = GDK_2BUTTON_PRESS;
g_signal_emit_by_name(view, "button_press_event", &event, &return_val);
}
} else {
// replaySavedEvents should have the required logic to make leapForward delays work
msgQueue[endOfQueue++].event = event;
replaySavedEvents();
}
return JSValueMakeUndefined(context);
}
static JSValueRef mouseUpCallback(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);
GdkEvent event;
memset(&event, 0, sizeof(event));
event.type = GDK_BUTTON_RELEASE;
event.button.button = 1;
if (argumentCount == 1) {
event.button.button = (int)JSValueToNumber(context, arguments[0], exception) + 1;
g_return_val_if_fail((!exception || !*exception), JSValueMakeUndefined(context));
}
currentEventButton = event.button.button;
event.button.x = lastMousePositionX;
event.button.y = lastMousePositionY;
event.button.window = GTK_WIDGET(view)->window;
event.button.time = GDK_CURRENT_TIME;
event.button.device = gdk_device_get_core_pointer();
event.button.state = getStateFlags();
down = false;
int x_root, y_root;
#if GTK_CHECK_VERSION(2,17,3)
gdk_window_get_root_coords(GTK_WIDGET(view)->window, lastMousePositionX, lastMousePositionY, &x_root, &y_root);
#else
getRootCoords(GTK_WIDGET(view), &x_root, &y_root);
#endif
event.button.x_root = x_root;
event.button.y_root = y_root;
if ((dragMode && !replayingSavedEvents) || msgQueue[endOfQueue].delay) {
msgQueue[endOfQueue].event = event;
msgQueue[endOfQueue++].isDragEvent = true;
replaySavedEvents();
} else {
webkit_web_frame_layout(mainFrame);
gboolean return_val;
g_signal_emit_by_name(view, "button_release_event", &event, &return_val);
}
lastClickPositionX = lastMousePositionX;
lastClickPositionY = lastMousePositionY;
return JSValueMakeUndefined(context);
}
static void
get_bounding_box (GtkWidget *widget,
GdkRectangle *bounds)
{
GtkAllocation allocation;
GtkBorder border = { 0, };
GdkWindow *window;
gint x, y;
gint w, h;
gint x1, y1;
gint x2, y2;
gint x3, y3;
gint x4, y4;
window = gtk_widget_get_parent_window (widget);
if (window == NULL)
window = gtk_widget_get_window (widget);
gtk_widget_get_allocation (widget, &allocation);
if (GTK_IS_WINDOW (widget))
_gtk_window_get_shadow_width (GTK_WINDOW (widget), &border);
x = allocation.x + border.left;
y = allocation.y + border.right;
w = allocation.width - border.left - border.right;
h = allocation.height - border.top - border.bottom;
gdk_window_get_root_coords (window, x, y, &x1, &y1);
gdk_window_get_root_coords (window, x + w, y, &x2, &y2);
gdk_window_get_root_coords (window, x, y + h, &x3, &y3);
gdk_window_get_root_coords (window, x + w, y + h, &x4, &y4);
#define MIN4(a,b,c,d) MIN(MIN(a,b),MIN(c,d))
#define MAX4(a,b,c,d) MAX(MAX(a,b),MAX(c,d))
bounds->x = floor (MIN4 (x1, x2, x3, x4));
bounds->y = floor (MIN4 (y1, y2, y3, y4));
bounds->width = ceil (MAX4 (x1, x2, x3, x4)) - bounds->x;
bounds->height = ceil (MAX4 (y1, y2, y3, y4)) - bounds->y;
}
static void
gctt_combott_menu_position (GtkMenu *menu,
gint *x,
gint *y,
gint *push_in,
gpointer user_data)
{
GncCombott *combott = GNC_COMBOTT (user_data);
GncCombottPrivate *priv = GNC_COMBOTT_GET_PRIVATE (combott);
gint sx, sy;
GtkWidget *child;
GtkRequisition req;
GtkAllocation alloc;
GtkBorder padding;
GtkStyleContext *sc = gtk_widget_get_style_context (GTK_WIDGET (priv->button));
GtkStateFlags state_flags = gtk_style_context_get_state (sc);
child = gtk_bin_get_child (GTK_BIN (priv->button));
sx = sy = 0;
if (!gtk_widget_get_has_window (child))
{
gtk_widget_get_allocation (child, &alloc);
sx += alloc.x;
sy += alloc.y;
}
gdk_window_get_root_coords (gtk_widget_get_window (child), sx, sy, &sx, &sy);
gtk_style_context_get_padding (sc, state_flags, &padding);
sx -= padding.left;
gtk_widget_get_preferred_size (GTK_WIDGET (menu), &req, NULL);
if (gtk_widget_get_direction (GTK_WIDGET (priv->button)) == GTK_TEXT_DIR_LTR)
*x = sx;
else
{
gtk_widget_get_allocation (child, &alloc);
*x = sx + alloc.width - req.width;
}
if(priv->active == -1 || priv->active == 0)
*y = sy;
else
*y = sy - ((req.height / priv->num_items) * (priv->active - 1));
*push_in = FALSE;
}
static void
gctt_combott_menu_position (GtkMenu *menu,
gint *x,
gint *y,
gint *push_in,
gpointer user_data)
{
GncCombott *combott = GNC_COMBOTT (user_data);
GncCombottPrivate *priv = GNC_COMBOTT_GET_PRIVATE (combott);
gint sx, sy;
GtkWidget *child;
GtkRequisition req;
GtkAllocation alloc;
child = gtk_bin_get_child (GTK_BIN (priv->button));
sx = sy = 0;
if (!gtk_widget_get_has_window (child))
{
gtk_widget_get_allocation (child, &alloc);
sx += alloc.x;
sy += alloc.y;
}
gdk_window_get_root_coords (gtk_widget_get_window (child), sx, sy, &sx, &sy);
sx -= gtk_widget_get_style (GTK_WIDGET (priv->button))->xthickness;
gtk_widget_size_request (GTK_WIDGET (menu), &req);
if (gtk_widget_get_direction (GTK_WIDGET (priv->button)) == GTK_TEXT_DIR_LTR)
*x = sx;
else
{
gtk_widget_get_allocation (child, &alloc);
*x = sx + alloc.width - req.width;
}
if(priv->active == -1 || priv->active == 0)
*y = sy;
else
*y = sy - ((req.height / priv->num_items) * (priv->active - 1));
*push_in = FALSE;
}
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());
}
static void
notify_cursor_location (GtkIMContextWayland *context)
{
cairo_rectangle_int_t rect;
if (!global || !global->text_input)
return;
if (global->current != GTK_IM_CONTEXT (context))
return;
if (!context->window)
return;
rect = context->cursor_rect;
gdk_window_get_root_coords (context->window, rect.x, rect.y,
&rect.x, &rect.y);
gtk_text_input_set_cursor_rectangle (global->text_input,
rect.x, rect.y,
rect.width, rect.height);
}
static void
ppg_menu_tool_item_menu_position_func (GtkMenu *menu,
gint *x,
gint *y,
gboolean *push_in,
gpointer user_data)
{
PpgMenuToolItemPrivate *priv;
PpgMenuToolItem *item = (PpgMenuToolItem *)user_data;
GtkAllocation alloc;
g_return_if_fail(PPG_IS_MENU_TOOL_ITEM(item));
priv = item->priv;
gtk_widget_get_allocation(priv->button, &alloc);
gdk_window_get_root_coords(gtk_widget_get_window(priv->button),
alloc.x, alloc.y + alloc.height, x, y);
*push_in = TRUE;
}
GdkEvent* EventSenderProxy::createMouseButtonEvent(GdkEventType eventType, unsigned button, WKEventModifiers modifiers)
{
GdkEvent* mouseEvent = gdk_event_new(eventType);
mouseEvent->button.button = eventSenderButtonToGDKButton(button);
mouseEvent->button.x = m_position.x;
mouseEvent->button.y = m_position.y;
mouseEvent->button.window = gtk_widget_get_window(GTK_WIDGET(m_testController->mainWebView()->platformView()));
g_object_ref(mouseEvent->button.window);
gdk_event_set_device(mouseEvent, gdk_device_manager_get_client_pointer(gdk_display_get_device_manager(gdk_window_get_display(mouseEvent->button.window))));
mouseEvent->button.state = modifiers | getMouseButtonModifiers(mouseEvent->button.button);
mouseEvent->button.time = GDK_CURRENT_TIME;
mouseEvent->button.axes = 0;
int xRoot, yRoot;
gdk_window_get_root_coords(mouseEvent->button.window, m_position.x, m_position.y, &xRoot, &yRoot);
mouseEvent->button.x_root = xRoot;
mouseEvent->button.y_root = yRoot;
return mouseEvent;
}
static void
gtk_bubble_window_get_pointed_to_coords (GtkBubbleWindow *window,
gint *x,
gint *y,
cairo_rectangle_int_t *root_rect)
{
GtkBubbleWindowPrivate *priv = window->priv;
cairo_rectangle_int_t rect;
GdkScreen *screen;
rect = priv->pointing_to;
screen = gtk_widget_get_screen (GTK_WIDGET (window));
if (priv->relative_to)
gdk_window_get_root_coords (priv->relative_to,
rect.x, rect.y, &rect.x, &rect.y);
if (POS_IS_VERTICAL (priv->final_position))
{
*x = CLAMP (rect.x + (rect.width / 2),
0, gdk_screen_get_width (screen));
*y = rect.y;
if (priv->final_position == GTK_POS_BOTTOM)
(*y) += rect.height;
}
else
{
*y = CLAMP (rect.y + (rect.height / 2),
0, gdk_screen_get_height (screen));
*x = rect.x;
if (priv->final_position == GTK_POS_RIGHT)
(*x) += rect.width;
}
if (root_rect)
*root_rect = rect;
}
static gboolean
_set_cursor_location_internal(FcitxIMContext *fcitxcontext)
{
GdkRectangle area;
if (fcitxcontext->client_window == NULL ||
!fcitx_client_is_valid(fcitxcontext->client)) {
return FALSE;
}
area = fcitxcontext->area;
if (area.x == -1 && area.y == -1 && area.width == 0 && area.height == 0) {
#if GTK_CHECK_VERSION (2, 91, 0)
area.x = 0;
area.y += gdk_window_get_height(fcitxcontext->client_window);
#else
gint w, h;
gdk_drawable_get_size(fcitxcontext->client_window, &w, &h);
area.y += h;
area.x = 0;
#endif
}
#if GTK_CHECK_VERSION (2, 18, 0)
gdk_window_get_root_coords(fcitxcontext->client_window,
area.x, area.y,
&area.x, &area.y);
#else
{
int rootx, rooty;
gdk_window_get_origin(fcitxcontext->client_window, &rootx, &rooty);
area.x = rootx + area.x;
area.y = rooty + area.y;
}
#endif
fcitx_client_set_cusor_rect(fcitxcontext->client, area.x, area.y, area.width, area.height);
return FALSE;
}
void PlatformWebView::simulateMouseMove(unsigned x, unsigned y)
{
GUniquePtr<GdkEvent> event(gdk_event_new(GDK_MOTION_NOTIFY));
event->motion.x = x;
event->motion.y = y;
event->motion.time = GDK_CURRENT_TIME;
event->motion.state = 0;
event->motion.axes = 0;
GtkWidget* viewWidget = GTK_WIDGET(m_view);
if (!gtk_widget_get_realized(viewWidget))
gtk_widget_show(m_window);
event->motion.window = gtk_widget_get_window(viewWidget);
g_object_ref(event->motion.window);
event->motion.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->motion.x_root = xRoot;
event->motion.y_root = yRoot;
gtk_main_do_event(event.get());
}
void WebViewTest::mouseMoveTo(int x, int y, unsigned mouseModifiers)
{
g_assert(m_parentWindow);
GtkWidget* viewWidget = GTK_WIDGET(m_webView);
g_assert(gtk_widget_get_realized(viewWidget));
GUniquePtr<GdkEvent> event(gdk_event_new(GDK_MOTION_NOTIFY));
event->motion.x = x;
event->motion.y = y;
event->motion.time = GDK_CURRENT_TIME;
event->motion.window = gtk_widget_get_window(viewWidget);
g_object_ref(event->motion.window);
event->motion.device = gdk_device_manager_get_client_pointer(gdk_display_get_device_manager(gtk_widget_get_display(viewWidget)));
event->motion.state = mouseModifiers;
event->motion.axes = 0;
int xRoot, yRoot;
gdk_window_get_root_coords(gtk_widget_get_window(viewWidget), x, y, &xRoot, &yRoot);
event->motion.x_root = xRoot;
event->motion.y_root = yRoot;
gtk_main_do_event(event.get());
}
void EventSenderProxy::mouseMoveTo(double x, double y)
{
m_position.x = x;
m_position.y = y;
GdkEvent* event = gdk_event_new(GDK_MOTION_NOTIFY);
event->motion.x = m_position.x;
event->motion.y = m_position.y;
event->motion.time = GDK_CURRENT_TIME;
event->motion.window = gtk_widget_get_window(GTK_WIDGET(m_testController->mainWebView()->platformView()));
g_object_ref(event->motion.window);
gdk_event_set_device(event, gdk_device_manager_get_client_pointer(gdk_display_get_device_manager(gdk_window_get_display(event->motion.window))));
event->motion.state = 0 | getMouseButtonModifiers(m_mouseButtonCurrentlyDown);
event->motion.axes = 0;
int xRoot, yRoot;
gdk_window_get_root_coords(gtk_widget_get_window(GTK_WIDGET(m_testController->mainWebView()->platformView())), m_position.x, m_position.y , &xRoot, &yRoot);
event->motion.x_root = xRoot;
event->motion.y_root = yRoot;
sendOrQueueEvent(event);
}
static JSValueRef mouseMoveToCallback(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);
lastMousePositionX = (int)JSValueToNumber(context, arguments[0], exception);
g_return_val_if_fail((!exception || !*exception), JSValueMakeUndefined(context));
lastMousePositionY = (int)JSValueToNumber(context, arguments[1], exception);
g_return_val_if_fail((!exception || !*exception), JSValueMakeUndefined(context));
GdkEvent event;
memset(&event, 0, sizeof(event));
event.type = GDK_MOTION_NOTIFY;
event.motion.x = lastMousePositionX;
event.motion.y = lastMousePositionY;
event.motion.time = GDK_CURRENT_TIME;
event.motion.window = GTK_WIDGET(view)->window;
event.motion.device = gdk_device_get_core_pointer();
event.motion.state = getStateFlags();
int xRoot, yRoot;
#if GTK_CHECK_VERSION(2,17,3)
gdk_window_get_root_coords(GTK_WIDGET(view)->window, lastMousePositionX, lastMousePositionY, &xRoot, &yRoot);
#else
getRootCoords(GTK_WIDGET(view), &xRoot, &yRoot);
#endif
event.motion.x_root = xRoot;
event.motion.y_root = yRoot;
sendOrQueueEvent(event);
return JSValueMakeUndefined(context);
}
static void
gtk_tooltip_show_tooltip (GdkDisplay *display)
{
gint x, y;
GdkScreen *screen;
GdkWindow *window;
GtkWidget *tooltip_widget;
GtkTooltip *tooltip;
gboolean has_tooltip;
gboolean return_value = FALSE;
tooltip = g_object_get_data (G_OBJECT (display),
"gdk-display-current-tooltip");
if (tooltip->keyboard_mode_enabled)
{
x = y = -1;
tooltip_widget = tooltip->keyboard_widget;
}
else
{
GdkDevice *device;
gint tx, ty;
window = tooltip->last_window;
if (!GDK_IS_WINDOW (window))
return;
device = gdk_device_manager_get_client_pointer (gdk_display_get_device_manager (display));
gdk_window_get_device_position (window, device, &x, &y, NULL);
gdk_window_get_root_coords (window, x, y, &tx, &ty);
tooltip->last_x = tx;
tooltip->last_y = ty;
tooltip_widget = _gtk_widget_find_at_coords (window, x, y, &x, &y);
}
if (!tooltip_widget)
return;
g_object_get (tooltip_widget, "has-tooltip", &has_tooltip, NULL);
return_value = gtk_tooltip_run_requery (&tooltip_widget, tooltip, &x, &y);
if (!return_value)
return;
if (!tooltip->current_window)
{
if (gtk_widget_get_tooltip_window (tooltip_widget))
tooltip->current_window = gtk_widget_get_tooltip_window (tooltip_widget);
else
tooltip->current_window = GTK_WINDOW (GTK_TOOLTIP (tooltip)->window);
}
screen = gtk_widget_get_screen (tooltip_widget);
/* FIXME: should use tooltip->current_window iso tooltip->window */
if (screen != gtk_widget_get_screen (tooltip->window))
{
g_signal_handlers_disconnect_by_func (display,
gtk_tooltip_display_closed,
tooltip);
gtk_window_set_screen (GTK_WINDOW (tooltip->window), screen);
g_signal_connect (display, "closed",
G_CALLBACK (gtk_tooltip_display_closed), tooltip);
}
gtk_tooltip_position (tooltip, display, tooltip_widget);
/* Now a tooltip is visible again on the display, make sure browse
* mode is enabled.
*/
tooltip->browse_mode_enabled = TRUE;
if (tooltip->browse_mode_timeout_id)
{
g_source_remove (tooltip->browse_mode_timeout_id);
tooltip->browse_mode_timeout_id = 0;
}
}
/**
* gimp_button_menu_position:
* @button: a button widget to popup the menu from
* @menu: the menu to position
* @position: the preferred popup direction for the menu (left or right)
* @x: return location for x coordinate
* @y: return location for y coordinate
*
* Utility function to position a menu that pops up from a button.
**/
void
gimp_button_menu_position (GtkWidget *button,
GtkMenu *menu,
GtkPositionType position,
gint *x,
gint *y)
{
GdkScreen *screen;
GtkAllocation button_allocation;
GtkRequisition menu_requisition;
GdkRectangle rect;
gint monitor;
g_return_if_fail (GTK_IS_WIDGET (button));
g_return_if_fail (gtk_widget_get_realized (button));
g_return_if_fail (GTK_IS_MENU (menu));
g_return_if_fail (x != NULL);
g_return_if_fail (y != NULL);
gtk_widget_get_allocation (button, &button_allocation);
if (gtk_widget_get_direction (button) == GTK_TEXT_DIR_RTL)
{
switch (position)
{
case GTK_POS_LEFT: position = GTK_POS_RIGHT; break;
case GTK_POS_RIGHT: position = GTK_POS_LEFT; break;
default:
break;
}
}
*x = 0;
*y = 0;
if (! gtk_widget_get_has_window (button))
{
*x += button_allocation.x;
*y += button_allocation.y;
}
gdk_window_get_root_coords (gtk_widget_get_window (button), *x, *y, x, y);
gtk_widget_size_request (GTK_WIDGET (menu), &menu_requisition);
screen = gtk_widget_get_screen (button);
monitor = gdk_screen_get_monitor_at_point (screen, *x, *y);
gdk_screen_get_monitor_geometry (screen, monitor, &rect);
gtk_menu_set_screen (menu, screen);
switch (position)
{
case GTK_POS_LEFT:
*x -= menu_requisition.width;
if (*x < rect.x)
*x += menu_requisition.width + button_allocation.width;
break;
case GTK_POS_RIGHT:
*x += button_allocation.width;
if (*x + menu_requisition.width > rect.x + rect.width)
*x -= button_allocation.width + menu_requisition.width;
break;
default:
g_warning ("%s: unhandled position (%d)", G_STRFUNC, position);
break;
}
*y += button_allocation.height / 2;
if (*y + menu_requisition.height > rect.y + rect.height)
*y -= menu_requisition.height;
if (*y < rect.y)
*y = rect.y;
}
static void
gtk_popup_button_popup_real (GtkPopupButton *popup_button, GdkDevice *device)
{
GtkPopupButtonPrivate *priv = popup_button->priv;
GtkAllocation button_allocation, dock_allocation;
GdkScreen *screen;
gint monitor_num;
GdkRectangle monitor;
GtkWidget *toplevel;
GdkDevice *keyboard, *pointer;
guint32 time;
gint x, y;
g_return_if_fail (GTK_IS_POPUP_BUTTON (popup_button));
g_return_if_fail (GDK_IS_DEVICE (device));
if (!gtk_widget_get_realized (GTK_WIDGET (popup_button)))
return;
if (gtk_widget_get_mapped (priv->dock))
return;
if (priv->grab_pointer && priv->grab_keyboard)
return;
time = gtk_get_current_event_time ();
if (gdk_device_get_source (device) == GDK_SOURCE_KEYBOARD) {
keyboard = device;
pointer = gdk_device_get_associated_device (device);
} else {
pointer = device;
keyboard = gdk_device_get_associated_device (device);
}
toplevel = gtk_widget_get_toplevel (GTK_WIDGET (popup_button));
if (GTK_IS_WINDOW (toplevel))
gtk_window_group_add_window (gtk_window_get_group (GTK_WINDOW (toplevel)),
GTK_WINDOW (priv->dock));
/* positioning */
gtk_widget_show (priv->dock);
gtk_widget_get_allocation (GTK_WIDGET (popup_button), &button_allocation);
gdk_window_get_root_coords (gtk_widget_get_window (GTK_WIDGET (popup_button)),
button_allocation.x, button_allocation.y, &x, &y);
gtk_widget_get_allocation (GTK_WIDGET (priv->dock), &dock_allocation);
x = (x + button_allocation.width / 2) - (dock_allocation.width / 2);
y = y - dock_allocation.height;
GdkWindow *window = window = gtk_widget_get_window (GTK_WIDGET (popup_button));
screen = gtk_widget_get_screen (GTK_WIDGET (priv->dock));
monitor_num = gdk_screen_get_monitor_at_window (screen, window);
gdk_screen_get_monitor_workarea (screen, monitor_num, &monitor);
if (x < monitor.x)
x = monitor.x;
else if (x + dock_allocation.width > monitor.x + monitor.width)
x = monitor.x + monitor.width - dock_allocation.width;
gtk_window_move (GTK_WINDOW (priv->dock), x, y);
/* grabbing */
gtk_widget_grab_focus (priv->dock);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (popup_button), TRUE);
if (gdk_device_grab (pointer, gtk_widget_get_window (priv->dock),
GDK_OWNERSHIP_WINDOW, TRUE,
GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_MASK,
NULL, time) != GDK_GRAB_SUCCESS) {
gtk_device_grab_remove (priv->dock, pointer);
gtk_widget_hide (priv->dock);
return;
}
if (gdk_device_grab (keyboard, gtk_widget_get_window (priv->dock),
GDK_OWNERSHIP_WINDOW, TRUE,
GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK,
NULL, time) != GDK_GRAB_SUCCESS) {
gdk_device_ungrab (pointer, time);
gtk_device_grab_remove (priv->dock, pointer);
gtk_widget_hide (priv->dock);
return;
}
gtk_device_grab_add (priv->dock, pointer, TRUE);
priv->grab_pointer = pointer;
priv->grab_keyboard = keyboard;
}
