/* This is called when the grab is broken for * either the dock, or the scale itself */ static void gtk_scale_button_grab_notify (GtkScaleButton *button, gboolean was_grabbed) { GdkDisplay *display; GtkScaleButtonPrivate *priv; if (was_grabbed != FALSE) return; priv = button->priv; if (!GTK_WIDGET_HAS_GRAB (priv->dock)) return; if (gtk_widget_is_ancestor (gtk_grab_get_current (), priv->dock)) return; display = gtk_widget_get_display (priv->dock); gdk_display_keyboard_ungrab (display, GDK_CURRENT_TIME); gdk_display_pointer_ungrab (display, GDK_CURRENT_TIME); gtk_grab_remove (priv->dock); /* hide again */ gtk_widget_hide (priv->dock); priv->timeout = FALSE; }
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); }
/*# @method keyboard_ungrab GdkDisplay @brief Release any keyboard grab @param time a timestap (e.g GDK_CURRENT_TIME). Warning: gdk_display_keyboard_ungrab has been deprecated since version 3.0 and should not be used in newly-written code. Use gdk_device_ungrab(), together with gdk_device_grab() instead. */ FALCON_FUNC Display::keyboard_ungrab( VMARG ) { Item* i_t = vm->param( 0 ); #ifndef NO_PARAMETER_CHECK if ( !i_t || !i_t->isInteger() ) throw_inv_params( "I" ); #endif gdk_display_keyboard_ungrab( GET_DISPLAY( vm->self() ), i_t->asInteger() ); }
static void gimp_pick_button_shutdown (GimpPickButton *button) { GdkDisplay *display = gtk_widget_get_display (button->grab_widget); guint32 timestamp = gtk_get_current_event_time (); gdk_display_keyboard_ungrab (display, timestamp); gdk_display_pointer_ungrab (display, timestamp); gtk_grab_remove (button->grab_widget); }
static void gimp_pick_button_clicked (GtkButton *gtk_button) { GimpPickButton *button = GIMP_PICK_BUTTON (gtk_button); GtkWidget *widget; guint32 timestamp; if (! button->cursor) button->cursor = make_cursor (gtk_widget_get_display (GTK_WIDGET (gtk_button))); if (! button->grab_widget) { button->grab_widget = gtk_invisible_new (); gtk_widget_add_events (button->grab_widget, GDK_BUTTON_RELEASE_MASK | GDK_BUTTON_PRESS_MASK | GDK_POINTER_MOTION_MASK); gtk_widget_show (button->grab_widget); } widget = button->grab_widget; timestamp = gtk_get_current_event_time (); if (gdk_keyboard_grab (gtk_widget_get_window (widget), FALSE, timestamp) != GDK_GRAB_SUCCESS) { g_warning ("Failed to grab keyboard to do eyedropper"); return; } if (gdk_pointer_grab (gtk_widget_get_window (widget), FALSE, GDK_BUTTON_RELEASE_MASK | GDK_BUTTON_PRESS_MASK | GDK_POINTER_MOTION_MASK, NULL, button->cursor, timestamp) != GDK_GRAB_SUCCESS) { gdk_display_keyboard_ungrab (gtk_widget_get_display (widget), timestamp); g_warning ("Failed to grab pointer 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 gui_ungrab (Gimp *gimp) { GdkDisplay *display = gdk_display_get_default (); if (display) { gdk_display_pointer_ungrab (display, GDK_CURRENT_TIME); gdk_display_keyboard_ungrab (display, GDK_CURRENT_TIME); } }
static void ungrab_stuff (GtkWidget *widget, GtkCellRendererAccel *accel) { GdkDisplay *display = gtk_widget_get_display (widget); gdk_display_keyboard_ungrab (display, GDK_CURRENT_TIME); gdk_display_pointer_ungrab (display, GDK_CURRENT_TIME); g_signal_handlers_disconnect_by_func (G_OBJECT (accel->grab_widget), G_CALLBACK (grab_key_callback), accel); }
void gimp_display_shell_keyboard_ungrab (GimpDisplayShell *shell, const GdkEvent *event) { g_return_if_fail (GIMP_IS_DISPLAY_SHELL (shell)); g_return_if_fail (event != NULL); g_return_if_fail (shell->keyboard_grabbed == TRUE); gdk_display_keyboard_ungrab (gtk_widget_get_display (shell->canvas), gdk_event_get_time (event)); shell->keyboard_grabbed = FALSE; }
static void layer_select_destroy (LayerSelect *layer_select, guint32 time) { gdk_display_keyboard_ungrab (gtk_widget_get_display (layer_select->window), time); gtk_widget_destroy (layer_select->window); if (layer_select->orig_layer != gimp_image_get_active_layer (layer_select->image)) { gimp_image_flush (layer_select->image); } g_slice_free (LayerSelect, layer_select); }
static gboolean gimp_context_help_key_press (GtkWidget *widget, GdkEventKey *kevent, gpointer data) { if (kevent->keyval == GDK_KEY_Escape) { GdkDisplay *display = gtk_widget_get_display (widget); gtk_grab_remove (widget); gdk_display_keyboard_ungrab (display, kevent->time); gdk_display_pointer_ungrab (display, kevent->time); gtk_widget_destroy (widget); } return TRUE; }
static void gtk_scale_button_popdown (GtkWidget *widget) { GtkScaleButton *button; GtkScaleButtonPrivate *priv; GdkDisplay *display; button = GTK_SCALE_BUTTON (widget); priv = button->priv; /* ungrab focus */ display = gtk_widget_get_display (widget); gdk_display_keyboard_ungrab (display, GDK_CURRENT_TIME); gdk_display_pointer_ungrab (display, GDK_CURRENT_TIME); gtk_grab_remove (priv->dock); /* hide again */ gtk_widget_hide (priv->dock); priv->timeout = FALSE; }
static void gtk_button_finish_activate (GtkButton *button, gboolean do_it) { GtkWidget *widget = GTK_WIDGET (button); g_source_remove (button->activate_timeout); button->activate_timeout = 0; gdk_display_keyboard_ungrab (gtk_widget_get_display (widget), gtk_get_current_event_time ()); gtk_grab_remove (widget); button->button_down = FALSE; gtk_button_update_state (button); gtk_widget_queue_draw (GTK_WIDGET (button)); if (do_it) gtk_button_clicked (button); }
static gboolean gimp_context_help_button_press (GtkWidget *widget, GdkEventButton *bevent, gpointer data) { GtkWidget *event_widget = gtk_get_event_widget ((GdkEvent *) bevent); if (event_widget && bevent->button == 1 && bevent->type == GDK_BUTTON_PRESS) { GdkDisplay *display = gtk_widget_get_display (widget); gtk_grab_remove (widget); gdk_display_keyboard_ungrab (display, bevent->time); gdk_display_pointer_ungrab (display, bevent->time); gtk_widget_destroy (widget); if (event_widget != widget) g_idle_add (gimp_context_help_idle_show_help, event_widget); } return TRUE; }
static GtkCellEditable * gtk_cell_renderer_accel_start_editing (GtkCellRenderer *cell, GdkEvent *event, GtkWidget *widget, const gchar *path, GdkRectangle *background_area, GdkRectangle *cell_area, GtkCellRendererState flags) { GtkCellRendererText *celltext; GtkCellRendererAccel *accel; GtkWidget *label; GtkWidget *eventbox; celltext = GTK_CELL_RENDERER_TEXT (cell); accel = GTK_CELL_RENDERER_ACCEL (cell); /* If the cell isn't editable we return NULL. */ if (celltext->editable == FALSE) return NULL; g_return_val_if_fail (widget->window != NULL, NULL); if (gdk_keyboard_grab (widget->window, FALSE, gdk_event_get_time (event)) != GDK_GRAB_SUCCESS) return NULL; if (gdk_pointer_grab (widget->window, FALSE, GDK_BUTTON_PRESS_MASK, NULL, NULL, gdk_event_get_time (event)) != GDK_GRAB_SUCCESS) { gdk_display_keyboard_ungrab (gtk_widget_get_display (widget), gdk_event_get_time (event)); return NULL; } accel->grab_widget = widget; g_signal_connect (G_OBJECT (widget), "key-press-event", G_CALLBACK (grab_key_callback), accel); eventbox = g_object_new (_gtk_cell_editable_event_box_get_type (), NULL); accel->edit_widget = eventbox; g_object_add_weak_pointer (G_OBJECT (accel->edit_widget), (gpointer) &accel->edit_widget); label = gtk_label_new (NULL); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_widget_modify_bg (eventbox, GTK_STATE_NORMAL, &widget->style->bg[GTK_STATE_SELECTED]); gtk_widget_modify_fg (label, GTK_STATE_NORMAL, &widget->style->fg[GTK_STATE_SELECTED]); /* This label is displayed in a treeview cell displaying * an accelerator when the cell is clicked to change the * acelerator. */ gtk_label_set_text (GTK_LABEL (label), _("New accelerator...")); gtk_container_add (GTK_CONTAINER (eventbox), label); g_object_set_data_full (G_OBJECT (accel->edit_widget), "gtk-cell-renderer-text", g_strdup (path), g_free); gtk_widget_show_all (accel->edit_widget); g_signal_connect (G_OBJECT (accel->edit_widget), "unrealize", G_CALLBACK (ungrab_stuff), accel); return GTK_CELL_EDITABLE (accel->edit_widget); }
static gchar* passphrase_mbox(const gchar *uid_hint, const gchar *pass_hint, gint prev_bad) { gchar *the_passphrase = NULL; GtkWidget *vbox; GtkWidget *confirm_box; GtkWidget *window; GtkWidget *pass_entry; GtkWidget *ok_button; GtkWidget *cancel_button; window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW(window), _("Passphrase")); gtk_widget_set_size_request(window, 450, -1); gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER); gtk_window_set_modal(GTK_WINDOW(window), TRUE); gtk_window_set_policy(GTK_WINDOW(window), FALSE, FALSE, FALSE); g_signal_connect(G_OBJECT(window), "delete_event", G_CALLBACK(passphrase_deleted), NULL); g_signal_connect(G_OBJECT(window), "key_press_event", G_CALLBACK(passphrase_key_pressed), NULL); MANAGE_WINDOW_SIGNALS_CONNECT(window); manage_window_set_transient(GTK_WINDOW(window)); vbox = gtk_vbox_new(FALSE, 8); gtk_container_add(GTK_CONTAINER(window), vbox); gtk_container_set_border_width(GTK_CONTAINER(vbox), 8); if (uid_hint || pass_hint) { GtkWidget *label; label = create_description (uid_hint, pass_hint, prev_bad); gtk_box_pack_start (GTK_BOX(vbox), label, FALSE, FALSE, 0); } pass_entry = gtk_entry_new(); gtk_box_pack_start(GTK_BOX(vbox), pass_entry, FALSE, FALSE, 0); gtk_entry_set_visibility(GTK_ENTRY(pass_entry), FALSE); gtk_widget_grab_focus(pass_entry); gtkut_stock_button_set_create(&confirm_box, &ok_button, GTK_STOCK_OK, &cancel_button, GTK_STOCK_CANCEL, NULL, NULL); gtk_box_pack_end(GTK_BOX(vbox), confirm_box, FALSE, FALSE, 0); gtk_widget_grab_default(ok_button); g_signal_connect(G_OBJECT(ok_button), "clicked", G_CALLBACK(passphrase_ok_cb), NULL); g_signal_connect(G_OBJECT(pass_entry), "activate", G_CALLBACK(passphrase_ok_cb), NULL); g_signal_connect(G_OBJECT(cancel_button), "clicked", G_CALLBACK(passphrase_cancel_cb), NULL); gtk_window_set_position (GTK_WINDOW(window), GTK_WIN_POS_CENTER); if (grab_all) gtk_window_set_policy (GTK_WINDOW(window), FALSE, FALSE, TRUE); gtk_widget_show_all(window); if (grab_all) { /* make sure that window is viewable * FIXME: this is still not enough */ gtk_widget_show_now(window); gdk_flush(); #ifdef GDK_WINDOWING_X11 gdk_x11_display_grab(gdk_display_get_default()); #endif /* GDK_WINDOWING_X11 */ if (gdk_pointer_grab(window->window, TRUE, 0, window->window, NULL, GDK_CURRENT_TIME)) { #ifdef GDK_WINDOWING_X11 gdk_x11_display_ungrab(gdk_display_get_default()); #endif /* GDK_WINDOWING_X11 */ g_warning("OOPS: Could not grab mouse\n"); gtk_widget_destroy(window); return NULL; } if (gdk_keyboard_grab(window->window, FALSE, GDK_CURRENT_TIME)) { gdk_display_pointer_ungrab(gdk_display_get_default(), GDK_CURRENT_TIME); #ifdef GDK_WINDOWING_X11 gdk_x11_display_ungrab(gdk_display_get_default()); #endif /* GDK_WINDOWING_X11 */ g_warning("OOPS: Could not grab keyboard\n"); gtk_widget_destroy(window); return NULL; } } gtk_main(); if (grab_all) { gdk_display_keyboard_ungrab(gdk_display_get_default(), GDK_CURRENT_TIME); gdk_display_pointer_ungrab(gdk_display_get_default(), GDK_CURRENT_TIME); #ifdef GDK_WINDOWING_X11 gdk_x11_display_ungrab(gdk_display_get_default()); #endif /* GDK_WINDOWING_X11 */ gdk_flush(); } manage_window_focus_out(window, NULL, NULL); if (pass_ack) { const gchar *entry_text; entry_text = gtk_entry_get_text(GTK_ENTRY(pass_entry)); the_passphrase = g_locale_from_utf8(entry_text, -1, NULL, NULL, NULL); if (!the_passphrase) the_passphrase = g_strdup(entry_text); } gtk_widget_destroy(window); return the_passphrase; }
static VALUE rg_keyboard_ungrab(VALUE self, VALUE time) { gdk_display_keyboard_ungrab(_SELF(self), NUM2ULONG(time)); return self; }
/** * gdk_keyboard_ungrab: * @time_: a timestamp from a #GdkEvent, or %GDK_CURRENT_TIME if no * timestamp is available. * * Ungrabs the keyboard on the default display, if it is grabbed by this * application. * * Deprecated: 3.0: Use gdk_device_ungrab(), together with gdk_device_grab() * instead. **/ void gdk_keyboard_ungrab (guint32 time) { gdk_display_keyboard_ungrab (gdk_display_get_default (), time); }
static gboolean grab_key_callback (GtkWidget *widget, GdkEventKey *event, GtkCellRendererAccel *accel) { GdkModifierType accel_mods = 0; guint accel_key; gchar *path; gboolean edited; gboolean cleared; GdkModifierType consumed_modifiers; GdkDisplay *display; display = gtk_widget_get_display (widget); if (event->is_modifier) return TRUE; edited = FALSE; cleared = FALSE; gdk_keymap_translate_keyboard_state (gdk_keymap_get_for_display (display), event->hardware_keycode, event->state, event->group, NULL, NULL, NULL, &consumed_modifiers); accel_key = gdk_keyval_to_lower (event->keyval); if (accel_key == GDK_ISO_Left_Tab) accel_key = GDK_Tab; accel_mods = event->state & gtk_accelerator_get_default_mod_mask (); /* Filter consumed modifiers */ if (accel->accel_mode == GTK_CELL_RENDERER_ACCEL_MODE_GTK) accel_mods &= ~consumed_modifiers; /* Put shift back if it changed the case of the key, not otherwise. */ if (accel_key != event->keyval) accel_mods |= GDK_SHIFT_MASK; if (accel_mods == 0) { switch (event->keyval) { case GDK_Escape: goto out; /* cancel */ case GDK_BackSpace: /* clear the accelerator on Backspace */ cleared = TRUE; goto out; default: break; } } if (accel->accel_mode == GTK_CELL_RENDERER_ACCEL_MODE_GTK) { if (!gtk_accelerator_valid (accel_key, accel_mods)) { gtk_widget_error_bell (widget); return TRUE; } } edited = TRUE; out: gdk_display_keyboard_ungrab (display, event->time); gdk_display_pointer_ungrab (display, event->time); path = g_strdup (g_object_get_data (G_OBJECT (accel->edit_widget), "gtk-cell-renderer-text")); gtk_cell_editable_editing_done (GTK_CELL_EDITABLE (accel->edit_widget)); gtk_cell_editable_remove_widget (GTK_CELL_EDITABLE (accel->edit_widget)); accel->edit_widget = NULL; accel->grab_widget = NULL; if (edited) g_signal_emit (accel, signals[ACCEL_EDITED], 0, path, accel_key, accel_mods, event->hardware_keycode); else if (cleared) g_signal_emit (accel, signals[ACCEL_CLEARED], 0, path); g_free (path); return TRUE; }