void
gtk_inspector_on_inspect (GtkWidget *button,
GtkInspectorWindow *iw)
{
GdkDisplay *display;
GdkCursor *cursor;
GdkGrabStatus status;
if (!iw->invisible)
{
iw->invisible = gtk_invisible_new_for_screen (gdk_screen_get_default ());
gtk_widget_add_events (iw->invisible,
GDK_POINTER_MOTION_MASK |
GDK_BUTTON_PRESS_MASK |
GDK_BUTTON_RELEASE_MASK |
GDK_KEY_PRESS_MASK |
GDK_KEY_RELEASE_MASK);
gtk_widget_realize (iw->invisible);
gtk_widget_show (iw->invisible);
}
display = gdk_display_get_default ();
cursor = gdk_cursor_new_from_name (display, "crosshair");
status = gdk_seat_grab (gdk_display_get_default_seat (display),
gtk_widget_get_window (iw->invisible),
GDK_SEAT_CAPABILITY_ALL_POINTING, TRUE,
cursor, NULL, NULL, NULL);
g_object_unref (cursor);
iw->grabbed = status == GDK_GRAB_SUCCESS;
g_signal_connect (iw->invisible, "event", G_CALLBACK (property_query_event), iw);
gtk_grab_add (GTK_WIDGET (iw->invisible));
deemphasize_window (GTK_WIDGET (iw));
}
static gboolean
grab_keyboard (GtkWidget *win, GdkEvent * event, gpointer data)
{
KaPwDialog *pwdialog = KA_PWDIALOG (data);
GdkGrabStatus status;
GdkWindow *window = gtk_widget_get_window(win);
gtk_grab_add(win);
if (!pwdialog->priv->grabbed) {
status = gdk_seat_grab (gdk_display_get_default_seat(
gdk_window_get_display (window)),
window,
GDK_SEAT_CAPABILITY_ALL,
TRUE,
NULL,
event,
NULL,
NULL);
if (status == GDK_GRAB_SUCCESS)
pwdialog->priv->grabbed = TRUE;
else
g_message ("could not grab keyboard: %d", (int) status);
}
return FALSE;
}
/* Pulled from gtkcombobox.c */
static gboolean
popup_grab_on_window (GdkWindow *window,
GdkDevice *keyboard,
GdkDevice *pointer,
guint32 activate_time)
{
#if GTK_CHECK_VERSION(3,20,0)
GdkDisplay *display = gdk_display_get_default ();
GdkSeat *seat = gdk_display_get_default_seat (display);
GdkEvent *event = gtk_get_current_event ();
if (keyboard && gdk_seat_grab (seat, window, GDK_SEAT_CAPABILITY_KEYBOARD, TRUE, NULL,
event, NULL, NULL) != GDK_GRAB_SUCCESS )
#else
if (keyboard && gdk_device_grab (keyboard, window,
GDK_OWNERSHIP_WINDOW, TRUE,
GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK,
NULL, activate_time) != GDK_GRAB_SUCCESS)
#endif
return FALSE;
#if GTK_CHECK_VERSION(3,20,0)
if (pointer && gdk_seat_grab (seat, window, GDK_SEAT_CAPABILITY_POINTER, TRUE, NULL,
event, NULL, NULL) != GDK_GRAB_SUCCESS )
#else
if (pointer && gdk_device_grab (pointer, window,
GDK_OWNERSHIP_WINDOW, TRUE,
GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK |
GDK_POINTER_MOTION_MASK,
NULL, activate_time) != GDK_GRAB_SUCCESS)
#endif
{
if (keyboard)
#if GTK_CHECK_VERSION(3,20,0)
gdk_seat_ungrab (seat);
#else
gdk_device_ungrab (keyboard, activate_time);
#endif
return FALSE;
}
return TRUE;
}
/* entry point to this file, called from gimppickbutton.c */
void
_gimp_pick_button_default_pick (GimpPickButton *button)
{
GdkDisplay *display;
GtkWidget *widget;
if (! button->priv->cursor)
button->priv->cursor =
make_cursor (gtk_widget_get_display (GTK_WIDGET (button)));
if (! button->priv->grab_widget)
{
button->priv->grab_widget = gtk_invisible_new ();
gtk_widget_add_events (button->priv->grab_widget,
GDK_BUTTON_PRESS_MASK |
GDK_BUTTON_RELEASE_MASK |
GDK_BUTTON1_MOTION_MASK);
gtk_widget_show (button->priv->grab_widget);
}
widget = button->priv->grab_widget;
display = gtk_widget_get_display (widget);
if (gdk_seat_grab (gdk_display_get_default_seat (display),
gtk_widget_get_window (widget),
GDK_SEAT_CAPABILITY_ALL,
FALSE,
button->priv->cursor,
NULL,
NULL, NULL) != GDK_GRAB_SUCCESS)
{
g_warning ("Failed to grab seat to do eyedropper");
return;
}
gtk_grab_add (widget);
g_signal_connect (widget, "button-press-event",
G_CALLBACK (gimp_pick_button_mouse_press),
button);
g_signal_connect (widget, "key-press-event",
G_CALLBACK (gimp_pick_button_key_press),
button);
}
static void
grab_devices(GtkWidget *window)
{
GdkGrabStatus status;
GdkDevice *device;
/* Grab the current event device */
device = gtk_get_current_event_device();
if (device == NULL) {
WARN("Couldn't get current device");
return;
}
/* Grab every seat capabilities */
status = gdk_seat_grab(gdk_device_get_seat(device),
gtk_widget_get_window(window),
GDK_SEAT_CAPABILITY_ALL, TRUE,
NULL, NULL, NULL, NULL);
if (status != GDK_GRAB_SUCCESS)
WARN("Could not grab %s", gdk_device_get_name(device));
}
static gboolean
on_widget_button_press (GtkWidget *widget,
GdkEventButton *event,
char *item_id)
{
GdkDevice *device = gdk_event_get_device ((GdkEvent*) event);
g_print ("%s received 'button-press' signal\n", item_id);
if (device && strstr (item_id, "explicit"))
{
GdkGrabStatus status;
#if GTK_CHECK_VERSION(3,20,0)
status = gdk_seat_grab (gdk_device_get_seat (device),
gtk_widget_get_window (widget),
GDK_SEAT_CAPABILITY_ALL_POINTING,
FALSE, NULL, (GdkEvent*) event, NULL, NULL);
#else
GdkEventMask mask = GDK_BUTTON_PRESS_MASK
| GDK_BUTTON_RELEASE_MASK
| GDK_POINTER_MOTION_MASK
| GDK_POINTER_MOTION_HINT_MASK
| GDK_ENTER_NOTIFY_MASK
| GDK_LEAVE_NOTIFY_MASK;
status = gdk_device_grab (device, gtk_widget_get_window (widget),
GDK_OWNERSHIP_NONE, FALSE, mask,
NULL, event->time);
#endif
if (status == GDK_GRAB_SUCCESS)
g_print ("grabbed pointer\n");
else
g_print ("pointer grab failed\n");
}
return TRUE;
}
static void
gtk_real_button_activate (GtkButton *button)
{
GtkWidget *widget = GTK_WIDGET (button);
GtkButtonPrivate *priv = button->priv;
GdkDevice *device;
device = gtk_get_current_event_device ();
if (device && gdk_device_get_source (device) != GDK_SOURCE_KEYBOARD)
device = gdk_device_get_associated_device (device);
if (gtk_widget_get_realized (widget) && !priv->activate_timeout)
{
/* bgo#626336 - Only grab if we have a device (from an event), not if we
* were activated programmatically when no event is available.
*/
if (device && gdk_device_get_source (device) == GDK_SOURCE_KEYBOARD)
{
if (gdk_seat_grab (gdk_device_get_seat (device), priv->event_window,
GDK_SEAT_CAPABILITY_KEYBOARD, TRUE,
NULL, NULL, NULL, NULL) == GDK_GRAB_SUCCESS)
{
gtk_device_grab_add (widget, device, TRUE);
priv->grab_keyboard = device;
}
}
priv->activate_timeout = gdk_threads_add_timeout (ACTIVATE_TIMEOUT,
button_activate_timeout,
button);
g_source_set_name_by_id (priv->activate_timeout, "[gtk+] button_activate_timeout");
priv->button_down = TRUE;
gtk_button_update_state (button);
}
}
static void
grab_window_toggled (GtkToggleButton *button,
GtkWidget *widget)
{
GdkDevice *device = gtk_get_current_event_device ();
GdkSeat *seat = gdk_device_get_seat (device);
if (gtk_toggle_button_get_active (button))
{
int status;
status = gdk_seat_grab (seat, gtk_widget_get_window (widget),
GDK_SEAT_CAPABILITY_KEYBOARD,
FALSE, NULL, NULL, NULL, NULL);
if (status != GDK_GRAB_SUCCESS)
g_warning ("Could not grab keyboard! (%s)", grab_string (status));
}
else
{
gdk_seat_ungrab (seat);
}
}
static gboolean
gtk_window_button_press_callback(GtkWidget* widget, GdkEventButton* gdk_event, wxMiniFrame* win)
{
if (gdk_event->window != gtk_widget_get_window(widget))
return false;
if (g_blockEventsOnDrag) return TRUE;
if (g_blockEventsOnScroll) return TRUE;
if (win->m_isDragging) return TRUE;
int style = win->GetWindowStyle();
int y = (int)gdk_event->y;
int x = (int)gdk_event->x;
if ((style & wxRESIZE_BORDER) &&
(x > win->m_width-14) && (y > win->m_height-14))
{
GtkWidget *ancestor = gtk_widget_get_toplevel( widget );
GdkWindow *source = gtk_widget_get_window(widget);
int org_x = 0;
int org_y = 0;
gdk_window_get_origin( source, &org_x, &org_y );
gtk_window_begin_resize_drag (GTK_WINDOW (ancestor),
GDK_WINDOW_EDGE_SOUTH_EAST,
1,
org_x + x,
org_y + y,
0);
return TRUE;
}
if (win->m_miniTitle && (style & wxCLOSE_BOX))
{
if ((y > 3) && (y < 19) && (x > win->m_width-19) && (x < win->m_width-3))
{
win->Close();
return TRUE;
}
}
if (y >= win->m_miniEdge + win->m_miniTitle)
return true;
gdk_window_raise(gtk_widget_get_window(win->m_widget));
#ifdef __WXGTK4__
gdk_seat_grab(
gdk_event_get_seat((GdkEvent*)gdk_event), gdk_event_get_window((GdkEvent*)gdk_event),
GDK_SEAT_CAPABILITY_POINTER, false, NULL, (GdkEvent*)gdk_event, NULL, 0);
#else
const GdkEventMask mask = GdkEventMask(
GDK_BUTTON_PRESS_MASK |
GDK_BUTTON_RELEASE_MASK |
GDK_POINTER_MOTION_MASK |
GDK_POINTER_MOTION_HINT_MASK |
GDK_BUTTON_MOTION_MASK |
GDK_BUTTON1_MOTION_MASK);
#ifdef __WXGTK3__
wxGCC_WARNING_SUPPRESS(deprecated-declarations)
gdk_device_grab(
gdk_event->device, gdk_event->window, GDK_OWNERSHIP_NONE,
false, mask, NULL, gdk_event->time);
wxGCC_WARNING_RESTORE()
#else
gdk_pointer_grab(gdk_event->window, false, mask, NULL, NULL, gdk_event->time);
#endif
#endif // !__WXGTK4__
win->m_diffX = x;
win->m_diffY = y;
win->m_oldX = 0;
win->m_oldY = 0;
win->m_isDragging = true;
return TRUE;
}
void
gstyle_eyedropper_set_source_event (GstyleEyedropper *self,
GdkEvent *event)
{
GtkWidget *source;
GtkStyleContext *context;
GtkWidget *box;
GtkWidget *swatch;
GdkGrabStatus status;
gint x_root, y_root;
gint x, y;
g_return_if_fail (GSTYLE_IS_EYEDROPPER (self));
g_return_if_fail (event != NULL);
self->seat = g_object_ref (gdk_event_get_seat (event));
source = gtk_get_event_widget (event);
self->screen = gdk_event_get_screen (event);
g_signal_connect_swapped (self->screen,
"size-changed",
G_CALLBACK (gstyle_eyedropper_screen_size_changed_cb),
self);
self->window = g_object_ref_sink (gtk_window_new (GTK_WINDOW_POPUP));
gtk_window_set_screen (GTK_WINDOW (self->window),self->screen);
gtk_widget_set_name (self->window, "gstyleeyedropper");
context = gtk_widget_get_style_context (self->window);
self->default_provider = gstyle_css_provider_init_default (gtk_style_context_get_screen (context));
box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
gtk_container_add (GTK_CONTAINER (self->window), box);
self->zoom_area = gtk_drawing_area_new ();
gtk_widget_set_size_request (self->zoom_area, ZOOM_AREA_WIDTH, ZOOM_AREA_HEIGHT);
gtk_container_add (GTK_CONTAINER (box), self->zoom_area);
swatch = g_object_new (GSTYLE_TYPE_COLOR_WIDGET,
"fallback-name-kind", GSTYLE_COLOR_KIND_RGB_HEX6,
"fallback-name-visible", TRUE,
"color", self->color,
NULL);
gtk_container_add (GTK_CONTAINER (box), swatch);
g_signal_connect_object (self->zoom_area,
"draw",
G_CALLBACK (gstyle_eyedropper_zoom_area_draw_cb),
self,
G_CONNECT_SWAPPED);
self->screen_width = gdk_screen_get_width (self->screen);
self->screen_height = gdk_screen_get_height (self->screen);
gstyle_eyedropper_event_get_root_coords (self, event, &x_root, &y_root);
gstyle_eyedropper_calculate_window_position (self, GTK_WINDOW (self->window), x_root, y_root, &x, &y);
gtk_window_move (GTK_WINDOW (self->window), x, y);
gtk_widget_show_all (self->window);
gtk_widget_add_events (self->window,
GDK_BUTTON_RELEASE_MASK | GDK_BUTTON_PRESS_MASK | GDK_POINTER_MOTION_MASK);
self->cursor = gdk_cursor_new_from_name (gdk_screen_get_display (self->screen), "cell");
gtk_grab_add (self->window);
status = gdk_seat_grab (self->seat,
gtk_widget_get_window (source),
GDK_SEAT_CAPABILITY_ALL,
FALSE,
self->cursor,
event,
NULL, NULL);
if (status != GDK_GRAB_SUCCESS)
{
g_warning ("grab failed status:%i\n", status);
return;
}
self->motion_notify_handler_id =
g_signal_connect_swapped (self->window, "motion-notify-event",
G_CALLBACK (gstyle_eyedropper_pointer_motion_notify_cb),
self);
self->pointer_pressed_handler_id =
g_signal_connect_swapped (self->window,
"button-press-event",
G_CALLBACK (gstyle_eyedropper_pointer_pressed_cb),
self);
self->pointer_wheel_handler_id =
g_signal_connect_swapped (self->window,
"scroll-event",
G_CALLBACK (gstyle_eyedropper_pointer_wheel_cb),
self);
self->key_handler_id =
g_signal_connect_swapped (self->window,
"key-press-event",
G_CALLBACK (gstyle_eyedropper_key_pressed_cb),
self);
self->grab_broken_handler_id =
g_signal_connect_swapped (self->window,
"grab-broken-event",
G_CALLBACK (gstyle_eyedropper_grab_broken_cb),
self);
}
bool wxPopupTransientWindow::Show( bool show )
{
#ifdef __WXGTK__
if (!show)
{
#ifdef __WXGTK3__
GdkDisplay* display = gtk_widget_get_display(m_widget);
#ifdef __WXGTK4__
gdk_seat_ungrab(gdk_display_get_default_seat(display));
#else
wxGCC_WARNING_SUPPRESS(deprecated-declarations)
GdkDeviceManager* manager = gdk_display_get_device_manager(display);
GdkDevice* device = gdk_device_manager_get_client_pointer(manager);
gdk_device_ungrab(device, unsigned(GDK_CURRENT_TIME));
wxGCC_WARNING_RESTORE()
#endif
#else
gdk_pointer_ungrab( (guint32)GDK_CURRENT_TIME );
#endif
gtk_grab_remove( m_widget );
}
#endif
#ifdef __WXX11__
if (!show)
{
XUngrabPointer( wxGlobalDisplay(), CurrentTime );
}
#endif
#if defined( __WXMSW__ ) || defined( __WXMAC__)
if (!show && m_child && m_child->HasCapture())
{
m_child->ReleaseMouse();
}
#endif
bool ret = wxPopupWindow::Show( show );
#ifdef __WXGTK__
if (show)
{
gtk_grab_add( m_widget );
GdkWindow* window = gtk_widget_get_window(m_widget);
#ifdef __WXGTK4__
GdkDisplay* display = gdk_window_get_display(window);
GdkSeat* seat = gdk_display_get_default_seat(display);
gdk_seat_grab(seat, window, GDK_SEAT_CAPABILITY_POINTER, false, NULL, NULL, NULL, 0);
#else
const GdkEventMask mask = GdkEventMask(
GDK_BUTTON_PRESS_MASK |
GDK_BUTTON_RELEASE_MASK |
GDK_POINTER_MOTION_HINT_MASK |
GDK_POINTER_MOTION_MASK);
#ifdef __WXGTK3__
GdkDisplay* display = gdk_window_get_display(window);
wxGCC_WARNING_SUPPRESS(deprecated-declarations)
GdkDeviceManager* manager = gdk_display_get_device_manager(display);
GdkDevice* device = gdk_device_manager_get_client_pointer(manager);
gdk_device_grab(device, window,
GDK_OWNERSHIP_NONE, true, mask, NULL, unsigned(GDK_CURRENT_TIME));
wxGCC_WARNING_RESTORE()
#else
gdk_pointer_grab( window, true,
mask,
NULL,
NULL,
(guint32)GDK_CURRENT_TIME );
#endif
#endif // !__WXGTK4__
}
#endif
#ifdef __WXX11__
if (show)
{
Window xwindow = (Window) m_clientWindow;
/* int res =*/ XGrabPointer(wxGlobalDisplay(), xwindow,
True,
ButtonPressMask | ButtonReleaseMask | ButtonMotionMask | EnterWindowMask | LeaveWindowMask | PointerMotionMask,
GrabModeAsync,
GrabModeAsync,
None,
None,
CurrentTime );
}
#endif
#if defined( __WXMSW__ ) || defined( __WXMAC__)
if (show && m_child)
{
// Assume that the mouse is outside the popup to begin with
m_child->CaptureMouse();
}
#endif
return ret;
}
static GtkCellEditable *
egg_cell_renderer_keys_start_editing (GtkCellRenderer *cell,
GdkEvent *event,
GtkWidget *widget,
const gchar *path,
const GdkRectangle *background_area,
const GdkRectangle *cell_area,
GtkCellRendererState flags)
{
GtkCellRendererText *celltext;
EggCellRendererKeys *keys;
GdkDisplay *display;
GdkSeat *seat;
GtkWidget *label;
GtkWidget *eventbox;
GValue celltext_editable = {0};
celltext = GTK_CELL_RENDERER_TEXT (cell);
keys = EGG_CELL_RENDERER_KEYS (cell);
/* If the cell isn't editable we return NULL. */
g_value_init (&celltext_editable, G_TYPE_BOOLEAN);
g_object_get_property (G_OBJECT (celltext), "editable", &celltext_editable);
if (g_value_get_boolean (&celltext_editable) == FALSE)
return NULL;
g_return_val_if_fail (gtk_widget_get_window (widget) != NULL, NULL);
display = gtk_widget_get_display (widget);
seat = gdk_display_get_default_seat (display);
if (gdk_seat_grab (seat,
gtk_widget_get_window (widget),
GDK_SEAT_CAPABILITY_ALL,
FALSE,
NULL,
event,
NULL,
NULL) != GDK_GRAB_SUCCESS)
return NULL;
keys->grab_widget = widget;
g_signal_connect (G_OBJECT (widget), "key_press_event",
G_CALLBACK (grab_key_callback),
keys);
eventbox = g_object_new (pointless_eventbox_subclass_get_type (),
NULL);
keys->edit_widget = eventbox;
g_object_add_weak_pointer (G_OBJECT (keys->edit_widget),
(void**) &keys->edit_widget);
label = gtk_label_new (NULL);
gtk_label_set_xalign (GTK_LABEL (label), 0.0);
gtk_widget_modify_bg (eventbox, GTK_STATE_NORMAL,
>k_widget_get_style (widget)->bg[GTK_STATE_SELECTED]);
gtk_widget_modify_fg (label, GTK_STATE_NORMAL,
>k_widget_get_style (widget)->fg[GTK_STATE_SELECTED]);
gtk_label_set_text (GTK_LABEL (label),
TOOLTIP_TEXT);
gtk_container_add (GTK_CONTAINER (eventbox), label);
g_object_set_data_full (G_OBJECT (keys->edit_widget), EGG_CELL_RENDERER_TEXT_PATH,
g_strdup (path), g_free);
gtk_widget_show_all (keys->edit_widget);
g_signal_connect (G_OBJECT (keys->edit_widget), "unrealize",
G_CALLBACK (ungrab_stuff), keys);
keys->edit_key = keys->accel_key;
return GTK_CELL_EDITABLE (keys->edit_widget);
}
