public async Task TestBug14686()
{
await Simulate("$\"\\\\\"", (content, ext) => {
content.Data.InsertText(0, "@");
ext.KeyPress(KeyDescriptor.FromGtk((Gdk.Key) '@', '@', Gdk.ModifierType.None));
var newText = content.Text;
Assert.AreEqual("@\"\\\"", newText);
});
}
public void ProcessKeys(string keyPresses, JustEnoughVi.JustEnoughVi plugin)
{
foreach (var c in keyPresses)
{
// TODO: modifier parsing
var descriptor = KeyDescriptor.FromGtk(Gdk.Key.a /* important? */, c, Gdk.ModifierType.None);
plugin.KeyPress(descriptor);
}
}
public async Task TestNonVerbatimToVerbatimConversion()
{
await Simulate("$\"\\t\"", async (content, ext) => {
content.Data.InsertText(0, "@");
await ext.KeyPress(KeyDescriptor.FromGtk((Gdk.Key) '@', '@', Gdk.ModifierType.None));
var newText = content.Text;
Assert.AreEqual("@\"\t\"", newText);
});
}
public void Test(string source, Gdk.Key specialKey, string expected, Type expectedMode)
{
var plugin = InitTest(source);
var descriptor = KeyDescriptor.FromGtk(specialKey, '\0', Gdk.ModifierType.None);
plugin.KeyPress(descriptor);
Check(plugin, expected, expectedMode);
}
void OnEditKeyRelease(object sender, EventArgs e)
{
if (keyHandled)
{
return;
}
CompletionWindowManager.PostProcessKeyEvent(KeyDescriptor.FromGtk(key, keyChar, modifier));
PopupCompletion((Entry)sender);
}
public async Task TestBug17902()
{
await Simulate(@"class Test17902
{
public void Foo()
{
{
if (true)
{
if (true)
{
}
else
{
System.Console.WriteLine(1);
}
}
else
{
System.Console.WriteLine(2);
}
}$
}
}", (content, ext) => {
content.Data.Options = new CustomEditorOptions {
IndentStyle = IndentStyle.Virtual
};
ext.KeyPress(KeyDescriptor.FromGtk(Gdk.Key.braceright, '}', Gdk.ModifierType.None));
var newText = content.Text;
Assert.AreEqual(@"class Test17902
{
public void Foo()
{
{
if (true)
{
if (true)
{
}
else
{
System.Console.WriteLine(1);
}
}
else
{
System.Console.WriteLine(2);
}
}
}
}", newText);
});
}
public async Task TestColonNotCommitChar()
{
using (var testCase = await SetupTestCase("<", 1)) {
var doc = testCase.Document;
var ext = doc.GetContent <BaseXmlEditorExtension> ();
ext.CompletionWidget = doc.Editor.GetViewContent().GetContent <ICompletionWidget> ();
await ext.TriggerCompletion(Ide.CodeCompletion.CompletionTriggerReason.CompletionCommand);
ext.KeyPress(KeyDescriptor.FromGtk(Gdk.Key.colon, ':', Gdk.ModifierType.None));
Assert.IsTrue(CompletionWindowManager.IsVisible);
}
}
void OnEditKeyRelease(object sender, Gtk.KeyReleaseEventArgs args)
{
UpdateTokenBeginMarker();
if (keyHandled)
{
return;
}
CompletionWindowManager.PostProcessKeyEvent(KeyDescriptor.FromGtk(key, keyChar, modifier));
PopupCompletion();
}
public async Task TestBug46817()
{
await Simulate("public class Application\r\n{\r\n\tstatic void Main (string[] args)\r\n\t{\r\n\t\t// abcd\r\n\t\t{\r\n\t\t\t\t}$\r\n", (content, ext) => {
content.Data.Options = new CustomEditorOptions {
IndentStyle = IndentStyle.Virtual
};
ext.KeyPress(KeyDescriptor.FromGtk((Gdk.Key) '}', '}', Gdk.ModifierType.None));
var newText = content.Text;
Assert.AreEqual("public class Application\r\n{\r\n\tstatic void Main (string[] args)\r\n\t{\n\t\t// abcd\r\n\t\t{\r\n\t\t}\r\n", newText);
});
}
void HandleKeyReleaseEvent(object o, Gtk.KeyReleaseEventArgs args)
{
if (keyHandled)
{
return;
}
string text = ctx == null ? Text : Text.Substring(Math.Max(0, Math.Min(ctx.TriggerOffset, Text.Length)));
CompletionWindowManager.UpdateWordSelection(text);
CompletionWindowManager.PostProcessKeyEvent(KeyDescriptor.FromGtk(key, keyChar, modifier));
PopupCompletion();
}
public async Task TestBug44747_regions()
{
await Simulate(@"class Foo
{
void Test()
{
#region$
}
}", (content, ext) => {
content.Data.Options = new CustomEditorOptions {
IndentStyle = IndentStyle.Virtual
};
ext.KeyPress(KeyDescriptor.FromGtk((Gdk.Key) 'n', 'n', Gdk.ModifierType.None));
var newText = content.Text;
Assert.AreEqual(@"class Foo
{
void Test()
{
#region
}
}", newText);
});
await Simulate(@"class Foo
{
void Test()
{
#region foo
#endregion$
}
}", (content, ext) => {
content.Data.Options = new CustomEditorOptions {
IndentStyle = IndentStyle.Virtual
};
ext.KeyPress(KeyDescriptor.FromGtk((Gdk.Key) 'n', 'n', Gdk.ModifierType.None));
var newText = content.Text;
Assert.AreEqual(@"class Foo
{
void Test()
{
#region foo
#endregion
}
}", newText);
});
}
void TextViewKeyReleaseEvent(object sender, KeyReleaseEventArgs args)
{
if (keyHandled || !completionWindow.Visible)
{
return;
}
var keyChar = (char)args.Event.Key;
ModifierType modifier = args.Event.State;
Gdk.Key key = args.Event.Key;
var descriptor = KeyDescriptor.FromGtk(key, keyChar, modifier);
completionWindow.PostProcessKeyEvent(descriptor);
}
/// <summary>
/// Tab key pressed
/// If caret in read - only region ignore
/// If completion list window active select item and close window
/// Else trigger completion async
///
/// Trigger completion
/// If completion list window shown end completion session
///
/// Get caret position and current line text
/// GetExpansionsAsync passing caret position and line text with cancellation token that times out
/// If one item returned use it
/// Else start completion session and show window
///
/// https://github.com/NuGet/NuGet.Client/blob/3803820961f4d61c06d07b179dab1d0439ec0d91/src/NuGet.Clients/NuGet.Console/WpfConsole/WpfConsoleKeyProcessor.cs
/// </summary>
protected override bool ProcessKeyPressEvent(KeyPressEventArgs args)
{
var keyChar = (char)args.Event.Key;
ModifierType modifier = args.Event.State;
Gdk.Key key = args.Event.Key;
if ((key == Gdk.Key.Down || key == Gdk.Key.Up))
{
keyChar = '\0';
}
if (completionWindow.Visible)
{
if (key == Gdk.Key.Return)
{
// AutoSelect is off and the completion window will only
// complete if tab is pressed. So cheat by converting return
// into Tab. Otherwise the command will be run.
key = Gdk.Key.Tab;
keyChar = '\t';
}
var descriptor = KeyDescriptor.FromGtk(key, keyChar, modifier);
keyHandled = completionWindow.PreProcessKeyEvent(descriptor);
if (keyHandled)
{
return(true);
}
}
if (cancellationTokenSource != null)
{
CancelCurrentCompletion();
}
if (key != Gdk.Key.Tab)
{
return(base.ProcessKeyPressEvent(args));
}
int caretIndex = completionWidget.Position;
TriggerCompletionAsync(InputLine, caretIndex).Ignore();
return(true);
}
/// <summary>
/// Tab key pressed
/// If caret in read - only region ignore
/// If completion list window active select item and close window
/// Else trigger completion async
///
/// Trigger completion
/// If completion list window shown end completion session
///
/// Get caret position and current line text
/// Evaluator.GetCompletions
/// If one item returned use it
/// Else start completion session and show window
/// </summary>
protected override bool ProcessKeyPressEvent(KeyPressEventArgs args)
{
var keyChar = (char)args.Event.Key;
ModifierType modifier = args.Event.State;
Gdk.Key key = args.Event.Key;
if ((key == Gdk.Key.Down || key == Gdk.Key.Up))
{
keyChar = '\0';
}
if (completionWindow.Visible)
{
if (key == Gdk.Key.Return)
{
// AutoSelect is off and the completion window will only
// complete if tab is pressed. So cheat by converting return
// into Tab. Otherwise the command will be run.
key = Gdk.Key.Tab;
keyChar = '\t';
}
var descriptor = KeyDescriptor.FromGtk(key, keyChar, modifier);
keyHandled = completionWindow.PreProcessKeyEvent(descriptor);
if (keyHandled)
{
return(true);
}
}
bool dotCompletion = IsDotCompletion(key);
if (dotCompletion)
{
Buffer.InsertAtCursor(".");
}
else if (key != Gdk.Key.Tab)
{
return(base.ProcessKeyPressEvent(args));
}
TriggerCompletion(InputLine, completionWidget.Position, autoComplete: !dotCompletion);
return(true);
}
public async Task TestBug16174_AutoIndent()
{
await Simulate("namespace Foo\n{\n\tpublic class Bar\n\t{\n$\t\tvoid Test()\n\t\t{\n\t\t}\n\t}\n}\n", (content, ext) => {
var options = new CustomEditorOptions();
options.IndentStyle = IndentStyle.Auto;
ext.Editor.Options = options;
EditActions.NewLine(ext.Editor);
ext.KeyPress(KeyDescriptor.FromGtk(Gdk.Key.Return, '\n', Gdk.ModifierType.None));
var newText = content.Text;
var expected = "namespace Foo\n{\n\tpublic class Bar\n\t{\n\n\t\tvoid Test()\n\t\t{\n\t\t}\n\t}\n}\n";
if (newText != expected)
{
Console.WriteLine(newText);
}
Assert.AreEqual(expected, newText);
});
}
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);
});
}
public async Task TestSemicolon()
{
await Simulate(@"class Foo
{
void Test ()
{
Console.WriteLine () ;$
}
}", (content, ext) => {
ext.KeyPress(KeyDescriptor.FromGtk(Gdk.Key.semicolon, ';', Gdk.ModifierType.None));
var newText = content.Text;
Assert.AreEqual(@"class Foo
{
void Test ()
{
Console.WriteLine();
}
}", newText);
});
}
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);
}
public async Task TestCloseBrace()
{
await Simulate(@"class Foo
{
void Test ()
{
Console.WriteLine() ;
}$
}", (content, ext) => {
ext.KeyPress(KeyDescriptor.FromGtk(Gdk.Key.braceright, '}', Gdk.ModifierType.None));
var newText = content.Text;
Console.WriteLine(newText);
Assert.AreEqual(@"class Foo
{
void Test()
{
Console.WriteLine();
}
}", newText);
});
}
public async Task TestIssue5951()
{
using (var data = await Create(@"
using System;
namespace MyLibrary
{
public class MyClass
{
public MyClass()
{
}
$
}
}")) {
data.Document.Editor.Options = new CustomEditorOptions(data.Document.Editor.Options)
{
IndentStyle = IndentStyle.Smart,
RemoveTrailingWhitespaces = false
};
var indent = new CSharpTextEditorIndentation();
indent.Initialize(data.Document.Editor, data.Document);
indent.KeyPress(KeyDescriptor.FromGtk(Gdk.Key.Return, '\n', Gdk.ModifierType.None));
CheckOutput(data, @"
using System;
namespace MyLibrary
{
public class MyClass
{
public MyClass()
{
}
$
}
}", indent);
}
}
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 async Task TestCorrectReindentNextLine()
{
await Simulate(@"
class Foo
{
void Bar ()
{
try {
} catch (Exception e) {$}
}
}
", (content, ext) => {
ext.ReindentOnTab();
EditActions.NewLine(ext.Editor);
ext.KeyPress(KeyDescriptor.FromGtk((Gdk.Key) '\n', '\n', Gdk.ModifierType.None));
var newText = content.Text;
var expected = @"
class Foo
{
void Bar ()
{
try {
} catch (Exception e) {
}
}
}
";
if (newText != expected)
{
Console.WriteLine(newText);
}
Assert.AreEqual(expected, newText);
});
}
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));
}
async 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 = await CompletionWindowManager.PreProcessKeyEvent(KeyDescriptor.FromGtk(key, keyChar, modifier));
}
}
public override bool KeyPress(KeyDescriptor descriptor)
{
var buffer = Editor;
var keyChar = descriptor.KeyChar;
var key = descriptor.SpecialKey;
var modifier = descriptor.ModifierKeys;
if (CompletionWindowManager.IsVisible)
{
// do some things to minimize keystrokes with code completion
if (keyChar == '=')
{
// we're in an attribute completion, so automatically add the quote and show completions (if available)
var ret = base.KeyPress(descriptor);
if (!ret)
{
base.KeyPress(KeyDescriptor.FromGtk((Gdk.Key) 0, '"', Gdk.ModifierType.None));
buffer.InsertText(buffer.CaretOffset, "\"");
buffer.CaretOffset--;
}
return(ret);
}
if (key == SpecialKey.Return &&
modifier == ModifierKeys.None &&
isParameterValueCompletion)
{
// finish completion
base.KeyPress(descriptor);
// if double quote already exists, skip it!
if (buffer.GetCharAt(buffer.CaretOffset) == '"')
{
buffer.CaretOffset++;
return(false);
}
// no double quote yet, so add it
return(base.KeyPress(KeyDescriptor.FromGtk((Gdk.Key) 0, '"', Gdk.ModifierType.None)));
}
if (keyChar == '"' || keyChar == '\'')
{
// finish completion with double quote
base.KeyPress(KeyDescriptor.FromGtk(Gdk.Key.Return, '\0', Gdk.ModifierType.None));
// if double quote already exists, skip it!
if (buffer.GetCharAt(buffer.CaretOffset) == keyChar)
{
buffer.CaretOffset++;
return(false);
}
return(base.KeyPress(descriptor));
}
}
if (keyChar == '>')
{
// finish completion first
if (CompletionWindowManager.IsVisible)
{
base.KeyPress(KeyDescriptor.FromGtk(Gdk.Key.Return, '\0', Gdk.ModifierType.None));
}
// add self-closing tag if there is no content for the control
if (!HasContentAtCurrentElement())
{
base.KeyPress(KeyDescriptor.FromGtk((Gdk.Key) 0, '/', Gdk.ModifierType.None));
//buffer.InsertText(buffer.CursorPosition++, "/");
return(base.KeyPress(descriptor));
}
}
if (keyChar == '"' || keyChar == '\'')
{
// if double quote already exists, skip it!
if (buffer.GetCharAt(buffer.CaretOffset) == keyChar)
{
buffer.CaretOffset++;
return(false);
}
}
if (keyChar == '.' || ((key == SpecialKey.Return || key == SpecialKey.Tab) && CompletionWindowManager.IsVisible))
{
// provide completions for <Control.Property> elements
var isNewCompletion = keyChar == '.' && !CompletionWindowManager.IsVisible;
var completionContext = CurrentCompletionContext;
var result = base.KeyPress(descriptor);
if (isNewCompletion)
{
completionContext = CurrentCompletionContext;
}
var offset = completionContext.TriggerOffset - 1;
// using reflection here as these have been made internal as of XS 6.0. Why? who knows. Alternative? reflection of course.
var completionWidget = GetType().GetProperty("CompletionWidget", BindingFlags.Instance | BindingFlags.NonPublic)?.GetValue(this);
var getCharMethod = completionWidget?.GetType()?.GetMethod("GetChar", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public);
if (getCharMethod != null)
{
Func <int, char> getChar = (arg) =>
{
return((char)getCharMethod.Invoke(completionWidget, new object[] { arg }));
};
var ch = getChar(offset);
while (ch != '\0' && (XmlConvert.IsNCNameChar(ch) || ch == ':') && offset > 0)
{
offset--;
ch = getChar(offset);
}
if (ch != '\0' && ch != '<')
{
return(result);
}
}
offset++;
var end = isNewCompletion ? completionContext.TriggerOffset - 1 : buffer.CaretOffset;
var name = Editor.GetTextAt(offset, end - offset);
if (!isNewCompletion && !name.EndsWith(".", StringComparison.Ordinal))
{
return(result);
}
try
{
XmlConvert.VerifyName(name);
}
catch (XmlException)
{
// not a valid xml name, so just return
return(result);
}
var xobject = Tracker.Engine.Nodes.Peek(1) as IAttributedXObject;
if (xobject == null)
{
string prefix = null;
var nsidx = name.IndexOf(':');
if (nsidx > 0)
{
prefix = name.Substring(0, nsidx);
name = name.Substring(nsidx + 1);
}
name = name.TrimEnd('.');
xobject = new XElement(Tracker.Engine.Location, new XName(prefix, name));
}
var attributeDictionary = new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase);
if (xobject.Attributes != null)
{
foreach (XAttribute current in xobject.Attributes)
{
attributeDictionary[current.Name.FullName] = current.Value ?? string.Empty;
}
}
var task = GetAttributeCompletions(xobject, attributeDictionary, CancellationToken.None, XmlCompletionData.DataType.XmlElement, true);
task.ContinueWith(t =>
{
// need to show completion within the main task scheduler, otherwise it doesn't show
var completions = t.Result;
if (completions != null)
{
ShowCompletion(completions, 0, '.');
}
}, Runtime.MainTaskScheduler);
return(false);
}
return(base.KeyPress(descriptor));
}
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));
}
}
static void SimulateInput(CompletionListWindow listWindow, string input)
{
var testCompletionWidget = ((TestCompletionWidget)listWindow.CompletionWidget);
bool isClosed = false;
listWindow.WindowClosed += delegate {
isClosed = true;
};
foreach (char ch in input)
{
switch (ch)
{
case '8':
listWindow.PreProcessKeyEvent(KeyDescriptor.FromGtk(Gdk.Key.Up, '\0', Gdk.ModifierType.None));
listWindow.PostProcessKeyEvent(KeyDescriptor.FromGtk(Gdk.Key.Up, '\0', Gdk.ModifierType.None));
break;
case '2':
listWindow.PreProcessKeyEvent(KeyDescriptor.FromGtk(Gdk.Key.Down, '\0', Gdk.ModifierType.None));
listWindow.PostProcessKeyEvent(KeyDescriptor.FromGtk(Gdk.Key.Down, '\0', Gdk.ModifierType.None));
break;
case '4':
listWindow.PreProcessKeyEvent(KeyDescriptor.FromGtk(Gdk.Key.Left, '\0', Gdk.ModifierType.None));
listWindow.PostProcessKeyEvent(KeyDescriptor.FromGtk(Gdk.Key.Left, '\0', Gdk.ModifierType.None));
break;
case '6':
listWindow.PreProcessKeyEvent(KeyDescriptor.FromGtk(Gdk.Key.Right, '\0', Gdk.ModifierType.None));
listWindow.PostProcessKeyEvent(KeyDescriptor.FromGtk(Gdk.Key.Right, '\0', Gdk.ModifierType.None));
break;
case '\t':
listWindow.PreProcessKeyEvent(KeyDescriptor.FromGtk(Gdk.Key.Tab, '\t', Gdk.ModifierType.None));
listWindow.PostProcessKeyEvent(KeyDescriptor.FromGtk(Gdk.Key.Tab, '\t', Gdk.ModifierType.None));
break;
case '\b':
listWindow.PreProcessKeyEvent(KeyDescriptor.FromGtk(Gdk.Key.BackSpace, '\b', Gdk.ModifierType.None));
testCompletionWidget.Backspace();
listWindow.PostProcessKeyEvent(KeyDescriptor.FromGtk(Gdk.Key.BackSpace, '\b', Gdk.ModifierType.None));
break;
case '\n':
listWindow.PreProcessKeyEvent(KeyDescriptor.FromGtk(Gdk.Key.Return, '\n', Gdk.ModifierType.None));
listWindow.PostProcessKeyEvent(KeyDescriptor.FromGtk(Gdk.Key.Return, '\n', Gdk.ModifierType.None));
break;
default:
listWindow.PreProcessKeyEvent(KeyDescriptor.FromGtk((Gdk.Key)ch, ch, Gdk.ModifierType.None));
testCompletionWidget.AddChar(ch);
listWindow.PostProcessKeyEvent(KeyDescriptor.FromGtk((Gdk.Key)ch, ch, Gdk.ModifierType.None));
break;
}
// window closed.
if (isClosed)
{
break;
}
}
}