Ejemplo n.º 1
0
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);
}
Ejemplo n.º 2
0
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;
}
Ejemplo n.º 3
0
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;
}
Ejemplo n.º 4
0
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;
}
Ejemplo n.º 5
0
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;
}
Ejemplo n.º 6
0
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;
}
Ejemplo n.º 7
0
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;
}
Ejemplo n.º 8
0
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;
}
Ejemplo n.º 9
0
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);
}
Ejemplo n.º 10
0
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;
}
Ejemplo n.º 11
0
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;
}
Ejemplo n.º 12
0
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;
}
Ejemplo n.º 13
0
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);
}
Ejemplo n.º 14
0
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() ) );
}
Ejemplo n.º 15
0
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;
}
Ejemplo n.º 16
0
int
clip_GTK_ACCELERATORGETDEFAULTMODMASK(ClipMachine * ClipMachineMemory)
{

   _clip_retni(ClipMachineMemory, (int) gtk_accelerator_get_default_mod_mask());
   return 0;
//err:
//      return 1;
}
Ejemplo n.º 17
0
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;
}
Ejemplo n.º 18
0
/*
 * 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);
}
Ejemplo n.º 19
0
/* 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;
}
Ejemplo n.º 20
0
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;
}
Ejemplo n.º 21
0
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;
}
Ejemplo n.º 22
0
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;
}
Ejemplo n.º 23
0
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;
}
Ejemplo n.º 24
0
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;
}
Ejemplo n.º 25
0
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;
}
Ejemplo n.º 26
0
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;
}
Ejemplo n.º 27
0
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;
}
Ejemplo n.º 30
0
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);
}