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;
}
