void snippets_accel_connect (GuSnippets* sc, guint keyval, GdkModifierType mod, GClosure* closure) { gchar* acc = NULL; gtk_accel_group_connect (sc->accel_group, keyval, gtk_accelerator_get_default_mod_mask () & mod, GTK_ACCEL_VISIBLE, closure); acc = gtk_accelerator_get_label (keyval, gtk_accelerator_get_default_mod_mask () & mod); slog (L_DEBUG, "Accelerator `%s' connected\n", acc); g_free (acc); }
static gboolean window_key_press_event (GtkWidget *win, GdkEventKey *event, GsShell *shell) { GsShellPrivate *priv = gs_shell_get_instance_private (shell); GdkKeymap *keymap; GdkModifierType state; gboolean is_rtl; GtkWidget *button; button = GTK_WIDGET (gtk_builder_get_object (priv->builder, "button_back")); if (!gtk_widget_is_visible (button) || !gtk_widget_is_sensitive (button)) return GDK_EVENT_PROPAGATE; state = event->state; keymap = gdk_keymap_get_default (); gdk_keymap_add_virtual_modifiers (keymap, &state); state = state & gtk_accelerator_get_default_mod_mask (); is_rtl = gtk_widget_get_direction (button) == GTK_TEXT_DIR_RTL; if ((!is_rtl && state == GDK_MOD1_MASK && event->keyval == GDK_KEY_Left) || (is_rtl && state == GDK_MOD1_MASK && event->keyval == GDK_KEY_Right) || event->keyval == GDK_KEY_Back) { gtk_widget_activate (button); return GDK_EVENT_STOP; } return GDK_EVENT_PROPAGATE; }
static gboolean button_press_cb (NautilusNotebook *notebook, GdkEventButton *event, gpointer data) { int tab_clicked; tab_clicked = find_tab_num_at_pos (notebook, event->x_root, event->y_root); if (event->type == GDK_BUTTON_PRESS && event->button == 3 && (event->state & gtk_accelerator_get_default_mod_mask ()) == 0) { if (tab_clicked == -1) { /* consume event, so that we don't pop up the context menu when * the mouse if not over a tab label */ return TRUE; } /* switch to the page the mouse is over, but don't consume the event */ gtk_notebook_set_current_page (GTK_NOTEBOOK (notebook), tab_clicked); } return FALSE; }
gpointer edit_metadata__gth_browser_file_list_key_press_cb (GthBrowser *browser, GdkEventKey *event) { gpointer result = NULL; guint modifiers; modifiers = gtk_accelerator_get_default_mod_mask (); if ((event->state & modifiers) != 0) return NULL; switch (gdk_keyval_to_lower (event->keyval)) { case GDK_KEY_c: gth_browser_activate_action_edit_comment (NULL, browser); result = GINT_TO_POINTER (1); break; case GDK_KEY_t: gth_browser_activate_action_edit_tags (NULL, browser); result = GINT_TO_POINTER (1); break; } return result; }
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; }
bool perfroll::on_scroll_event (GdkEventScroll * ev) { guint modifiers; /* used to filter out caps/num lock etc. */ modifiers = gtk_accelerator_get_default_mod_mask(); if ((ev->state & modifiers) == GDK_SHIFT_MASK) { double val = m_hadjust.get_value(); if (ev->direction == GDK_SCROLL_UP) val -= m_hadjust.get_step_increment(); else if (ev->direction == GDK_SCROLL_DOWN) val += m_hadjust.get_step_increment(); m_hadjust.clamp_page(val, val + m_hadjust.get_page_size()); } else { double val = m_vadjust.get_value(); if (ev->direction == GDK_SCROLL_UP) val -= m_vadjust.get_step_increment(); else if (ev->direction == GDK_SCROLL_DOWN) val += m_vadjust.get_step_increment(); m_vadjust.clamp_page(val, val + m_vadjust.get_page_size()); } return true; }
static gboolean on_video_window_key_pressed( GtkWidget *widget, GdkEventKey *event, gpointer user_data ) { main_window_t win = (main_window_t)user_data; if( win->is_grabbed ) { #ifdef HAVE_GTK_OSX /* On OSX, use the command key rather than ctrl-alt. Mainly because GTK/OSX * doesn't seem to be able to get ctrl-alt reliably **/ if( event->keyval == GDK_Meta_L || event->keyval == GDK_Meta_R ) { video_window_ungrab_display(win); return TRUE; } #else /* Check for ungrab key combo (ctrl-alt). Unfortunately GDK sends it as * a singly-modified keypress rather than a double-modified 'null' press, * so we have to do a little more work. * Only check Ctrl/Shift/Alt for state - don't want to check numlock/capslock/ * mouse buttons/etc */ int mod = gdk_keycode_to_modifier(gtk_widget_get_display(widget), event->hardware_keycode); int state = event->state & gtk_accelerator_get_default_mod_mask(); if( (state == GDK_CONTROL_MASK && mod == GDK_MOD1_MASK) || (state == GDK_MOD1_MASK && mod == GDK_CONTROL_MASK) ) { video_window_ungrab_display(win); // Consume the keypress, DC doesn't get it. return TRUE; } #endif } input_event_keydown( NULL, gtk_get_unmodified_keyval(event), MAX_PRESSURE ); return TRUE; }
static gboolean shell_searchbar_entry_key_press_cb (EShellSearchbar *searchbar, GdkEventKey *key_event, GtkWindow *entry) { EShellView *shell_view; EShellWindow *shell_window; GtkAction *action; guint mask; mask = gtk_accelerator_get_default_mod_mask (); if ((key_event->state & mask) != GDK_MOD1_MASK) return FALSE; if (key_event->keyval != GDK_KEY_Down) return FALSE; shell_view = e_shell_searchbar_get_shell_view (searchbar); shell_window = e_shell_view_get_shell_window (shell_view); action = E_SHELL_WINDOW_ACTION_SEARCH_OPTIONS (shell_window); gtk_action_activate (action); return TRUE; }
void on_key_press_event(GtkWidget *self, GdkEventKey *event, gpointer v) { KeyGrabButton* b = KEYGRAB_BUTTON(v); guint key; GdkModifierType mods = event->state & gtk_accelerator_get_default_mod_mask(); if ((event->keyval == FcitxKey_Escape || event->keyval == FcitxKey_Return) && !mods) { if (event->keyval == FcitxKey_Escape) g_signal_emit_by_name(G_OBJECT(b), "changed", b->key, b->mods); end_key_grab(b); keygrab_button_set_key(b, 0, 0); return; } key = gdk_keyval_to_upper(event->keyval); if (key == FcitxKey_ISO_Left_Tab) key = FcitxKey_Tab; if (gtk_accelerator_valid(key, mods) || (key == FcitxKey_Tab && mods)) { keygrab_button_set_key(b, key, mods); end_key_grab(b); b->key = key; b->mods = mods; g_signal_emit_by_name(G_OBJECT(b), "changed", b->key, b->mods); return; } keygrab_button_set_key(b, key, mods); }
static gboolean onButtonPressExonView(GtkWidget *exonView, GdkEventButton *event, gpointer data) { gboolean handled = FALSE; if (event->button == 1) /* left button */ { /* If we clicked on top of an exon, select that msp */ guint modifiers = gtk_accelerator_get_default_mod_mask(); const gboolean ctrlModifier = ((event->state & modifiers) == GDK_CONTROL_MASK); const gboolean shiftModifier = ((event->state & modifiers) == GDK_SHIFT_MASK); handled = selectClickedExon(exonView, event, ctrlModifier, shiftModifier); } ExonViewProperties *properties = exonViewGetProperties(exonView); BigPictureProperties *bpProperties = bigPictureGetProperties(properties->bigPicture); if (event->button == 2 || (event->button == 1 && !handled && (event->type == GDK_2BUTTON_PRESS || clickedInRect(event, &properties->highlightRect, bpProperties->highlightBoxMinWidth)))) { /* Draw the preview box (draw it on the other big picture components as well) */ int x = event->x; if (event->button == 1 && event->type == GDK_BUTTON_PRESS) x = properties->highlightRect.x + properties->highlightRect.width / 2; showPreviewBox(exonViewGetBigPicture(exonView), event->x, TRUE, x - event->x); handled = TRUE; } return handled; }
static gboolean panel_menu_key_press_handler (GtkWidget *widget, GdkEventKey *event) { gboolean retval = FALSE; #if GTK_CHECK_VERSION (3, 0, 0) GtkWidget *active_menu_item = NULL; #endif if ((event->keyval == GDK_Menu) || (event->keyval == GDK_F10 && (event->state & gtk_accelerator_get_default_mod_mask ()) == GDK_SHIFT_MASK)) { GtkMenuShell *menu_shell = GTK_MENU_SHELL (widget); #if GTK_CHECK_VERSION (3, 0, 0) active_menu_item = gtk_menu_shell_get_selected_item (menu_shell); if (active_menu_item && gtk_menu_item_get_submenu (GTK_MENU_ITEM (active_menu_item)) == NULL) { #else if (menu_shell->active_menu_item && GTK_MENU_ITEM (menu_shell->active_menu_item)->submenu == NULL) { #endif GdkEventButton bevent; bevent.button = 3; bevent.time = GDK_CURRENT_TIME; #if GTK_CHECK_VERSION (3, 0, 0) retval = show_item_menu (active_menu_item, &bevent); #else retval = show_item_menu (menu_shell->active_menu_item, &bevent); #endif } } return retval; }
static gboolean button_press_cb (EphyNotebook *notebook, GdkEventButton *event, gpointer data) { int tab_clicked; tab_clicked = find_tab_num_at_pos (notebook, event->x_root, event->y_root); if (event->type == GDK_BUTTON_PRESS && event->button == GDK_BUTTON_MIDDLE) { GtkWidget *tab = gtk_notebook_get_nth_page (GTK_NOTEBOOK (notebook), tab_clicked); g_signal_emit (notebook, signals[TAB_CLOSE_REQUEST], 0, tab); return GDK_EVENT_STOP; } if (event->type == GDK_BUTTON_PRESS && event->button == GDK_BUTTON_SECONDARY && (event->state & gtk_accelerator_get_default_mod_mask ()) == 0) { if (tab_clicked == -1) { /* Consume event so that we don't pop up the context * menu when the mouse is not over a tab label. */ return GDK_EVENT_STOP; } /* Switch to the page where the mouse is over, but don't consume the * event. */ gtk_notebook_set_current_page (GTK_NOTEBOOK (notebook), tab_clicked); } return GDK_EVENT_PROPAGATE; }
static gboolean gedit_notebook_button_press (GtkWidget *widget, GdkEventButton *event) { GtkNotebook *nb = GTK_NOTEBOOK (widget); if (event->type == GDK_BUTTON_PRESS && event->button == GDK_BUTTON_SECONDARY && (event->state & gtk_accelerator_get_default_mod_mask ()) == 0) { gint tab_clicked; tab_clicked = find_tab_num_at_pos (nb, event->x_root, event->y_root); if (tab_clicked >= 0) { GtkWidget *tab; tab = gtk_notebook_get_nth_page (nb, tab_clicked); g_signal_emit (G_OBJECT (widget), signals[SHOW_POPUP_MENU], 0, event, tab); return TRUE; } } return GTK_WIDGET_CLASS (gedit_notebook_parent_class)->button_press_event (widget, event); }
Accelerator accelerator_for_event_key( guint keyval, guint state ){ keyval = gdk_keyval_to_upper( keyval ); if ( keyval == GDK_KEY_ISO_Left_Tab ) { keyval = GDK_KEY_Tab; } return Accelerator( keyval, (GdkModifierType)( state & gtk_accelerator_get_default_mod_mask() ) ); }
gboolean on_mainwin_key_press_event (GtkWidget *widget, GdkEventKey *event, gpointer user_data) { // local hotkeys GdkModifierType consumed; guint accel_key; gdk_keymap_translate_keyboard_state (gdk_keymap_get_default (), event->hardware_keycode, event->state, 0, &accel_key, NULL, NULL, &consumed); if (accel_key == GDK_ISO_Left_Tab) accel_key = GDK_Tab; int mods = event->state & gtk_accelerator_get_default_mod_mask (); mods &= ~(consumed&~GDK_SHIFT_MASK); int lower = gdk_keyval_to_lower (accel_key); if (lower != accel_key) { accel_key = lower; } trace ("pressed: keycode: %x, mods: %x, hw: %x, translated: %x\n", event->keyval, mods, event->hardware_keycode, accel_key); DB_plugin_t *hkplug = deadbeef->plug_get_for_id ("hotkeys"); if (hkplug) { int ctx; DB_plugin_action_t *act = ((DB_hotkeys_plugin_t *)hkplug)->get_action_for_keycombo (accel_key, mods, 0, &ctx); if (act && act->callback2) { trace ("executing action %s in ctx %d\n", act->name, ctx); act->callback2 (act, ctx); return TRUE; } else if (act && act->callback) { gtkui_exec_action_14 (act, -1); } } trace ("action not found\n"); return FALSE; }
int clip_GTK_ACCELERATORGETDEFAULTMODMASK(ClipMachine * ClipMachineMemory) { _clip_retni(ClipMachineMemory, (int) gtk_accelerator_get_default_mod_mask()); return 0; //err: // return 1; }
static gboolean entry_key_press_event_cb (GtkEntry *entry, GdkEventKey *event, EphyFindToolbar *toolbar) { EphyFindToolbarPrivate *priv = toolbar->priv; guint mask = gtk_accelerator_get_default_mod_mask (); gboolean handled = FALSE; if ((event->state & mask) == 0) { handled = TRUE; switch (event->keyval) { case GDK_KEY_Up: case GDK_KEY_KP_Up: scroll_lines (priv->web_view, -1); break; case GDK_KEY_Down: case GDK_KEY_KP_Down: scroll_lines (priv->web_view, 1); break; case GDK_KEY_Page_Up: case GDK_KEY_KP_Page_Up: scroll_pages (priv->web_view, -1); break; case GDK_KEY_Page_Down: case GDK_KEY_KP_Page_Down: scroll_pages (priv->web_view, 1); break; case GDK_KEY_Escape: /* Hide the toolbar when ESC is pressed */ ephy_find_toolbar_request_close (toolbar); break; default: handled = FALSE; break; } } else if ((event->state & mask) == GDK_CONTROL_MASK && (event->keyval == GDK_KEY_Return || event->keyval == GDK_KEY_KP_Enter || event->keyval == GDK_KEY_ISO_Enter)) { handled = ephy_find_toolbar_activate_link (toolbar, event->state); } else if ((event->state & mask) == GDK_SHIFT_MASK && (event->keyval == GDK_KEY_Return || event->keyval == GDK_KEY_KP_Enter || event->keyval == GDK_KEY_ISO_Enter)) { handled = TRUE; g_signal_emit (toolbar, signals[PREVIOUS], 0); } return handled; }
/* * Keep code in panel-applet-bindings.c in sync! */ static void panel_util_key_event_is_binding (GdkEventKey *event, GType type, const char *signal_name, gboolean *is_popup, gboolean *is_popup_modifier) { GtkBindingSet *binding_set; GtkBindingEntry *binding_entry; gboolean popup = FALSE; gboolean popup_modifier = FALSE; guint modifiers; char *signal_dash; char *signal_underscore; modifiers = event->state & gtk_accelerator_get_default_mod_mask (); signal_dash = g_strdup (signal_name); g_strdelimit (signal_dash, "_", '-'); signal_underscore = g_strdup (signal_name); g_strdelimit (signal_underscore, "-", '_'); binding_set = gtk_binding_set_by_class (g_type_class_peek (type)); for (binding_entry = binding_set->entries; binding_entry != NULL; binding_entry = binding_entry->set_next) { GtkBindingSignal *binding_signal; for (binding_signal = binding_entry->signals; binding_signal != NULL; binding_signal = binding_signal->next) { if (g_strcmp0 (binding_signal->signal_name, signal_dash) == 0 || g_strcmp0 (binding_signal->signal_name, signal_underscore) == 0) { if (binding_entry->keyval != event->keyval) break; popup = modifiers == binding_entry->modifiers; popup_modifier = modifiers == (panel_bindings_get_mouse_button_modifier_keymask ()|binding_entry->modifiers); break; } } if (popup || popup_modifier) break; } if (is_popup) *is_popup = popup; if (is_popup_modifier) *is_popup_modifier = popup_modifier; g_free (signal_dash); g_free (signal_underscore); }
/* Send keyboard accelerators to the parent window, if necessary. * This code is heavily based on gtk_menu_key_press () */ static gboolean hildon_app_menu_key_press (GtkWidget *widget, GdkEventKey *event) { GtkWindow *parent_window; HildonAppMenuPrivate *priv; g_return_val_if_fail (HILDON_IS_APP_MENU (widget), FALSE); g_return_val_if_fail (event != NULL, FALSE); if (GTK_WIDGET_CLASS (hildon_app_menu_parent_class)->key_press_event (widget, event)) return TRUE; priv = HILDON_APP_MENU_GET_PRIVATE (widget); parent_window = priv->parent_window; if (parent_window) { guint accel_key, accel_mods; GdkModifierType consumed_modifiers; GdkDisplay *display; GSList *accel_groups; GSList *list; display = gtk_widget_get_display (widget); /* Figure out what modifiers went into determining the key symbol */ 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); accel_mods = event->state & gtk_accelerator_get_default_mod_mask () & ~consumed_modifiers; /* If lowercasing affects the keysym, then we need to include SHIFT in the modifiers, * We re-upper case when we match against the keyval, but display and save in caseless form. */ if (accel_key != event->keyval) accel_mods |= GDK_SHIFT_MASK; accel_groups = gtk_accel_groups_from_object (G_OBJECT (parent_window)); for (list = accel_groups; list; list = list->next) { GtkAccelGroup *accel_group = list->data; if (gtk_accel_group_query (accel_group, accel_key, accel_mods, NULL)) { gtk_window_activate_key (parent_window, event); priv->hide_idle_id = gdk_threads_add_idle (hildon_app_menu_hide_idle, widget); break; } } } return TRUE; }
static gboolean on_key_pressed_cb (GtkWidget *w, GdkEvent *event, gpointer user_data) { BjbWindowBase *self = BJB_WINDOW_BASE (user_data); BjbWindowBasePriv *priv = self->priv; GdkModifierType modifiers; modifiers = gtk_accelerator_get_default_mod_mask (); /* First check for Alt <- to go back */ if ((event->key.state & modifiers) == GDK_MOD1_MASK && event->key.keyval == GDK_KEY_Left && priv->current_view == BJB_WINDOW_BASE_NOTE_VIEW) { BijiItemsGroup items; items = bjb_controller_get_group (priv->controller); if (items == BIJI_LIVING_ITEMS) bjb_window_base_switch_to (self, BJB_WINDOW_BASE_MAIN_VIEW); else if (items == BIJI_ARCHIVED_ITEMS) bjb_window_base_switch_to (self, BJB_WINDOW_BASE_ARCHIVE_VIEW); return TRUE; } switch (event->key.keyval) { /* Help on F1 */ case GDK_KEY_F1: help_activated (NULL, NULL, NULL); return TRUE; /* Reserve other func keys for window */ case GDK_KEY_F2: case GDK_KEY_F3: case GDK_KEY_F4: case GDK_KEY_F5: case GDK_KEY_F6: case GDK_KEY_F7: case GDK_KEY_F8: case GDK_KEY_F9: case GDK_KEY_F10: case GDK_KEY_F11: return TRUE; default: return FALSE; } return FALSE; }
static gboolean panel_focus_tab(GtkWidget *widget, GdkEvent *event, gpointer data) { GeanyKeyBinding *kb = keybindings_lookup_item(GEANY_KEY_GROUP_FOCUS, GEANY_KEYS_FOCUS_SIDEBAR); if (kb != NULL && event->key.keyval == kb->key && (event->key.state & gtk_accelerator_get_default_mod_mask()) == kb->mods) { gint current = gtk_notebook_get_current_page(GTK_NOTEBOOK(geany->main_widgets->sidebar_notebook)); gint tab = gtk_notebook_page_num(GTK_NOTEBOOK(geany->main_widgets->sidebar_notebook), panel); if(current == tab) { gtk_widget_grab_focus(entry); //TODO: or grab table entries, whatever was last focused } } return FALSE; }
bool perfroll::on_scroll_event( GdkEventScroll* a_ev ) { guint modifiers; // Used to filter out caps/num lock etc. modifiers = gtk_accelerator_get_default_mod_mask (); if ((a_ev->state & modifiers) == GDK_CONTROL_MASK) { if (a_ev->direction == GDK_SCROLL_DOWN) { m_perfedit->set_zoom(m_zoom*2); } else if (a_ev->direction == GDK_SCROLL_UP) { m_perfedit->set_zoom(m_zoom/2); } return true; } if ((a_ev->state & modifiers) == GDK_SHIFT_MASK) { double val = m_hadjust->get_value(); if ( a_ev->direction == GDK_SCROLL_UP ) { val -= m_hadjust->get_step_increment(); } else if ( a_ev->direction == GDK_SCROLL_DOWN ) { val += m_hadjust->get_step_increment(); } m_hadjust->clamp_page(val, val + m_hadjust->get_page_size()); } else { double val = m_vadjust->get_value(); if ( a_ev->direction == GDK_SCROLL_UP ) { val -= m_vadjust->get_step_increment(); } else if ( a_ev->direction == GDK_SCROLL_DOWN ) { val += m_vadjust->get_step_increment(); } m_vadjust->clamp_page(val, val + m_vadjust->get_page_size()); } return true; }
static gboolean key_press_cb(GtkWidget* widget, GdkEventKey* evt, gpointer udata) { GtWin* self = GT_WIN(udata); GtWinPrivate* priv = gt_win_get_instance_private(self); GdkModifierType modifiers = gtk_accelerator_get_default_mod_mask(); gboolean playing; GAction *action; g_object_get(self->player, "playing", &playing, NULL); if (MAIN_VISIBLE_CHILD == GTK_WIDGET(self->player)) { if (evt->keyval == GDK_KEY_Escape) { if (priv->fullscreen) g_object_set(self, "fullscreen", FALSE, NULL); else { action = g_action_map_lookup_action(G_ACTION_MAP(self), "close_player"); g_action_activate(action, NULL); } } else if (evt->keyval == GDK_KEY_f) { g_object_set(self, "fullscreen", !priv->fullscreen, NULL); } } else { if (evt->keyval == GDK_KEY_Escape) gt_browse_header_bar_stop_search(GT_BROWSE_HEADER_BAR(priv->browse_header_bar)); else if (evt->keyval == GDK_KEY_f && (evt->state & modifiers) == GDK_CONTROL_MASK) gt_browse_header_bar_toggle_search(GT_BROWSE_HEADER_BAR(priv->browse_header_bar)); else { GtkWidget* view = gtk_stack_get_visible_child(GTK_STACK(priv->browse_stack)); if (view == priv->channels_view) gt_channels_view_handle_event(GT_CHANNELS_VIEW(priv->channels_view), (GdkEvent*) evt); else if (view == priv->games_view) gt_games_view_handle_event(GT_GAMES_VIEW(priv->games_view), (GdkEvent*) evt); else if (view == priv->follows_view) gt_follows_view_handle_event(GT_FOLLOWS_VIEW(priv->follows_view), (GdkEvent* )evt); } } return FALSE; }
static gboolean gear_menu_key_press (GtkWidget *widget, GdkEventKey *event, gpointer user_data) { GdkModifierType mask = gtk_accelerator_get_default_mod_mask (); if ((event->state & mask) == 0 && (event->keyval == GDK_KEY_F10)) { gtk_menu_shell_deactivate (GTK_MENU_SHELL (widget)); return TRUE; } return FALSE; }
static gboolean on_tab_key_press (GtkWidget *widget, GdkEventKey *event, gpointer data) { guint modifiers; modifiers = gtk_accelerator_get_default_mod_mask (); if ((event->keyval == GDK_KEY(w)) && ((event->state & modifiers) == GDK_CONTROL_MASK)) { browser_tabs_close_tab ((tabInfo *)data); return TRUE; } return FALSE; }
static gboolean on_key_press(GtkWidget* w, GdkEventKey* evt, GtkNotebook *notebook) { int modifier = (evt->state & gtk_accelerator_get_default_mod_mask()); if (modifier == GDK_MOD1_MASK) /* Alt */ { if(evt->keyval >= '1' && evt->keyval <= '9') /* Alt + 1 ~ 9, nth tab */ { gtk_notebook_set_current_page(notebook, evt->keyval - '1'); return TRUE; } } return FALSE; }
static gboolean key_press_cb(GtkWidget *vte, GdkEventKey *event) { const GdkModifierType modifiers = event->state & gtk_accelerator_get_default_mod_mask(); if (modifiers == (GDK_CONTROL_MASK|GDK_SHIFT_MASK)) { switch (gdk_keyval_to_lower(event->keyval)) { case GDK_c: vte_terminal_copy_clipboard(VTE_TERMINAL(vte)); return TRUE; case GDK_v: vte_terminal_paste_clipboard(VTE_TERMINAL(vte)); return TRUE; } } return FALSE; }
/* Class functions */ gboolean scim_bridge_client_imcontext_filter_key_event (GtkIMContext *context, GdkEventKey *event) { scim_bridge_pdebugln (8, "scim_bridge_client_imcontext_filter_key_event ()"); ScimBridgeClientIMContext *imcontext = SCIM_BRIDGE_CLIENT_IMCONTEXT (context); if (!(event->send_event & SEND_EVENT_MASK) && scim_bridge_client_is_messenger_opened () && imcontext != NULL && !key_snooper_used) { if (imcontext->client_window != NULL) { int new_window_x; int new_window_y; gdk_window_get_origin (imcontext->client_window, &new_window_x, &new_window_y); if (imcontext->window_x != new_window_x || imcontext->window_y != new_window_y) { imcontext->window_x = new_window_x; imcontext->window_y = new_window_y; scim_bridge_pdebugln (1, "The cursor location is changed: x = %d + %d\ty = %d + %d", imcontext->window_x, imcontext->cursor_x, imcontext->window_y, imcontext->cursor_y); if (set_cursor_location (imcontext, new_window_x, new_window_y, imcontext->cursor_x, imcontext->cursor_y)) { scim_bridge_perrorln ("An IOException occurred at scim_bridge_client_imcontext_filter_key_event ()"); return gtk_im_context_filter_keypress (fallback_imcontext, event); } } } boolean consumed = FALSE; if (filter_key_event (imcontext, event, &consumed)) { scim_bridge_perrorln ("An IOException occurred at scim_bridge_client_imcontext_filter_key_event ()"); } else if (consumed) { return TRUE; } } unsigned int accelerator_mask = (gtk_accelerator_get_default_mod_mask () & ~GDK_SHIFT_MASK); if (imcontext == NULL || !imcontext->enabled) { return gtk_im_context_filter_keypress (fallback_imcontext, event); } else if (event->type == GDK_KEY_PRESS && (event->state & accelerator_mask) == 0) { guint32 wchar = gdk_keyval_to_unicode (event->keyval); if (wchar != 0) { gchar buffer[10]; const int buffer_length = g_unichar_to_utf8 (wchar, buffer); buffer[buffer_length] = '\0'; g_signal_emit_by_name (focused_imcontext, "commit", &buffer); return TRUE; } }
static gboolean window_key_press_event (GtkWidget *win, GdkEventKey *event, GnomeControlCenter *self) { GdkKeymap *keymap; gboolean retval; GdkModifierType state; if (event->state == 0) return FALSE; retval = FALSE; state = event->state; keymap = gdk_keymap_get_default (); gdk_keymap_add_virtual_modifiers (keymap, &state); state = state & gtk_accelerator_get_default_mod_mask (); if (state == GDK_CONTROL_MASK) { switch (event->keyval) { case GDK_KEY_s: case GDK_KEY_S: case GDK_KEY_f: case GDK_KEY_F: if (gtk_widget_get_visible (self->priv->search_entry)) { gtk_widget_grab_focus (self->priv->search_entry); retval = TRUE; } break; case GDK_KEY_Q: case GDK_KEY_q: g_object_unref (self); retval = TRUE; break; case GDK_KEY_W: case GDK_KEY_w: if (notebook_get_selected_page (self->priv->notebook) != self->priv->scrolled_window) shell_show_overview_page (self); retval = TRUE; break; } } return retval; }
guint panel_applet_bindings_get_mouse_button_modifier_keymask (void) { guint mod; g_assert (mouse_button_modifier_keymask != 0); if (!initialised) panel_applet_bindings_init (); mod = panel_applet_bindings_get_real_modifier_mask (mouse_button_modifier_keymask); if (mod & gtk_accelerator_get_default_mod_mask ()) return mod; else return panel_applet_bindings_get_real_modifier_mask (DEFAULT_MOUSE_MODIFIER); }