public BindingAttribute (Gdk.Key key, Gdk.ModifierType mod, string handler, params object[] parms) { this.key = key; this.mod = mod; this.handler = handler; this.parms = parms; }
/// <summary> /// Creates an item with the specified sub items. And the current /// Condition status for this item. /// </summary> public override object BuildItem(object owner, ArrayList subItems, ConditionCollection conditions) { //FIXME: This code is *not* fully ported yet if (subItems.Count > 0) { throw new ApplicationException ("more than one level of edit actions don't make sense!"); } IEditAction editAction = (IEditAction) AddIn.CreateObject (Class); Gdk.Key[] actionKeys = new Gdk.Key[keys.Length]; for (int j = 0; j < keys.Length; ++j) { string[] keydescr = keys[j].Split (new char[] { '|' }); //Keys key = (Keys)((System.Windows.Forms.Keys.Space.GetType()).InvokeMember(keydescr[0], BindingFlags.GetField, null, System.Windows.Forms.Keys.Space, new object[0])); //Console.Write (keydescr[0] + " -- "); for (int k = 1; k < keydescr.Length; ++k) { //key |= (Keys)((System.Windows.Forms.Keys.Space.GetType()).InvokeMember(keydescr[k], BindingFlags.GetField, null, System.Windows.Forms.Keys.Space, new object[0])); //Console.Write (keydescr[k] + " -- "); } //actionKeys[j] = key; } editAction.Keys = actionKeys; return editAction; }
void HandleKeyPressEvent (object o, Gtk.KeyPressEventArgs args) { keyHandled = false; keyChar = (char)args.Event.Key; keyValue = args.Event.KeyValue; modifier = args.Event.State; key = args.Event.Key; if ((args.Event.Key == Gdk.Key.Down || args.Event.Key == Gdk.Key.Up)) { keyChar = '\0'; } if (list != null) args.RetVal = keyHandled = CompletionWindowManager.PreProcessKeyEvent (KeyDescriptor.FromGtk (key, keyChar, modifier)); }
void HandleKeyPressEvent(object o, Gtk.KeyPressEventArgs args) { keyHandled = false; keyChar = (char)args.Event.Key; keyValue = args.Event.KeyValue; modifier = args.Event.State; key = args.Event.Key; if ((args.Event.Key == Gdk.Key.Down || args.Event.Key == Gdk.Key.Up)) { keyChar = '\0'; } if (list != null) { args.RetVal = keyHandled = CompletionWindowManager.PreProcessKeyEvent(key, keyChar, modifier); } }
static string GetKeyEquivalent(Gdk.Key key) { char c = (char)Gdk.Keyval.ToUnicode((uint)key); if (c != 0) { return(c.ToString()); } var fk = GetFunctionKey(key); if (fk != 0) { return(((char)fk).ToString()); } LoggingService.LogError("Mac menu cannot display key '{0}", key); return(""); }
public async Task TestIssue5025() { IdeApp.Preferences.AddImportedItemsToCompletionList.Value = true; await TestCompletion(@" namespace console61 { class MainClass { public static void Main (string[] args) { t$ } } } ", (doc, list) => { //var extEditor = doc.Editor.GetContent<SourceEditorView> ().TextEditor; var compExt = doc.GetContent <CSharpCompletionTextEditorExtension> (); CompletionWindowManager.StartPrepareShowWindowSession(); //extEditor.EditorExtension = compExt; //extEditor.OnIMProcessedKeyPressEvent (Gdk.Key.BackSpace, '\0', Gdk.ModifierType.None); var listWindow = new CompletionListWindow(); var widget = new NamedArgumentCompletionTests.TestCompletionWidget(doc.Editor, doc.DocumentContext); listWindow.CompletionWidget = widget; listWindow.CodeCompletionContext = widget.CurrentCodeCompletionContext; var item = (RoslynCompletionData)list.FirstOrDefault(d => d.CompletionText == "MainClass"); KeyActions ka = KeyActions.Process; Gdk.Key key = Gdk.Key.Tab; item.InsertCompletionText(doc.Editor, doc.DocumentContext, ref ka, KeyDescriptor.FromGtk(key, (char)key, Gdk.ModifierType.None)); Assert.AreEqual(@" namespace console61 { class MainClass { public static void Main (string[] args) { MainClass } } } ", doc.Editor.Text); }); }
void MainWindow_KeyReleaseEvent(object o, KeyReleaseEventArgs e) { Gdk.Key key = e.Event.Key; pressed_keys.Remove(key); Logger.Log("Key release: " + key.ToString()); if (key == Gdk.Key.Control_L || key == Gdk.Key.Control_R || key == Gdk.Key.Escape) { cmd_map.Off(true); } // Give the Canvas (and by extension the tools) // first shot at handling the event if // the mouse pointer is on the canvas if (IsMouseOnCanvas() || canvas_pad.Canvas.HasFocus) { canvas_pad.Canvas.DoKeyReleaseEvent(o, e); } }
void OnEditKeyPress(object sender, KeyPressEventArgs args) { keyHandled = false; keyChar = (char)args.Event.Key; keyValue = args.Event.KeyValue; modifier = args.Event.State; key = args.Event.Key; if ((args.Event.Key == Gdk.Key.Down || args.Event.Key == Gdk.Key.Up)) { keyChar = '\0'; } if (currentCompletionData != null) { args.RetVal = keyHandled = CompletionWindowManager.PreProcessKeyEvent(KeyDescriptor.FromGtk(key, keyChar, modifier)); } }
public override bool KeyPress(Gdk.Key key, char keyChar, Gdk.ModifierType modifier) { updater.BeginUpdate(); if (this.CompletionWidget != null) { switch (keyChar) { case '(': case ')': case ';': case ']': ParameterInformationWindowManager.HideWindow(this, CompletionWidget); break; default: if (lastTriggerOffset >= 0 && char.IsDigit(keyChar)) { bool containsDigitsOnly = true; for (int offset = lastTriggerOffset; offset < CompletionWidget.CaretOffset; offset++) { if (!char.IsDigit(CompletionWidget.GetChar(offset))) { containsDigitsOnly = false; break; } } if (containsDigitsOnly) { CompletionWindowManager.HideWindow(); } } break; } } var ret = base.KeyPress(key, keyChar, modifier); updater.FinishUpdate(); return(ret); }
public override bool KeyPress(Gdk.Key key, char keyChar, Gdk.ModifierType modifier) { if (keyChar != '/') { return(base.KeyPress(key, keyChar, modifier)); } LineSegment line = textEditorData.Document.GetLine(textEditorData.Caret.Line); string text = textEditorData.Document.GetTextAt(line.Offset, line.EditableLength); if (!text.EndsWith("//")) { return(base.KeyPress(key, keyChar, modifier)); } IMember member = GetMemberToDocument(); if (member == null) { return(base.KeyPress(key, keyChar, modifier)); } string documentation = GenerateDocumentation(member, textEditorData.Document.GetLineIndent(line)); if (string.IsNullOrEmpty(documentation)) { return(base.KeyPress(key, keyChar, modifier)); } string documentationEmpty = GenerateEmptyDocumentation(member, textEditorData.Document.GetLineIndent(line)); int offset = textEditorData.Caret.Offset; int insertedLength = textEditorData.Insert(offset, documentationEmpty); // important to set the caret position here for the undo step textEditorData.Caret.Offset = offset + insertedLength; insertedLength = textEditorData.Replace(offset, insertedLength, documentation); textEditorData.Caret.Offset = offset + insertedLength; return(false); }
public bool PostProcessKey(CompletionListWindow listWindow, Gdk.Key key, char keyChar, Gdk.ModifierType modifier, out KeyActions keyAction) { keyAction = KeyActions.None; if (keyChar == '_') { listWindow.PostProcessKey(key, keyChar, modifier); return(true); } Mono.TextEditor.TextEditorData ed; if (keyChar == '.' && (ed = ext.document.Editor).GetCharAt(ed.Caret.Offset - 1) == '.') { // optional: Distinguish whether we are in an an index/slice expression and do not close down the completion window if so.. keyAction = KeyActions.CloseWindow; listWindow.PostProcessKey(key, keyChar, modifier); return(true); } return(false); }
public bool CompleteWord(ref KeyActions ka, Gdk.Key closeChar, char keyChar, Gdk.ModifierType modifier) { if (SelectedItem == -1 || completionDataList == null) { return(false); } var item = completionDataList [SelectedItem]; if (item == null) { return(false); } // first close the completion list, then insert the text. // this is required because that's the logical event chain, otherwise things could be messed up CloseCompletionList(); ((CompletionData)item).InsertCompletionText(this, ref ka, closeChar, keyChar, modifier); AddWordToHistory(PartialWord, item.CompletionText); OnWordCompleted(new CodeCompletionContextEventArgs(CompletionWidget, CodeCompletionContext, item.CompletionText)); return(true); }
/// <summary>Map raw GTK key input to work around platform bugs and decompose accelerator keys</summary> /// <param name='evt'>The raw key event</param> /// <param name='key'>The composed key</param> /// <param name='mod'>The composed modifiers</param> /// <param name='accels'>All the key/modifier decompositions that can be used as accelerators</param> public static void MapKeys(Gdk.EventKey evt, out Gdk.Key key, out Gdk.ModifierType state, out KeyboardShortcut[] accels) { //this uniquely identifies the raw key ulong id; unchecked { id = (((ulong)(uint)evt.State) | (((ulong)evt.HardwareKeycode) << 32) | (((ulong)evt.Group) << 48)); } MappedKeys mapped; if (!mappedKeys.TryGetValue(id, out mapped)) { mappedKeys[id] = mapped = MapKeys(evt); } accels = mapped.Accels; key = mapped.Key; state = mapped.State; }
static char TranslateKeyCharForIndenter(Gdk.Key key, char keyChar, char docChar) { switch (key) { case Gdk.Key.Return: case Gdk.Key.KP_Enter: return('\n'); case Gdk.Key.Tab: return('\t'); default: if (docChar == keyChar) { return(keyChar); } break; } return('\0'); }
static string KeyToDisplayLabel (Gdk.Key key) { if (isMac) { char appl = AppleMapKeyToSymbol (key); if (appl != '\0') { return new string (appl, 1); } } switch (key) { case Gdk.Key.Page_Down: //Gdk.Key.Next: return "Page Down"; case Gdk.Key.Page_Up: //case Gdk.Key.Prior: return "Page Up"; } return KeyToString (key); }
public void ShellSend(Gdk.Key key) { if (UserInputMode) { LastKeyPress = key; userkeypress.Set(); } else { if (LocalEcho) { Write(key.ToString()); } if (shellStream != null && shellStream.CanWrite) { shellStream.WriteByte((byte)key); shellStream.Flush(); } } }
string Test(string input, string type, string member, Gdk.Key key = Gdk.Key.Return) { TestViewContent content; var ext = Setup(input, out content); ListWindow.ClearHistory(); var listWindow = new CompletionListWindow(); var widget = new TestCompletionWidget(ext.Document); listWindow.CompletionWidget = widget; listWindow.CodeCompletionContext = widget.CurrentCodeCompletionContext; var t = ext.Document.Compilation.FindType(new FullTypeName(type)); var foundMember = t.GetMembers(m => m.Name == member).First(); var data = new MemberCompletionData(ext, foundMember, OutputFlags.ClassBrowserEntries); data.DisplayFlags |= ICSharpCode.NRefactory.Completion.DisplayFlags.NamedArgument; KeyActions ka = KeyActions.Process; data.InsertCompletionText(listWindow, ref ka, key, (char)key, Gdk.ModifierType.None, true, false); return(widget.CompletedWord); }
public static Perspex.Input.Key ConvertKey(Gdk.Key key) { // TODO: Don't use reflection for this! My eyes!!! if (key == Gdk.Key.BackSpace) { return(Perspex.Input.Key.Back); } else { var s = Enum.GetName(typeof(Gdk.Key), key); Perspex.Input.Key result; if (Enum.TryParse(s, true, out result)) { return(result); } else { return(Perspex.Input.Key.None); } } }
bool ExtensionKeyPress(Gdk.Key key, uint ch, Gdk.ModifierType state) { isInKeyStroke = true; try { if (needToAddLastExtension) { var ext = EditorExtension; while (ext.Next != null) { ext = ext.Next; } ext.Next = new LastEditorExtension(this); needToAddLastExtension = false; } return(EditorExtension.KeyPress(KeyDescriptor.FromGtk(key, (char)ch, state))); } catch (Exception ex) { ReportExtensionError(ex); } finally { isInKeyStroke = false; } return(false); }
/// <summary> /// Fires a key press event to a widget. This is not something that should be used very often, /// but it provides a way to store a value of a cell being edited in a grid when the user closes the grid /// (e.g., by selecting a different view). /// I haven't been able to find any better way to do it. /// It's placed in this unit because there may be uses in other contexts. /// </summary> /// <param name="widget"></param> /// <param name="key"></param> public static void SendKeyEvent(Gtk.Widget widget, Gdk.Key key) { uint keyval = (uint)key; Gdk.Window window = widget.GdkWindow; Gdk.KeymapKey[] keymap = Gdk.Keymap.Default.GetEntriesForKeyval(keyval); EventKeyStruct native = new EventKeyStruct(); native.type = Gdk.EventType.KeyPress; native.window = window.Handle; native.send_event = 1; native.state = (uint)Gdk.EventMask.KeyPressMask; native.keyval = keyval; native.length = 0; native.str = null; native.hardware_keycode = (ushort)keymap[0].Keycode; native.group = (byte)keymap[0].Group; IntPtr ptr = GLib.Marshaller.StructureToPtrAlloc(native); try { Gdk.EventKey evnt = new Gdk.EventKey(ptr); Gdk.EventHelper.Put(evnt); // We need to process the event, or we won't be able // to safely free the unmanaged pointer // Using DoEvent for this fails on the Mac while (GLib.MainContext.Iteration()) { ; } // Gtk.Main.DoEvent(evnt); } finally { GLib.Marshaller.Free(ptr); } }
private int KeyToHex(Gdk.Key key) { if (key >= Gdk.Key.Key_0 && key <= Gdk.Key.Key_9) { return(key - Gdk.Key.Key_0); } else if (key >= Gdk.Key.A && key <= Gdk.Key.F) { return(key - Gdk.Key.A + 10); } else if (key >= Gdk.Key.a && key <= Gdk.Key.f) { return(key - Gdk.Key.a + 10); } else if (key >= Gdk.Key.KP_0 && key <= Gdk.Key.KP_9) { return(key - Gdk.Key.KP_0); } else { return(-1); } }
static void HandleKeyPress(object sender, KeyPressEventArgs args) { uint symbol = args.Event.Symbol; Gdk.Key key = (Gdk.Key)Enum.Parse(typeof(Gdk.Key), symbol.ToString()); switch (key) { case Gdk.Key.s: timeline.Start(); TestThreadData data = new TestThreadData(count_label, timeline); ThreadWrapper wrapper = new ThreadWrapper(data); Thread thread = new Thread(wrapper.ThreadMethod); thread.Start(); break; case Gdk.Key.q: Clutter.Main.Quit(); break; } }
public bool PostProcessKey(CompletionListWindow listWindow, Gdk.Key key, char keyChar, Gdk.ModifierType modifier, out KeyActions keyAction) { if (key == Gdk.Key.Return) { keyAction = KeyActions.Complete; } else if (key == Gdk.Key.BackSpace) { keyAction = KeyActions.None; return(false); } else if (keyChar != '\0' && !D_Parser.Parser.Lexer.IsIdentifierPart(keyChar)) { keyAction = KeyActions.CloseWindow; } else { keyAction = KeyActions.None; } listWindow.PostProcessKey(key, keyChar, modifier); return(true); }
string Test(string input, string type, string member, Gdk.Key key = Gdk.Key.Return, bool isDelegateExpected = false) { TestViewContent content; var ext = Setup(input, out content); ListWindow.ClearHistory(); var listWindow = new CompletionListWindow(); var widget = new TestCompletionWidget(ext.Document); listWindow.CompletionWidget = widget; listWindow.CodeCompletionContext = widget.CurrentCodeCompletionContext; var t = ext.Document.Compilation.FindType(new FullTypeName(type)); var method = member != null?t.GetMembers(m => m.Name == member).First() : t.GetConstructors().First(); var data = new MemberCompletionData(ext, method, OutputFlags.ClassBrowserEntries); data.IsDelegateExpected = isDelegateExpected; KeyActions ka = KeyActions.Process; data.InsertCompletionText(listWindow, ref ka, key, (char)key, Gdk.ModifierType.None, true, false); return(widget.CompletedWord); }
async Task <string> Test(string input, string type, string member, Gdk.Key key = Gdk.Key.Return) { string result = null; await Setup(input, async testCase => { var ext = testCase.Content.GetContent <CSharpCompletionTextEditorExtension> (); var listWindow = new CompletionListWindow(); var widget = new TestCompletionWidget(ext.Editor, ext.DocumentContext); listWindow.CompletionWidget = widget; listWindow.CodeCompletionContext = widget.CurrentCodeCompletionContext; var sm = await ext.DocumentContext.AnalysisDocument.GetSemanticModelAsync(); var t = sm.Compilation.GetTypeByMetadataName(type); var foundMember = t.GetMembers().First(m => m.Name == member); var data = new CompletionData(foundMember.Name); data.DisplayFlags |= DisplayFlags.NamedArgument; KeyActions ka = KeyActions.Process; data.InsertCompletionText(listWindow, ref ka, KeyDescriptor.FromGtk(key, (char)key, Gdk.ModifierType.None)); result = widget.CompletedWord; }); return(result); }
public override bool KeyPress(Gdk.Key key, char keyChar, Gdk.ModifierType modifier) { if (key == Gdk.Key.Return) { string lastLine = Editor.GetLineText(Editor.CursorLine); string trimmedLine = lastLine.Trim(); bool indent = false; if (trimmedLine.EndsWith("{")) { indent = true; } if (indent) { base.KeyPress(key, keyChar, modifier); Editor.InsertText(Editor.CursorPosition, "\t"); return(false); } } return(base.KeyPress(key, keyChar, modifier)); }
private void MatItemEditNext(int row, Gdk.Key keyCode) { if (keyCode == Gdk.Key.Tab) { MatCurrentColumnEvaluate(); ProdEditGridField(0, colItem.Index); return; } if (codeQtty != 0) { MatQtyEvaluate(row, codeQtty); } if (barcodeUsed) { if (codeQtty == 0) { MatQtyEvaluate(row, 1); } if (recipe.DetailsMat.Count <= row + 1) { recipe.AddNewDetail(); } MatEditGridField(row + 1, colItem.Index); } else if (colQuantity != null && colQuantity.ListCell.IsEditable) { MatEditGridField(row, colQuantity.Index); } else { MatQtyEditNext(row, keyCode); } }
private void ProdItemEditNext(int row, Gdk.Key keyCode) { if (keyCode == Gdk.Key.Tab) { ProdCurrentColumnEvaluate(); //btnOK.GrabFocus (); return; } if (!codeQtty.IsZero()) { ProdQtyEvaluate(row, codeQtty); } if (barcodeUsed) { if (codeQtty.IsZero()) { ProdQtyEvaluate(row, 1); } if (recipe.DetailsProd.Count <= row + 1) { recipe.AddNewAdditionalDetail(); } ProdEditGridField(row + 1, colSecondItem.Index); } else if (colSecondQuantity != null && colSecondQuantity.ListCell.IsEditable) { ProdEditGridField(row, colSecondQuantity.Index); } else { ProdQtyEditNext(row, keyCode); } }
public override bool KeyPress(Gdk.Key key, char keyChar, Gdk.ModifierType modifier) { // If we are a keyword if (keyChar == ' ' && modifier == Gdk.ModifierType.None && CompletionWidget != null) { CompletionWindowManager.PreProcessKeyEvent(Gdk.Key.Tab, '\t', Gdk.ModifierType.None); CompletionWindowManager.PostProcessKeyEvent(Gdk.Key.Tab, '\t', Gdk.ModifierType.None); CompletionWidget.CurrentCodeCompletionContext.TriggerWordLength = 0; } bool ret = base.KeyPress(key, keyChar, modifier); { // did we type a keyword? string line = Editor.GetLineText(Editor.Caret.Line); string to_left = line.Substring(0, Math.Min(line.Length, Editor.Caret.Column)); if (rx_is_keyword.IsMatch(to_left)) { CompletionWindowManager.HideWindow(); } } return(ret); }
private void OnKeyPressed(object o, KeyPressEventArgs args) { Gdk.Key key = args.Event.Key; Gdk.ModifierType modifier = args.Event.State; Gdk.ModifierType controlModifier = Gdk.ModifierType.ControlMask; if ((modifier & controlModifier) == controlModifier) //Control was pressed { switch (key) { case Gdk.Key.Page_Up: Core.Base.Ui.View.Selection.SelectPrevious(); GrabFocus(); args.RetVal = true; break; case Gdk.Key.Page_Down: Core.Base.Ui.View.Selection.SelectNext(); GrabFocus(); args.RetVal = true; break; } } }
protected override bool ProcessKeyPressEvent(Gtk.KeyPressEventArgs args) { keyHandled = false; keyChar = (char)args.Event.Key; keyValue = args.Event.KeyValue; modifier = args.Event.State; key = args.Event.Key; if ((args.Event.Key == Gdk.Key.Down || args.Event.Key == Gdk.Key.Up)) { keyChar = '\0'; } if (currentCompletionData != null) { if ((keyHandled = CompletionWindowManager.PreProcessKeyEvent(KeyDescriptor.FromGtk(key, keyChar, modifier)))) { return(true); } } return(base.ProcessKeyPressEvent(args)); }
private BaseTool FindNextTool(Gdk.Key shortcut) { string key = shortcut.ToString().ToUpperInvariant(); // Begin looking at the tool after the current one for (int i = index + 1; i < Tools.Count; i++) { if (Tools[i].ShortcutKey.ToString().ToUpperInvariant() == key) { return(Tools[i]); } } // Begin at the beginning and look up to the current tool for (int i = 0; i < index; i++) { if (Tools[i].ShortcutKey.ToString().ToUpperInvariant() == key) { return(Tools[i]); } } return(null); }
protected override void HandleKeypress(Gdk.Key key, uint unicodeKey, Gdk.ModifierType modifier) { switch (key) { case Gdk.Key.Up: if (CurIndex > 0) { CurIndex--; } DocumentLocation loc = insertionPoints[CurIndex].Location; editor.CenterTo(loc.Line - 1, DocumentLocation.MinColumn); editor.QueueDraw(); SetHelpWindowPosition(); break; case Gdk.Key.Down: if (CurIndex < insertionPoints.Count - 1) { CurIndex++; } loc = insertionPoints[CurIndex].Location; editor.CenterTo(loc.Line + 1, DocumentLocation.MinColumn); editor.QueueDraw(); SetHelpWindowPosition(); break; case Gdk.Key.KP_Enter: case Gdk.Key.Return: OnExited(new InsertionCursorEventArgs(true, insertionPoints[CurIndex])); break; case Gdk.Key.Escape: OnExited(new InsertionCursorEventArgs(false, null)); break; } }
/// <summary> /// Creates a new instance of shortcut /// </summary> /// <param name="Value">Keycode</param> /// <param name="Control">Control needs to be pressed in order to execute this</param> /// <param name="Alt">Alt needs to be pressed in order to execute this</param> /// <param name="Shift">Shift needs to be pressed in order to execute this</param> /// <param name="Data"></param> public Shortcut(Gdk.Key Value, bool Control = false, bool Alt = false, bool Shift = false, string Data = "") { control = Control; shift = Shift; alt = Alt; data = Data; keys = Value; }
protected override bool ProcessKeyPressEvent (Gtk.KeyPressEventArgs args) { keyHandled = false; keyChar = (char) args.Event.Key; keyValue = args.Event.KeyValue; modifier = args.Event.State; key = args.Event.Key; if ((args.Event.Key == Gdk.Key.Down || args.Event.Key == Gdk.Key.Up)) { keyChar = '\0'; } if (currentCompletionData != null) { if ((keyHandled = CompletionWindowManager.PreProcessKeyEvent (key, keyChar, modifier))) return true; } return base.ProcessKeyPressEvent (args); }
public Keystroke(Gdk.Key key, uint unicodeKey, Gdk.ModifierType modifier) { m_key = key; m_unicodeKey = unicodeKey; m_modifier = modifier; }
void OnEditKeyPress (object sender, KeyPressEventArgs args) { keyHandled = false; keyChar = (char) args.Event.Key; keyValue = args.Event.KeyValue; modifier = args.Event.State; key = args.Event.Key; if ((args.Event.Key == Gdk.Key.Down || args.Event.Key == Gdk.Key.Up)) { keyChar = '\0'; } if (currentCompletionData != null) args.RetVal = keyHandled = CompletionWindowManager.PreProcessKeyEvent (key, keyChar, modifier); }