protected override bool OnKeyPressEvent(Gdk.EventKey key) { switch (key.Key) { // quit only on certain keys case Gdk.Key.F: case Gdk.Key.f: case Gdk.Key.Q: case Gdk.Key.q: case Gdk.Key.F11: case Gdk.Key.Escape: Quit(); return(true); // display infobox for 'i' key case Gdk.Key.i: case Gdk.Key.I: InfoAction(info_button, null); return(true); case Gdk.Key.bracketleft: new RotateLeftAction(View.Item).Activate(); return(true); case Gdk.Key.bracketright: new RotateRightAction(View.Item).Activate(); return(true); } return(base.OnKeyPressEvent(key)); }
static Gdk.Key GetGroupZeroKey(Gdk.Key mappedKey, Gdk.EventKey evt) { Gdk.Key ret; if (groupZeroMappings.TryGetValue(mappedKey, out ret)) { return(ret); } //LookupKey isn't implemented on Mac, so we have to use this workaround uint[] keyvals; Gdk.KeymapKey [] keys; keymap.GetEntriesForKeycode(evt.HardwareKeycode, out keys, out keyvals); //find the key that has the same level (so we preserve shift) but with group 0 for (uint i = 0; i < keyvals.Length; i++) { if (keyvals[i] == (uint)mappedKey) { for (uint j = 0; j < keys.Length; j++) { if (keys[j].Group == 0 && keys[j].Level == keys[i].Level) { return(groupZeroMappings[mappedKey] = ret = (Gdk.Key)keyvals[j]); } } } } //failed, but avoid looking it up again return(groupZeroMappings[mappedKey] = mappedKey); }
protected override bool OnKeyPressEvent(Gdk.EventKey evnt) { switch (evnt.Key) { case Gdk.Key.Escape: ((Entry)comboFind.Child).Text = ""; return(true); case Gdk.Key.F3: if ((evnt.State & Gdk.ModifierType.ShiftMask) != 0) { MovePosition(-1); } else { MovePosition(1); } return(true); case Gdk.Key.Return: case Gdk.Key.KP_Enter: UpdateComboEntries(comboFind.ActiveText); return(true); } return(base.OnKeyPressEvent(evnt)); }
// Methods :: Public :: IsModifier public static bool IsModifier(Gdk.EventKey e) { switch (e.Key) { case Key.Shift_L: case Key.Shift_R: case Key.Caps_Lock: case Key.Shift_Lock: case Key.Control_L: case Key.Control_R: case Key.Meta_L: case Key.Meta_R: case Key.Alt_L: case Key.Alt_R: case Key.Super_L: case Key.Super_R: case Key.Hyper_L: case Key.Hyper_R: case Key.Mode_switch: case Key.ISO_Level3_Shift: return(true); default: return(false); } }
bool ITextEditorExtension.KeyPress(Gdk.Key key, char ch, Gdk.ModifierType modifier) { Gdk.EventKey evnt = evntCopy; HideLanguageItemWindow(); bool res = false; IEditAction action = editactions.GetAction(evnt.Key, evnt.State); if (action != null) { action.PreExecute(this); if (action.PassToBase) { base.OnKeyPressEvent(evnt); } action.Execute(this); if (action.PassToBase) { base.OnKeyPressEvent(evnt); } action.PostExecute(this); res = true; } else { res = base.OnKeyPressEvent(evnt); } return(res); }
protected override bool OnKeyReleaseEvent(Gdk.EventKey evnt) { bool ret; if (evnt.Key == Gdk.Key.Control_L || evnt.Key == Gdk.Key.Control_R) { Gdk.Window focusTarget = null; Document doc = SelectedDocument; if (doc != null) { doc.Select(); focusTarget = doc.ActiveView.Control.Toplevel.GdkWindow; } else { Pad pad = SelectedPad; if (pad != null) { pad.BringToFront(true); focusTarget = pad.Window.Content.Control.Toplevel.GdkWindow; } } ret = base.OnKeyReleaseEvent(evnt); Gtk.Window parent = this.TransientFor; this.Destroy(); (focusTarget ?? parent.GdkWindow).Focus(0); } else { ret = base.OnKeyReleaseEvent(evnt); } return(ret); }
protected override bool OnKeyReleaseEvent(Gdk.EventKey evnt) { if (evnt.Key == Gdk.Key.Control_L || evnt.Key == Gdk.Key.Control_R) { OnRequestClose(new RequestActionEventArgs(true)); } return(base.OnKeyReleaseEvent(evnt)); }
protected override bool OnKeyReleaseEvent(Gdk.EventKey evnt) { if (evnt.Key == Gdk.Key.Control_L || evnt.Key == Gdk.Key.Control_R) { OnRequestClose(EventArgs.Empty); } return(base.OnKeyReleaseEvent(evnt)); }
protected override bool OnKeyReleaseEvent(Gdk.EventKey evnt) { if (evnt.Key == Gdk.Key.Return || evnt.Key == Gdk.Key.KP_Enter) { Activate(); } return(true); }
// Methods // Methods :: Public // Methods :: Public :: HaveModifier // If we have modifiers, and either Ctrl, Mod1 (Alt), or any // of Mod3 to Mod5 (Mod2 is num-lock...) are pressed, we // let Gtk+ handle the key public static bool HaveModifier(Gdk.EventKey e) { return(e.State != 0 && (((e.State & Gdk.ModifierType.ControlMask) != 0) || ((e.State & Gdk.ModifierType.Mod1Mask) != 0) || ((e.State & Gdk.ModifierType.Mod3Mask) != 0) || ((e.State & Gdk.ModifierType.Mod4Mask) != 0) || ((e.State & Gdk.ModifierType.Mod5Mask) != 0))); }
protected override bool OnKeyPressEvent(Gdk.EventKey e) { int page = -1; // if alt is pressed if ((e.State & ModifierType.Mod1Mask) == ModifierType.Mod1Mask) { // select a page switch (e.Key) { case Gdk.Key.Key_1: page = 0; break; case Gdk.Key.Key_2: page = 1; break; case Gdk.Key.Key_3: page = 2; break; case Gdk.Key.Key_4: page = 3; break; case Gdk.Key.Key_5: page = 4; break; case Gdk.Key.Key_6: page = 5; break; case Gdk.Key.Key_7: page = 6; break; case Gdk.Key.Key_8: page = 7; break; case Gdk.Key.Key_9: page = 8; break; case Gdk.Key.Left: page = this.CurrentPage - 1; break; case Gdk.Key.Right: page = this.CurrentPage + 1; break; default: break; } } // change the current page if the new one is valid if (page >= 0 && page < this.NPages) { this.Page = page; } return(true); }
protected override bool OnKeyPressEvent(Gdk.EventKey e) { if (e.Key == Gdk.Key.Escape) { this.OnDeleteEvent(this, new DeleteEventArgs()); HideAll(); } ; return(base.OnKeyPressEvent(e)); }
protected override bool OnKeyPressEvent(Gdk.EventKey evt) { uint unicodeChar = Gdk.Keyval.ToUnicode(evt.KeyValue); ModifierType filteredModifiers = evt.State & (ModifierType.ShiftMask | ModifierType.Mod1Mask | ModifierType.ControlMask); HexEditorData.EditMode.InternalHandleKeypress(this, evt.Key, unicodeChar, filteredModifiers); return(true); }
public GcKeyEventArgs(Gtk.Widget sender, Gdk.EventKey args, bool key_pressed_suppressed) { control = ((args.State & ModifierType.ControlMask) == ModifierType.ControlMask); shift = ((args.State & ModifierType.ShiftMask) == ModifierType.ShiftMask); alt = ((args.State & ModifierType.Mod1Mask) == ModifierType.Mod1Mask); widget = sender; keyCode = args.Key; keyValue = (int)args.KeyValue; suppressKeyPress = key_pressed_suppressed; }
/// <summary> /// Handles KeyRelease event /// </summary> /// <param name="evnt"> /// Arguments <see cref="Gdk.EventKey"/> /// </param> /// <returns> /// true if handled, false if not <see cref="System.Boolean"/> /// </returns> protected override bool OnKeyReleaseEvent(Gdk.EventKey evnt) { switch (evnt.Key) { case Gdk.Key.Tab: return(base.OnKeyReleaseEvent(evnt)); break; } if (Editable == false) { return(true); } if ((char)evnt.KeyValue == System.Threading.Thread.CurrentThread.CurrentCulture.DateTimeFormat.DateSeparator[0]) { if (ignoreNextSeparator == true) { ignoreNextSeparator = false; return(true); } SelectNext(); return(true); } ignoreNextSeparator = false; if (char.IsDigit((char)evnt.KeyValue) == true) { string s = CurrentPart + (char)evnt.KeyValue; int i = System.Convert.ToInt32(s); if (i <= MaxNumber) { CurrentPart = i.ToString(); if ((i * 10) > MaxNumber) { SelectNext(); ignoreNextSeparator = true; } } } switch (evnt.Key) { case Gdk.Key.Delete: ResetEditing(); OnClearData(); break; case Gdk.Key.KP_Add: case Gdk.Key.KP_Subtract: case Gdk.Key.plus: case Gdk.Key.minus: ResetEditing(); OnStartCalculator(); break; } return(base.OnKeyReleaseEvent(evnt)); }
protected override bool OnKeyReleaseEvent(Gdk.EventKey evnt) { if (pressed && evnt.Key == Gdk.Key.space) { LoadImage(); Clicked?.Invoke(this, EventArgs.Empty); return(true); } return(base.OnKeyReleaseEvent(evnt)); }
protected override bool OnKeyPressEvent(Gdk.EventKey evnt) { if (ProcessKey(evnt.Key, evnt.State)) { return(true); } else { return(base.OnKeyPressEvent(evnt)); } }
protected override bool OnKeyPressEvent(Gdk.EventKey evnt) { if (SpecialOnPressKeys.Contains(evnt.Key) == true) { if (specialKeyPressEvent != null) { specialKeyPressEvent(this, new GdkKeyEventArgs(evnt.Key)); } return(true); } return(base.OnKeyPressEvent(evnt)); }
#pragma warning disable 0169 int TransparencyKeySnooper(IntPtr widget, IntPtr rawEvnt, IntPtr data) { if (rawEvnt != IntPtr.Zero) { Gdk.EventKey evnt = new Gdk.EventKey(rawEvnt); if (evnt != null && evnt.Key == Gdk.Key.Control_L || evnt.Key == Gdk.Key.Control_R) { SemiTransparent = (evnt.Type == Gdk.EventType.KeyPress); } } return(0); //gboolean FALSE }
protected override bool OnKeyPressEvent(Gdk.EventKey evnt) { evntCopy = evnt; //FIXME use Gdk.Keyval.ToUnicode rtc if (extension == null) { return(((ITextEditorExtension)this).KeyPress(evnt.Key, (char)evnt.KeyValue, evnt.State)); } else { return(extension.KeyPress(evnt.Key, (char)evnt.KeyValue, evnt.State)); } }
/// <summary> /// Breaks apart an event key into the individual and normalized key and /// any modifiers. /// </summary> /// <param name="evt">The evt.</param> /// <param name="key">The key.</param> /// <param name="modifiers">The mod.</param> public static void DecomposeKeys( EventKey evt, out Key key, out ModifierType modifiers) { // Use the keymap to decompose various elements of the hardware keys. uint keyval; int effectiveGroup, level; ModifierType consumedModifiers; keymap.TranslateKeyboardState( evt.HardwareKeycode, evt.State, evt.Group, out keyval, out effectiveGroup, out level, out consumedModifiers); // Break out the identified keys and modifiers. key = (Key) keyval; modifiers = evt.State & ~consumedModifiers; // Normalize some of the keys that don't make sense. if (key == Key.ISO_Left_Tab) { key = Key.Tab; modifiers |= ModifierType.ShiftMask; } // Check to see if we are a character and pull out the shift key if // it is a capital letter. This is used to normalize so all the // keys are uppercase with a shift modifier. bool shiftWasConsumed = ((evt.State ^ modifiers) & ModifierType.ShiftMask) != 0; var unicode = (char) Keyval.ToUnicode((uint) key); if (shiftWasConsumed && Char.IsUpper(unicode)) { modifiers |= ModifierType.ShiftMask; } if (Char.IsLetter(unicode) && Char.IsLower(unicode)) { key = (Key) Char.ToUpper(unicode); } }
protected override bool OnKeyPressEvent(Gdk.EventKey evnt) { if (evnt.Key == Gdk.Key.Escape || evnt.Key == Gdk.Key.Return) { return(base.OnKeyPressEvent(evnt)); } if (IsSupportedModifier(evnt.Key)) { return(true); } hotKey = App.Current.Keyboard.ParseEvent(evnt); Respond(ResponseType.Ok); return(true); }
protected override bool OnKeyPressEvent(Gdk.EventKey evnt) { if (evnt.Key == Gdk.Key.Escape || evnt.Key == Gdk.Key.Return) { return(base.OnKeyPressEvent(evnt)); } hotKey = App.Current.Keyboard.ParseEvent(evnt); // Hotkey can be null when the first key is a supported modifier if (hotKey == null) { return(true); } Respond(ResponseType.Ok); return(true); }
protected override bool OnKeyPressEvent(Gdk.EventKey evnt) { if (mKeyToSDLK.ContainsKey(evnt.Key)) { this.mKey = evnt.Key; ModifierType mods = evnt.State; this.mAltDown = (mods & ModifierType.Mod1Mask) == ModifierType.Mod1Mask; this.mControlDown = (mods & ModifierType.ControlMask) == ModifierType.ControlMask; this.mShiftDown = (mods & ModifierType.ShiftMask) == ModifierType.ShiftMask; this.UpdateDisplay(); } return(true); }
protected override bool OnKeyPressEvent(Gdk.EventKey key) { switch (key.Key) { case Gdk.Key.Up: case Gdk.Key.Left: case Gdk.Key.KP_Up: case Gdk.Key.KP_Left: case Gdk.Key.Page_Up: case Gdk.Key.Down: case Gdk.Key.Right: case Gdk.Key.KP_Down: case Gdk.Key.KP_Right: case Gdk.Key.Page_Down: break; default: controls.Visibility = ControlOverlay.VisibilityType.Partial; break; } if (key == null) { System.Console.WriteLine("Key == null", key); return(false); } if (view == null) { System.Console.WriteLine("view == null", key); return(false); } bool retval = base.OnKeyPressEvent(key); if (!retval) { Quit(); } else { view.Fit = false; } return(retval); }
protected override bool OnKeyPressEvent(Gdk.EventKey ek) { switch (ek.Key) { case Gdk.Key.Page_Down: case Gdk.Key.Down: case Gdk.Key.Right: ActiveItem++; return(true); case Gdk.Key.Page_Up: case Gdk.Key.Up: case Gdk.Key.Left: ActiveItem--; return(true); } return(false); }
protected override bool OnKeyReleaseEvent(Gdk.EventKey evnt) { if (initialKey.IsEmpty) { Gdk.Key key; Gdk.ModifierType mod; KeyboardShortcut [] accels; GtkWorkarounds.MapKeys(evnt, out key, out mod, out accels); initialKey = new KeyboardShortcut(key, mod); } var releaseMods = GtkWorkarounds.KeysForMod(initialKey.Modifier); if ((releaseMods.Length == 0 && (evnt.Key == Gdk.Key.Control_L || evnt.Key == Gdk.Key.Control_R)) || releaseMods.Contains(evnt.Key)) { OnRequestClose(new RequestActionEventArgs(true)); } return(base.OnKeyReleaseEvent(evnt)); }
protected override bool OnKeyPressEvent(Gdk.EventKey ev) { switch (ev.Key) { case Gdk.Key.Delete: case Gdk.Key.KP_Delete: IObjectSelection sel = GetSelection(); if (sel != null && sel.DataObject != null) { Wrapper.Widget wrapper = Wrapper.Widget.Lookup(sel.DataObject) as Wrapper.Widget; if (wrapper != null) { wrapper.Delete(); } } return(true); default: return(base.OnKeyPressEvent(ev)); } }
protected override bool OnKeyPressEvent(Gdk.EventKey evnt) { Gdk.Key key = evnt.Key; ModifierType modifier = evnt.State; // Only react to {Shift|Alt|Ctrl}+key // Ctrl is a modifier to select single keys // Combination are allowed with Alt and Shift (Ctrl is not allowed to avoid // conflicts with menus shortcuts) if ((modifier & (ModifierType.Mod1Mask | ModifierType.ShiftMask | ModifierType.ControlMask)) != 0 && key != Gdk.Key.Shift_L && key != Gdk.Key.Shift_R && key != Gdk.Key.Alt_L && key != Gdk.Key.Control_L && key != Gdk.Key.Control_R) { hotKey.Key = (int)key; hotKey.Modifier = (int)(modifier & (ModifierType.Mod1Mask | ModifierType.ShiftMask)); this.Respond(ResponseType.Ok); } return(base.OnKeyPressEvent(evnt)); }
//FIXME: get ctrl(-shift)-tab keybindings from the Switch(Next|Previous)Document commands? protected override bool OnKeyPressEvent(Gdk.EventKey evnt) { Gdk.Key key; Gdk.ModifierType mod; KeyBindingManager.MapRawKeys(evnt, out key, out mod); switch (key) { case Gdk.Key.Left: SwitchToPad(); break; case Gdk.Key.Right: SwitchToDocument(); break; case Gdk.Key.Up: Previous(); break; case Gdk.Key.Down: Next(); break; case Gdk.Key.Tab: if ((mod & ModifierType.ShiftMask) == 0) { Next(); } else { Previous(); } break; } return(true); }
protected override bool OnKeyPressEvent(Gdk.EventKey evnt) { if (evnt.Key == Gdk.Key.Escape || evnt.Key == Gdk.Key.Return) { return(base.OnKeyPressEvent(evnt)); } if (IsSupportedModifier(evnt.Key)) { return(true); } hotKey = Keyboard.ParseEvent(evnt); if (hotKey.Modifier != -1 && !IsSupportedModifier((Gdk.Key)hotKey.Modifier)) { string msg = Keyboard.NameFromKeyval((uint)hotKey.Modifier) + Catalog.GetString("is not a valid key modifier: Alt, Shift or Ctrl"); Config.GUIToolkit.WarningMessage(msg, this); hotKey = null; return(true); } Respond(ResponseType.Ok); return(true); }
protected override bool OnKeyPressEvent (EventKey evnt) { // Console.WriteLine (evnt.Key); return base.OnKeyPressEvent (evnt); }
protected override bool OnKeyPressEvent (EventKey evnt) { if (evnt.Key == Gdk.Key.Escape) Close (); if (evnt.Key == Gdk.Key.Control_L) controlKeyMask |= 1; if (evnt.Key == Gdk.Key.Control_R) controlKeyMask |= 2; placeholder.UpdatePosition (); return base.OnKeyPressEvent (evnt); }
protected override bool OnKeyPressEvent(EventKey evnt) { this.Theory.FireHook (EventType.KeyPress, evnt); return base.OnKeyPressEvent (evnt); }
protected override bool OnKeyPressEvent(EventKey evnt) => ProcessKeyEvent(evnt);
protected override bool OnKeyPressEvent(EventKey evnt) { int focus_old = FocusCell; bool shift = ModifierType.ShiftMask == (evnt.State & ModifierType.ShiftMask); bool control = ModifierType.ControlMask == (evnt.State & ModifierType.ControlMask); switch (evnt.Key) { case Gdk.Key.Down: case Gdk.Key.J: case Gdk.Key.j: FocusCell += VisibleColums; break; case Gdk.Key.Left: case Gdk.Key.H: case Gdk.Key.h: if (control && shift) FocusCell -= FocusCell % VisibleColums; else FocusCell--; break; case Gdk.Key.Right: case Gdk.Key.L: case Gdk.Key.l: if (control && shift) FocusCell += VisibleColums - (FocusCell % VisibleColums) - 1; else FocusCell++; break; case Gdk.Key.Up: case Gdk.Key.K: case Gdk.Key.k: FocusCell -= VisibleColums; break; case Gdk.Key.Page_Up: FocusCell -= VisibleColums * VisibleRows; break; case Gdk.Key.Page_Down: FocusCell += VisibleColums * VisibleRows; break; case Gdk.Key.Home: FocusCell = 0; break; case Gdk.Key.End: FocusCell = Collection.Count - 1; break; case Gdk.Key.R: case Gdk.Key.r: FocusCell = new Random().Next(0, Collection.Count - 1); break; case Gdk.Key.space: Selection.ToggleCell (FocusCell); break; case Gdk.Key.Return: if (DoubleClicked != null) DoubleClicked (this, new BrowsableEventArgs (FocusCell, null)); break; default: return false; } if (shift) { if (focus_old != FocusCell && Selection.Contains (focus_old) && Selection.Contains (FocusCell)) Selection.Remove (FocusCell, focus_old); else Selection.Add (focus_old, FocusCell); } else if (!control) { Selection.Clear (); Selection.Add (FocusCell); } ScrollTo (FocusCell); return true; }
protected override bool OnKeyPressEvent(EventKey evnt) { Gdk.Key key = evnt.Key; Gdk.ModifierType modifier = evnt.State; bool ret; ret = base.OnKeyPressEvent(evnt); if(openedProject == null && !player.Opened) return ret; if(projectType != ProjectType.CaptureProject && projectType != ProjectType.FakeCaptureProject) { switch(key) { case Constants.SEEK_FORWARD: if(modifier == Constants.STEP) player.StepForward(); else player.SeekToNextFrame(selectedTimeNode != null); break; case Constants.SEEK_BACKWARD: if(modifier == Constants.STEP) player.StepBackward(); else player.SeekToPreviousFrame(selectedTimeNode != null); break; case Constants.FRAMERATE_UP: player.FramerateUp(); break; case Constants.FRAMERATE_DOWN: player.FramerateDown(); break; case Constants.TOGGLE_PLAY: player.TogglePlay(); break; } } else { switch(key) { case Constants.TOGGLE_PLAY: capturer.TogglePause(); break; } } return ret; }
public void KeyPressedHandler(EventKey e) { Parser.Parse(CurrentKeyMap.Lookup(e).Select(a => { return new UnparsedCommand(a, e.KeyValue); })); // TODO alert the user if there were any invalid sequences // TODO indicate the current state somewhere Parser.Commands.ForEach(c => c.Execute(this)); Parser.Commands.Clear(); }
protected override bool OnKeyPressEvent (EventKey evnt) { Gdk.Key key; Gdk.ModifierType mod; Mono.TextEditor.KeyboardShortcut[] accels; Mono.TextEditor.GtkWorkarounds.MapKeys (evnt, out key, out mod, out accels); switch (accels[0].Key) { case Gdk.Key.Left: LeftItem (); break; case Gdk.Key.Right: RightItem (); break; case Gdk.Key.Up: PrevItem (false); break; case Gdk.Key.Down: NextItem (false); break; case Gdk.Key.Tab: if ((accels[0].Modifier & ModifierType.ShiftMask) == 0) NextItem (true); else PrevItem (true); break; } return base.OnKeyPressEvent (evnt); }
protected override bool OnKeyPressEvent(EventKey evnt) { bool ret = base.OnKeyPressEvent (evnt); if (Focus is Entry) { return ret; } else { Config.EventsBroker.EmitKeyPressed (this, LongoMatch.Core.Common.Keyboard.ParseEvent (evnt)); return true; } }
protected override bool OnKeyPressEvent (EventKey evnt) { if (evnt.Key == Gdk.Key.Escape && IdeApp.Workspace.IsOpen) WelcomePageService.HideWelcomePage (true); return base.OnKeyPressEvent (evnt); }
protected override bool OnKeyPressEvent(EventKey evnt) { if(evnt.Key == Gdk.Key.Return) { var startIter = Buffer.GetIterAtMark(promptStart); var endIter = Buffer.EndIter; var text = Buffer.GetText(startIter, endIter, true); Buffer.ApplyTag("history", startIter, endIter); promptStart = Buffer.CreateMark(null, endIter, true); evaluator(text); NewLine(); return true; } else if(evnt.Key == Gdk.Key.Shift_L) { return base.OnKeyPressEvent(evnt); } var result = base.OnKeyPressEvent(evnt); sourceHighlighter.Tokenize(new Character((char)evnt.KeyValue, new Location(null, 0, column))); column++; return result; }
int TransparencyKeySnooper (Gtk.Widget widget, EventKey evnt) { if (evnt != null && evnt.Key == Gdk.Key.Control_L || evnt.Key == Gdk.Key.Control_R) SemiTransparent = (evnt.Type == Gdk.EventType.KeyPress); return 0; //FALSE }
private bool TryHandleChar(EventKey eventKey) { // Try to handle it as a character if (imContext.FilterKeypress (eventKey)) { return true; } // We didn't handle the key return false; }
public void KeyPressedHandler(EventKey e) { if (!IgnoreKeys.Contains(e.Key)) { Parser.Parse(CurrentKeyMap.Lookup(e).Select(a => { return new UnparsedCommand(a, e.KeyValue); })); // TODO alert the user if there were any invalid sequences // TODO indicate the current state somewhere Model.Value.IncrUserAction(); try { Parser.Commands.ForEach(c => c.Execute(this)); } finally { Model.Value.DecrUserAction(); } Parser.Commands.Clear(); } }
public KeyInput(EventKey e) : this() { Base = e.Key; Modifiers = e.State; }
private bool TryHandleChar(EventKey eventKey) { // Try to handle it as a character if (CurrentTextEngine.HandleKeyPress (eventKey)) { RedrawText (true, true); return true; } // We didn't handle the key return false; }
protected override bool OnKeyPressEvent(EventKey evnt) { return ((DefaultWorkbench)IdeApp.Workbench.RootWindow).FilterWindowKeypress (evnt) || base.OnKeyPressEvent (evnt); }
private bool ProcessKeyEvent(EventKey evnt) { _lastKeyEventTimestamp = evnt.Time; if (_imContext.FilterKeypress(evnt)) return true; var e = new RawKeyEventArgs( GtkKeyboardDevice.Instance, evnt.Time, evnt.Type == EventType.KeyPress ? RawKeyEventType.KeyDown : RawKeyEventType.KeyUp, GtkKeyboardDevice.ConvertKey(evnt.Key), GetModifierKeys(evnt.State)); Input(e); return true; }
public IEC Lookup(EventKey e) { return Lookup(new KeyInput(e)); }
protected override bool OnKeyReleaseEvent(EventKey evnt) => ProcessKeyEvent(evnt);
/// <summary> /// Called on KeyPress event. /// </summary> /// <param name="e">An instance that contains the event data.</param> /// <returns>True if event was handled?</returns> protected override bool OnKeyPressEvent(EventKey e) { return this.ActualController.HandleKeyDown(this, e.ToKeyEventArgs()); }
protected override bool OnKeyPressEvent(EventKey evnt) { if ((evnt.State & (ModifierType.Mod1Mask | ModifierType.ControlMask)) != 0) return base.OnKeyPressEvent (evnt); bool handled = true; int x, y; Gdk.ModifierType type; switch(evnt.Key) { case Gdk.Key.Up: case Gdk.Key.KP_Up: case Gdk.Key.k: case Gdk.Key.K: ScrollBy (0, -Vadjustment.StepIncrement); break; case Gdk.Key.Down: case Gdk.Key.KP_Down: case Gdk.Key.j: case Gdk.Key.J: ScrollBy (0, Vadjustment.StepIncrement); break; case Gdk.Key.Left: case Gdk.Key.KP_Left: case Gdk.Key.h: case Gdk.Key.H: ScrollBy (-Hadjustment.StepIncrement, 0); break; case Gdk.Key.Right: case Gdk.Key.KP_Right: case Gdk.Key.l: case Gdk.Key.L: ScrollBy (Hadjustment.StepIncrement, 0); break; case Gdk.Key.equal: case Gdk.Key.plus: case Gdk.Key.KP_Add: ZoomIn (); break; case Gdk.Key.minus: case Gdk.Key.KP_Subtract: ZoomOut (); break; case Gdk.Key.Key_0: case Gdk.Key.KP_0: ZoomFit (); break; case Gdk.Key.KP_1: case Gdk.Key.Key_1: GdkWindow.GetPointer (out x, out y, out type); DoZoom (1.0, x, y); break; case Gdk.Key.Key_2: case Gdk.Key.KP_2: GdkWindow.GetPointer (out x, out y, out type); DoZoom (2.0, x, y); break; default: handled = false; break; } return handled || base.OnKeyPressEvent (evnt); }
protected override bool OnKeyPressEvent (EventKey evnt) { Gdk.Key key; Gdk.ModifierType mod; KeyBindingManager.MapRawKeys (evnt, out key, out mod); switch (key) { case Gdk.Key.Left: LeftItem (); break; case Gdk.Key.Right: RightItem (); break; case Gdk.Key.Up: PrevItem (false); break; case Gdk.Key.Down: NextItem (false); break; case Gdk.Key.Tab: if ((mod & ModifierType.ShiftMask) == 0) NextItem (true); else PrevItem (true); break; } return base.OnKeyPressEvent (evnt); }
protected override bool OnKeyPressEvent (EventKey evnt) { Gdk.Key key; Gdk.ModifierType mod; KeyboardShortcut[] accels; GtkWorkarounds.MapKeys (evnt, out key, out mod, out accels); switch (accels [0].Key) { case Gdk.Key.Left: case Gdk.Key.KP_Left: LeftItem (); break; case Gdk.Key.Right: case Gdk.Key.KP_Right: RightItem (); break; case Gdk.Key.Up: case Gdk.Key.KP_Up: PrevItem (false); break; case Gdk.Key.Down: case Gdk.Key.KP_Down: NextItem (false); break; case Gdk.Key.Tab: if ((accels [0].Modifier & ModifierType.ShiftMask) == 0) NextItem (true); else PrevItem (true); break; case Gdk.Key.Return: case Gdk.Key.KP_Enter: case Gdk.Key.ISO_Enter: OnRequestClose (new RequestActionEventArgs (true)); break; case Gdk.Key.Escape: OnRequestClose (new RequestActionEventArgs (false)); break; } return base.OnKeyPressEvent (evnt); }
protected override bool OnKeyPressEvent(EventKey evnt) { switch (evnt.Key) { case Gdk.Key.Page_Down: case Gdk.Key.Down: case Gdk.Key.Right: ActiveItem ++; return true; case Gdk.Key.Page_Up: case Gdk.Key.Up: case Gdk.Key.Left: ActiveItem --; return true; } return false; }
protected override bool OnKeyReleaseEvent (EventKey evnt) { if (evnt.Key == Gdk.Key.Control_L) controlKeyMask &= ~1; if (evnt.Key == Gdk.Key.Control_R) controlKeyMask &= ~2; placeholder.UpdatePosition (); return base.OnKeyReleaseEvent (evnt); }
#pragma warning disable 0169 int TransparencyKeySnooper (IntPtr widget, IntPtr rawEvnt, IntPtr data) { if (rawEvnt != IntPtr.Zero) { Gdk.EventKey evnt = new Gdk.EventKey (rawEvnt); if (evnt != null && evnt.Key == Gdk.Key.Control_L || evnt.Key == Gdk.Key.Control_R) SemiTransparent = (evnt.Type == Gdk.EventType.KeyPress); } return 0; //gboolean FALSE }
protected override bool OnKeyPressEvent (EventKey evnt) { if (evnt.Key == Gdk.Key.Up) { do { int selected = GetSelected () - 1; if (selected < 0) selected = NumberItems () - 1; UpdateSelected (selected); } while (GetSelectedItem ().item.Disabled); } else if (evnt.Key == Gdk.Key.Down) { do { int selected = GetSelected () + 1; if (selected > NumberItems () - 1) selected = 0; UpdateSelected (selected); } while (GetSelectedItem ().item.Disabled); } else if (evnt.Key == Gdk.Key.Return && GetSelectedItem () != null) { MenuItem item = (GetSelectedItem () as MenuItemWidget).item; if (!item.Disabled) { item.SendClick (); Hide (); } } else if (evnt.Key == Gdk.Key.Escape) { Hide (); } else { foreach (Gtk.Widget widget in (Container.Child as VBox).Children) if (widget is MenuItemWidget) { MenuItem item = (widget as MenuItemWidget).item; if (evnt.KeyValue == item.Mnemonic) if (!item.Disabled) { item.SendClick (); Hide (); } } } return base.OnKeyPressEvent (evnt); }
protected override bool OnKeyPressEvent(EventKey evnt) { bool shift = ModifierType.ShiftMask == (evnt.State & ModifierType.ShiftMask); bool control = ModifierType.ControlMask == (evnt.State & ModifierType.ControlMask); switch (evnt.Key) { case Gdk.Key.Down: case Gdk.Key.J: case Gdk.Key.j: Pointer.Index = Math.Min (Pointer.Collection.Count - 1, Pointer.Index + VisibleColums); break; case Gdk.Key.Left: case Gdk.Key.H: case Gdk.Key.h: if (control && shift) Pointer.Index -= Pointer.Index % VisibleColums; else Pointer.MovePrevious (); break; case Gdk.Key.Right: case Gdk.Key.L: case Gdk.Key.l: if (control && shift) Pointer.Index = Math.Min (Pointer.Collection.Count - 1, Pointer.Index + VisibleColums - (Pointer.Index % VisibleColums) - 1); else Pointer.MoveNext (); break; case Gdk.Key.Up: case Gdk.Key.K: case Gdk.Key.k: Pointer.Index = Math.Max (0, Pointer.Index - VisibleColums); break; case Gdk.Key.Page_Up: Pointer.Index = Math.Max (0, Pointer.Index - VisibleColums); break; case Gdk.Key.Page_Down: Pointer.Index = Math.Min (Pointer.Collection.Count - 1, Pointer.Index + VisibleColums * VisibleRows); break; case Gdk.Key.Home: Pointer.MoveFirst (); break; case Gdk.Key.End: Pointer.MoveLast (); break; default: return false; } ScrollTo (Pointer.Index); return true; }