public override void OnWindowLoaded()
{
bool requiresCompiler = false;
foreach (var snippet in SnippetsAddinConfiguration.Current.Snippets)
{
if (!requiresCompiler && !string.IsNullOrEmpty(snippet.SnippetText) &&
(snippet.SnippetText.Contains("{{") || snippet.SnippetText.Contains("@")))
{
requiresCompiler = true;
}
if (!string.IsNullOrEmpty(snippet.KeyboardShortcut))
{
var ksc = snippet.KeyboardShortcut.ToLower();
KeyBinding kb = new KeyBinding();
if (ksc.Contains("alt"))
{
kb.Modifiers = ModifierKeys.Alt;
}
if (ksc.Contains("shift"))
{
kb.Modifiers |= ModifierKeys.Shift;
}
if (ksc.Contains("ctrl") || ksc.Contains("ctl"))
{
kb.Modifiers |= ModifierKeys.Control;
}
string key =
ksc.Replace("+", "")
.Replace("-", "")
.Replace("_", "")
.Replace(" ", "")
.Replace("alt", "")
.Replace("shift", "")
.Replace("ctrl", "")
.Replace("ctl", "");
key = CultureInfo.CurrentCulture.TextInfo.ToTitleCase(key);
if (!string.IsNullOrEmpty(key))
{
KeyConverter k = new KeyConverter();
kb.Key = (Key)k.ConvertFromString(key);
}
// Whatever command you need to bind to
kb.Command = new CommandBase((s, e) => InsertSnippet(snippet),
(s, e) => Model.IsEditorActive);
Model.Window.InputBindings.Add(kb);
}
}
if (requiresCompiler)
{
RoslynLifetimeManager.WarmupRoslyn();
}
}
/// <summary>
/// Creates a keyboard shortcut from a
/// </summary>
/// <param name="ksc"></param>
/// <param name="command"></param>
/// <returns>KeyBinding - Window.InputBindings.Add(keyBinding)</returns>
public static KeyBinding CreateKeyboardShortcutBinding(string ksc, ICommand command,
object commandParameter = null)
{
if (string.IsNullOrEmpty(ksc))
{
return(null);
}
try
{
KeyBinding kb = new KeyBinding();
ksc = ksc.ToLower();
if (ksc.Contains("alt"))
{
kb.Modifiers = ModifierKeys.Alt;
}
if (ksc.Contains("shift"))
{
kb.Modifiers |= ModifierKeys.Shift;
}
if (ksc.Contains("ctrl") || ksc.Contains("ctl"))
{
kb.Modifiers |= ModifierKeys.Control;
}
if (ksc.Contains("win"))
{
kb.Modifiers |= ModifierKeys.Windows;
}
string key =
ksc.Replace("+", "")
.Replace("-", "")
.Replace("_", "")
.Replace(" ", "")
.Replace("alt", "")
.Replace("shift", "")
.Replace("ctrl", "")
.Replace("ctl", "");
key = CultureInfo.CurrentCulture.TextInfo.ToTitleCase(key);
if (!string.IsNullOrEmpty(key))
{
KeyConverter k = new KeyConverter();
kb.Key = (Key)k.ConvertFromString(key);
}
// Whatever command you need to bind to
kb.Command = command;
if (commandParameter != null)
{
kb.CommandParameter = commandParameter;
}
return(kb);
}
// deal with invalid bindings - ignore them
catch (Exception ex)
{
mmApp.Log("Unable to assign key binding: " + ksc, ex);
return(null);
}
}
/// <summary>
/// Spracovanie stlačených tlačítok
/// </summary>
/// <param name="sender">Sender object</param>
/// <param name="e">KeyEventArgs</param>
private void Window_KeyDown(object sender, KeyEventArgs e)
{
bool shiftPressed = (Keyboard.Modifiers & ModifierKeys.Shift) == ModifierKeys.Shift;
// Vypíš číslo
if (!shiftPressed && OutputProcessor.IsNumericKey(e.Key))
{
KeyConverter keyConverter = new KeyConverter();
this.outputProcessor.PrintNumber(keyConverter.ConvertToString(e.Key));
}
// Vypíš desatinnú čiarku
if (!shiftPressed && (e.Key == Key.Decimal || e.Key == Key.OemComma || e.Key == Key.OemPeriod))
{
this.outputProcessor.PrintComma();
}
// Vypočítaj výsledok
if (e.Key == Key.Enter || e.Key == Key.Return || !shiftPressed && e.Key == Key.OemPlus)
{
this.mathProcessor.CalculateResult(this.GetNumericAns(), false, true);
}
// Odstráň posledné číslo pomocou backspace
if (e.Key == Key.Back)
{
this.outputProcessor.Backspace();
}
// Add
if (e.Key == Key.Add || shiftPressed && e.Key == Key.OemPlus)
{
this.mathProcessor.ProcessAdd(this.GetNumericAns());
}
// Substract
if (e.Key == Key.Subtract || !shiftPressed && e.Key == Key.OemMinus)
{
this.mathProcessor.ProcessSubstract(this.GetNumericAns());
}
// Multiply
if (e.Key == Key.Multiply || shiftPressed && e.Key == Key.D8)
{
this.mathProcessor.ProcessMultiply(this.GetNumericAns());
}
// Divide
if (e.Key == Key.Divide || !shiftPressed && e.Key == Key.OemQuestion)
{
this.mathProcessor.ProcessDivide(this.GetNumericAns());
}
// Factorial (Fact)
if (shiftPressed && e.Key == Key.D1)
{
this.mathProcessor.ProcessFact(this.GetNumericAns());
}
// Power (Pow)
if (shiftPressed && e.Key == Key.D6)
{
this.mathProcessor.ProcessPow(this.GetNumericAns());
}
}
public static Macro LoadMacroFile(string[] file)
{
if (file.Length > 0)
{
string[] args = file[0].Split(' ');
if (args.Length <= 1)
{
args = new string[2] {
args[0], "ÿ"
};
}
if (args[0].ToLower().Contains("macro"))
{
Macro macro = new Macro(KeyConverter.Name2WinFormKey(args[1]));
if (args[0].ToLower().Contains("mouse"))
{
macro.Type = MacroType.Mouse;
macro.TriggerKey = KeyConverter.Name2WinFormKey("" + args[1][0]);
}
else if (args[0].ToLower().Contains("winopen"))
{
macro.Type = MacroType.WinOpen;
}
else if (args[0].ToLower().Contains("startup"))
{
macro.Type = MacroType.Startup;
}
else if (args[0].ToLower().Contains("idle"))
{
macro.Type = MacroType.IDLE;
try { macro.idletime = Int32.Parse(args[1]); }
catch { }
}
else if (args[0].ToLower().Contains("rewrite"))
{
macro.Type = MacroType.RewriteKeyboard;
string[] tmp = args[1].Split("+".ToCharArray());
foreach (string k in tmp)
{
Keys result = KeyConverter.Name2WinFormKey(k);
if (result != Keys.None)
{
macro.TriggerKeys.Add(result);
}
}
}
if (args[0].ToLower().Contains("super"))
{
macro.Override = true;
}
if (args.Length >= 3)
{
macro.targetapp = args[2];
}
for (int i = 1; i < file.Length; i++)
{
args = file[i].Split(' ');
if (args.Length >= 2)
{
int time = 0;
byte code = 0;
Point P = Point.Empty;
KeySender.MouseButton button;
switch (args[0].ToLower())
{
case "key":
code = KeyConverter.Name2Key(args[1]);
if (code != 0)
{
macro.Add(new ActionKeyStroke(code));
}
break;
case "keydown":
code = KeyConverter.Name2Key(args[1]);
if (code != 0)
{
macro.Add(new ActionKeyPress(code));
}
break;
case "keyup":
code = KeyConverter.Name2Key(args[1]);
if (code != 0)
{
macro.Add(new ActionKeyRelease(code));
}
break;
case "mouse":
button = KeyConverter.Name2MouseKey(args[1]);
if (args.Length >= 3 && ParsePoint(args[2], ref P))
{
macro.Add(new ActionMouseClick(button, P));
}
else
{
macro.Add(new ActionMouseClick(button));
}
break;
case "mousedown":
button = KeyConverter.Name2MouseKey(args[1]);
if (args.Length >= 3 && ParsePoint(args[2], ref P))
{
macro.Add(new ActionMousePress(button, P));
}
else
{
macro.Add(new ActionMousePress(button));
}
break;
case "mouseup":
button = KeyConverter.Name2MouseKey(args[1]);
if (args.Length >= 3 && ParsePoint(args[2], ref P))
{
macro.Add(new ActionMouseRelease(button, P));
}
else
{
macro.Add(new ActionMouseRelease(button));
}
break;
case "sleep":
try { time = Int32.Parse(args[1]); }
catch { }
if (time != 0)
{
macro.Add(new ActionSleep(time));
}
break;
case "run":
try { macro.Add(new ActionRun(file[i].Substring(4))); }
catch { }
break;
case "paste":
try { macro.Add(new ActionPaste(file[i].Substring(6))); }
catch { }
break;
case "close":
try { macro.Add(new ActionClose(file[i].Substring(6))); }
catch { }
break;
case "kill":
macro.Add(new ActionKill(args[1]));
break;
}
}
}
return(macro);
}
else
{
return(null);
}
}
else
{
return(null);
}
}
private void visior_KeyDown(object sender, KeyEventArgs e)
{
if (e.Key == Key.F6)
{
popi.IsOpen = false;
LookUpSelector contragenSelector = new LookUpSelector(DataContext as SaldoItem);
contragenSelector.ShowDialog();
if (contragenSelector.DialogResult.HasValue && contragenSelector.DialogResult.Value)
{
var data = contragenSelector.dg.ItemsSource2D as ObservableCollection <ObservableCollection <string> >;
var dat = DataContext as SaldoItem;
if (data != null)
{
if (contragenSelector.dg.SelectedIndex != -1)
{
var dat1 = data[contragenSelector.dg.SelectedIndex + 1];
if (dat != null)
{
dat.Value = dat1[0];
dat.Lookupval = dat1[1];
if (dat1.Count > 4)
{
dat.Bulstad = dat1[3];
dat.Vat = dat1[4];
}
dat.LiD = dat.GetLookUpId(0);
OnRefreshExecuted(new FastLookupEventArgs(dat));
}
}
}
}
e.Handled = true;
return;
}
if (e.Key == Key.Enter)
{
var sendy = sender as TextBoxEx;
if (sendy != null && string.IsNullOrWhiteSpace(sendy.Text))
{
var dat = DataContext as SaldoItem;
if (dat != null)
{
dat.Value = "";
dat.Lookupval = "";
}
}
}
var _keyConv = new KeyConverter();
string keyPressed = _keyConv.ConvertToString(e.Key);
if (keyPressed != null && keyPressed.Length == 1 || keyPressed.Contains("NumPad"))
{
if (char.IsLetterOrDigit(keyPressed[0]))
{
{
searcher.Visibility = Visibility.Visible;
visior.Visibility = Visibility.Hidden;
searcher.Text = "";
searcher.Focus();
}
}
}
}
public _MultiKeyGestureConverter()
{
_keyConverter = new KeyConverter();
_modifierKeysConverter = new ModifierKeysConverter();
}
/// <summary>
/// The Controller is notified about key down events
/// </summary>
private void InputKeys(KeyEventArgs e, bool controlDown,
bool shiftDown)
{
var anyKeyConverter = new KeyConverter();
Log.Info(anyKeyConverter.ConvertToString(e.Key) + " Pressed");
if ((controlDown) || (shiftDown) || (!_attachedView.ActiveControlFocused()))
{
return;
}
var isNumeric = (e.Key >= Key.D0 && e.Key <= Key.D9);
var isNumPad = (e.Key >= Key.NumPad0 && e.Key <= Key.NumPad9) || e.Key == Key.Decimal;
var value = string.Empty;
if (isNumeric)
{
var converter = new KeyConverter();
value = converter.ConvertToString(e.Key);
}
if (e.Key == Key.OemComma)
{
value = ",";
}
if (e.Key == Key.OemPeriod)
{
value = ".";
}
if (e.Key == Key.R)
{
value = "r";
}
if (e.Key == Key.OemMinus)
{
value = "-";
}
if (isNumPad)
{
var converter = new KeyConverter();
var result = converter.ConvertToString(e.Key);
if (result != null)
{
var numKey = result[6];
value = numKey.ToString();
}
}
_commandLineView.EditTextBox.Text += value;
if (e.Key == Key.Back)
{
if (_commandLineView.EditTextBox.Text != "")
{
_commandLineView.EditTextBox.Text = _commandLineView.EditTextBox.Text.Substring(0,
_commandLineView.
EditTextBox.Text
.Length - 1);
}
}
if (e.Key == Key.Enter)
{
_commandLineView.TextBoxKeyDown(this, e);
}
}
public void SetKeyAlias(object input, object key)
{
KeyConverter.SetKeyAlias(input, key);
}
public bool IsReleased(object input)
{
if (!KeyConverter.ContainsInput(input))
{
return(false);
}
return(MouseHardware.CurrentButtonUpEvent(KeyConverter.GetKey(input)) && MouseHardware.OldButtonDownEvent(KeyConverter.GetKey(input)));
}
public HotkeyConverter()
{
_modifierKeyConverter = new ModifierKeysConverter();
_keyConverter = new KeyConverter();
}
public override void Initialize()
{
KeyConverter = new KeyConverter();
}
public SettingsWindow(HookManager hooks)
{
InitializeComponent();
_hooks = hooks;
KeybindingsToggle.IsChecked = hooks.Listening;
TimerKeybindingsToggle.IsChecked = Settings.Default.TimerKeys;
DigitsBox.SelectedIndex = Settings.Default.MiliDigits;
DelayBox.Text = Settings.Default.UpdateDelay.ToString();
Startbind.Text = Settings.Default.StartKey;
Resetbind.Text = Settings.Default.ResetKey;
KeybindingsToggle.Checked += (sender, e) =>
{
Settings.Default.GlobalKeybinds = true;
_hooks.Listen();
};
KeybindingsToggle.Unchecked += (sender, e) =>
{
Settings.Default.GlobalKeybinds = false;
_hooks.StopListening();
};
DigitsBox.SelectionChanged += (sender, e) =>
{
// Jesus christ this is ugly and smells, but ey, it works
int digits = int.Parse(((ComboBoxItem)DigitsBox.SelectedItem).Content.ToString());
Settings.Default.MiliDigits = digits;
NotifySubscribers();
};
DelayBox.TextChanged += (sender, e) =>
{
int milli;
if (int.TryParse(DelayBox.Text, out milli))
{
Settings.Default.UpdateDelay = milli;
NotifySubscribers();
}
};
Startbind.KeyUp += (sender, e) =>
{
if (Startbind.IsFocused)
{
KeyConverter keyConverter = new KeyConverter();
_hooks.DisableHook((Key)keyConverter.ConvertFromString(Settings.Default.StartKey));
string startKey = keyConverter.ConvertToString(e.Key);
Startbind.Text = startKey;
e.Handled = true;
Settings.Default.StartKey = startKey;
NotifySubscribers();
}
};
Resetbind.KeyUp += (sender, e) =>
{
if (Resetbind.IsFocused)
{
KeyConverter keyConverter = new KeyConverter();
_hooks.DisableHook((Key)keyConverter.ConvertFromString(Settings.Default.ResetKey));
string resetKey = keyConverter.ConvertToString(e.Key);
Resetbind.Text = resetKey;
e.Handled = true;
Settings.Default.ResetKey = resetKey;
NotifySubscribers();
}
};
this.Closed += (sender, e) => Settings.Default.Save();
TimerKeybindingsToggle.Checked += (sender, e) =>
{
Settings.Default.TimerKeys = true;
NotifySubscribers();
};
TimerKeybindingsToggle.Unchecked += (sender, e) =>
{
Settings.Default.TimerKeys = false;
NotifySubscribers();
};
}
public void read_settings()
{
KeyConverter k = new KeyConverter();
if (File.Exists("ap_settings.txt"))
{
string[] settings = File.ReadAllLines("ap_settings.txt");
string ahkwhole = "";
foreach (string st in settings)
{
if (st.Contains("hp_button"))
{
cmb_hp.Text = st.Split(new string[] { " = " }, StringSplitOptions.None)[1];
}
else if (st.Contains("sp_button"))
{
cmb_sp.Text = st.Split(new string[] { " = " }, StringSplitOptions.None)[1];
}
else if (st.Contains("hp_percent"))
{
textBox1.Text = st.Split(new string[] { " = " }, StringSplitOptions.None)[1];
}
else if (st.Contains("sp_percent"))
{
textBox2.Text = st.Split(new string[] { " = " }, StringSplitOptions.None)[1];
}
else if (st.Contains("status_button"))
{
// cmb_status.Text = st.Split(new string[] { " = " }, StringSplitOptions.None)[1];
}
else if (st.Contains("hold_button"))
{
// cmb_hold.Text = st.Split(new string[] { " = " }, StringSplitOptions.None)[1];
}
else if (st.Contains("gloom_button"))
{
cmb_gloom.Text = st.Split(new string[] { " = " }, StringSplitOptions.None)[1];
}
else if (st.Contains("aspd_button"))
{
cmb_aspd.Text = st.Split(new string[] { " = " }, StringSplitOptions.None)[1];
}
/*else if (st.Contains("rcx_color"))
* {
* tb_rcx.Text = st.Split(new string[] { " = " }, StringSplitOptions.None)[1];
* }*/
// foods
else if (st.Contains("agiscroll_button"))
{
cmb_agi.Text = st.Split(new string[] { " = " }, StringSplitOptions.None)[1];
}
else if (st.Contains("blesscroll_button"))
{
cmb_bless.Text = st.Split(new string[] { " = " }, StringSplitOptions.None)[1];
}
else if (st.Contains("ap_delay"))
{
tb_apDelay.Text = st.Split(new string[] { " = " }, StringSplitOptions.None)[1];
}
else if (st.Contains("autobuff_delay"))
{
tb_abuffDelay.Text = st.Split(new string[] { " = " }, StringSplitOptions.None)[1];
}
else if (st.Contains("autobuff_read_delay"))
{
tb_abuffReadDelay.Text = st.Split(new string[] { " = " }, StringSplitOptions.None)[1];
}
else if (st.Contains("spam_delay"))
{
tb_spamDelay.Text = st.Split(new string[] { " = " }, StringSplitOptions.None)[1];
}
else if (st.Contains("ahk_list"))
{
all_keys.Clear();
all_keysB.Clear();
ahkwhole = st.Split(new string[] { " = " }, StringSplitOptions.None)[1];
foreach (string a in ahkwhole.Split(','))
{
if (a.Length != 0)
{
if (a.Contains("mc"))
{
Key _ahk = (Key)k.ConvertFromString(a.Split(':')[0]);
all_keys.Add(_ahk);
}
else
{
Key _ahk = (Key)k.ConvertFromString(a.Split(':')[0]);
all_keysB.Add(_ahk);
}
lb_ahk.Items.Add(a);
}
}
}
}
readSettingsFromUI();
}
else
{
string allahk = "";
all_keys.Clear();
all_keysB.Clear();
foreach (string ahkl in lb_ahk.Items)
{
allahk += string.Format("{0},", ahkl);
if (ahkl.Contains("mc"))
{
Key _ahk = (Key)k.ConvertFromString(ahkl.Split(':')[0]);
all_keys.Add(_ahk);
}
else
{
Key _ahk = (Key)k.ConvertFromString(ahkl.Split(':')[0]);
all_keysB.Add(_ahk);
}
}
string[] settings =
{
string.Format("hp_button = {0}", cmb_hp.Text),
string.Format("sp_button = {0}", cmb_sp.Text),
string.Format("ahk_list = {0}", allahk),
string.Format("hp_percent = {0}", textBox1.Text),
string.Format("sp_percent = {0}", textBox2.Text),
string.Format("gloom_button = {0}", cmb_gloom.Text),
string.Format("aspd_button = {0}", cmb_aspd.Text),
string.Format("agiscroll_button = {0}", cmb_agi.Text),
string.Format("blesscroll_button = {0}", cmb_agi.Text),
string.Format("ap_delay = {0}", tb_apDelay.Text),
string.Format("autobuff_delay = {0}", tb_abuffDelay.Text),
string.Format("autobuff_read_delay = {0}", tb_abuffReadDelay.Text),
string.Format("spam_delay = {0}", tb_spamDelay.Text),
string.Format("", "")
};
File.WriteAllLines("ap_settings.txt", settings);
readSettingsFromUI();
}
}
/// <summary>
/// Internal init function to set up DynaHotkeys hotkeys for the category systems.
/// </summary>
private void Init_InitGlobalState_SetUpDynaHotkeyHotkeys()
{
List <Category> CategoryList = GlobalState.CategoryManager.CurrentCategorySystem.Categories;
KeyConverter KConverter = new KeyConverter();
foreach (Category Cat in CategoryList)
{
string CatName = Cat.Name;
string KeyName = null;
if (CatName.ContainsNumeric())
{
int KeyPosition = CatName.GetFirstIndexOfNumeric();
// should be impossible
Debug.Assert(KeyPosition != -1);
KeyName = KeyPosition.ToString();
Key Key = (Key)KConverter.ConvertFromString(KeyName);
DynaHotkey DHotkey = DHotkeyManager.AddNewHotkey(CatName, new List <Key> {
Key
}, false);
Cat.Hotkey = DHotkey;
continue;
}
else
{
string[] Words = Cat.Name.Split(' ');
switch (Words.Length)
{
case 0:
continue; // do nothing the category name is empty. This code shouldn't even run but just in case.
case 1:
string FirstWordOfCatName = Words[0];
// not a char because of the methods used.
string FirstChar = FirstWordOfCatName[0].ToString();
KeyName = FirstChar;
Key Key = (Key)KConverter.ConvertFromString(KeyName);
if (!DHotkeyManager.CheckIfKeyIsDuplicated(Key))
{
DynaHotkey DHotkey = DHotkeyManager.AddNewHotkey(CatName, new List <Key>()
{
Key
}, false);
Cat.Hotkey = DHotkey;
}
continue;
default:
string HotkeyName = Cat.GetAbbreviatedCategoryName(CatName, 1, 1, 1);
if (HotkeyName.Length != 0)
{
KeyName = HotkeyName;
Key NewHotkey = (Key)KConverter.ConvertFromString(KeyName);
// as dynahotkeys can be used for anything, check for duplication and duplicate hotkey to categories
// this is spaghettified so i'll probably slim it down to specifically one subclass of IHotkey
if (!DHotkeyManager.CheckIfKeyIsDuplicated(NewHotkey))
{
DynaHotkey DHotkey = DHotkeyManager.AddNewHotkey(CatName, new List <Key>()
{
NewHotkey
}, false);
Cat.Hotkey = DHotkey;
}
}
else
{
Error.Throw("Warning!", "Error generating abbreviation; skipping this DynaHotkey", ErrorSeverity.Warning, 414);
continue;
}
continue;
}
}
}
}
private void ResetInputBinding(MenuItem menu, Key key) {
KeyConverter k = new KeyConverter();
menu.InputGestureText = k.ConvertToString(key);
foreach (KeyBinding item in InputBindings) {
if (item.Key == key) {
item.Modifiers = ModifierKeys.None;
break;
}
}
}
public static string GetKey(Key key)
{
var keyConverter = new KeyConverter();
// converts it to string representation. IE. Key.E = "E" and Key.OemComma = "OemComma"
string character = keyConverter.ConvertToString(key);
if (!string.IsNullOrEmpty(character) && character.Length == 1)
{
if (char.IsLetter(character, 0))
{
return(character);
}
if (char.IsNumber(character, 0) && !IsShiftKey())
{
return(character);
}
if (char.IsNumber(character, 0) && IsShiftKey())
{
switch (key)
{
// http://msdn.microsoft.com/en-us/library/system.windows.forms.keys(v=vs.110).aspx
case Key.D1:
return("!");
case Key.D2:
return("@");
case Key.D3:
return("#");
case Key.D4:
return("$");
case Key.D5:
return("%");
case Key.D6:
return("^");
case Key.D7:
return("&");
case Key.D8:
return("*");
case Key.D9:
return("(");
case Key.D0:
return(")");
}
}
}
switch (key)
{
// http://msdn.microsoft.com/en-us/library/system.windows.forms.keys(v=vs.110).aspx
case Key.Oem4: return(IsShiftKey() ? "{" : "[");
case Key.Oem6: return(IsShiftKey() ? "}" : "]");
case Key.Oem5: return(IsShiftKey() ? "|" : @"\");
case Key.OemMinus: return(IsShiftKey() ? "_" : "-");
case Key.OemPlus: return(IsShiftKey() ? "+" : "=");
case Key.OemQuestion: return(IsShiftKey() ? "?" : "/");
case Key.OemSemicolon: return(IsShiftKey() ? ":" : ";");
case Key.Oem7: return(IsShiftKey() ? "'" : "\"");
case Key.OemPeriod: return(IsShiftKey() ? ">" : ".");
case Key.OemComma: return(IsShiftKey() ? "<" : ",");
}
return(string.Empty);
}
public void Handle_PreviewKeyDown(KeyEventArgs currentKey, bool forceSendToMainWindow)
{
// Check the arguments for null
ThrowIf.IsNullArgument(currentKey, nameof(currentKey));
// First, try to interpret key as a possible valid quickpaste shortcut key.
// If so, send it to the Quickpaste window and mark the event as handled.
if ((Keyboard.IsKeyDown(Key.LeftCtrl) || Keyboard.IsKeyDown(Key.RightCtrl)) &&
((currentKey.Key >= Key.D0 && currentKey.Key <= Key.D9) || (currentKey.Key >= Key.NumPad0 && currentKey.Key <= Key.NumPad9)))
{
if (this.quickPasteWindow != null && this.quickPasteWindow.Visibility == Visibility.Visible)
{
// The quickpaste window is visible, and thus able to take shortcuts.
string key = new KeyConverter().ConvertToString(currentKey.Key);
if (key.StartsWith("NumPad"))
{
key = key.Remove(0, 6);
}
if (Int32.TryParse(key, out int shortcutIndex) && shortcutIndex != 0)
{
this.quickPasteWindow.TryQuickPasteShortcut(shortcutIndex);
currentKey.Handled = true;
}
}
return;
}
// Next, - but only if forceSendToMainWindow is true,
// don't interpret keyboard shortcuts if the focus is on a control in the control grid, as the text entered may be directed
// to the controls within it. That is, if a textbox or combo box has the focus, then take no as this is normal text input
// and NOT a shortcut key. Similarly, if a menu is displayed keys should be directed to the menu rather than interpreted as
// shortcuts.
if (forceSendToMainWindow == false && this.SendKeyToDataEntryControlOrMenu(currentKey))
{
return;
}
// Finally, test for other shortcut keys and take the appropriate action as needed
DirectionEnum direction;
int keyRepeatCount = this.State.GetKeyRepeatCount(currentKey);
switch (currentKey.Key)
{
case Key.B: // Save a Bookmark of the current pan / zoom level of the image
this.MarkableCanvas.SetBookmark();
break;
case Key.Escape:
this.TrySetKeyboardFocusToMarkableCanvas(false, currentKey);
break;
case Key.OemPlus: // Restore the zoom level / pan coordinates of the bookmark
this.MarkableCanvas.ApplyBookmark();
break;
case Key.OemMinus: // Restore the zoom level / pan coordinates of the bookmark
this.MarkableCanvas.ZoomOutAllTheWay();
break;
case Key.M: // Toggle the magnifying glass on and off
this.MenuItemDisplayMagnifyingGlass_Click(this, null);
break;
case Key.U: // Increase the magnifing glass zoom level
this.FilePlayer_Stop(); // In case the FilePlayer is going
this.MarkableCanvas.MagnifierOrOffsetChangeZoomLevel(ZoomDirection.ZoomIn);
break;
case Key.D: // Decrease the magnifing glass zoom level
this.FilePlayer_Stop(); // In case the FilePlayer is going
this.MarkableCanvas.MagnifierOrOffsetChangeZoomLevel(ZoomDirection.ZoomOut);
break;
case Key.Right: // next /previous image
case Key.Left: // previous image
int increment = 1;
this.FilePlayer_Stop(); // In case the FilePlayer is going
direction = currentKey.Key == Key.Right ? DirectionEnum.Next : DirectionEnum.Previous;
if (Keyboard.IsKeyDown(Key.LeftCtrl) || Keyboard.IsKeyDown(Key.LeftCtrl))
{
long currentFileID = this.DataHandler.ImageCache.Current.ID;
bool result = Episodes.GetIncrementToNextEpisode(this.DataHandler.FileDatabase.FileTable, this.DataHandler.FileDatabase.GetFileOrNextFileIndex(currentFileID), direction, out increment);
if (result == true)
{
if (Episodes.ShowEpisodes == false)
{
// turn on Episode display if its not already on
this.EpisodeShowHide(true);
}
// At this point, the episodes should be showing and the increment amount should be reset (see the out parameter above)
}
}
if (currentKey.IsRepeat == false || (currentKey.IsRepeat == true && keyRepeatCount % this.State.Throttles.RepeatedKeyAcceptanceInterval == 0))
{
this.TryFileShowWithoutSliderCallback(direction, increment);
}
break;
case Key.Up: // show visual difference to next image
if (this.IsDisplayingMultipleImagesInOverview())
{
this.FilePlayer.Direction = DirectionEnum.Previous;
this.FilePlayer_ScrollRow();
}
else
{
this.FilePlayer_Stop(); // In case the FilePlayer is going
this.TryViewPreviousOrNextDifference();
}
break;
case Key.Down: // show visual difference to previous image
if (this.IsDisplayingMultipleImagesInOverview())
{
this.FilePlayer.Direction = DirectionEnum.Next;
this.FilePlayer_ScrollRow();
}
else
{
this.FilePlayer_Stop(); // In case the FilePlayer is going
this.TryViewCombinedDifference();
}
break;
case Key.C:
if (this.State.IsViewOnly == false)
{
this.CopyPreviousValues_Click();
}
break;
case Key.E:
this.MenuItemEpisodeShowHide_Click(null, null);
break;
case Key.Q:
// Toggle the QuickPaste window
if (this.quickPasteWindow == null || (this.quickPasteWindow.Visibility != Visibility.Visible))
{
if (this.State.IsViewOnly == false)
{
this.QuickPasteWindowShow();
}
}
else
{
this.QuickPasteWindowHide();
}
break;
case Key.Tab:
this.FilePlayer_Stop(); // In case the FilePlayer is going
this.MoveFocusToNextOrPreviousControlOrCopyPreviousButton(Keyboard.Modifiers == ModifierKeys.Shift);
break;
case Key.PageDown:
case Key.PageUp:
direction = currentKey.Key == Key.PageDown ? DirectionEnum.Next : DirectionEnum.Previous;
if (this.IsDisplayingMultipleImagesInOverview())
{
this.FilePlayer.Direction = direction;
this.FilePlayer_ScrollPage();
}
else
{
this.FilePlayer_Stop(); // In case the FilePlayer is going
if (currentKey.IsRepeat == false || (currentKey.IsRepeat == true && keyRepeatCount % this.State.Throttles.RepeatedKeyAcceptanceInterval == 0))
{
this.TryFileShowWithoutSliderCallback(direction);
}
}
break;
case Key.Home:
case Key.End:
{
this.DataGridPane.IsActive = true;
break;
}
default:
return;
}
if (currentKey != null)
{
currentKey.Handled = true;
}
}
/// <summary>
///
/// </summary>
/// <param name="key"></param>
/// <param name="isGlobal"></param>
/// <returns>True if the key down event is handled</returns>
public bool HandleKeyDown(Key key, bool isGlobal)
{
if (MainTextBox.Focusable || !CaptureKeyboard || (isGlobal && !ReceiveGlobalKeystrokes))
{
return(false);
}
bool handled = true;
if (key == Key.Down)
{
SpeedForward();
}
else if (key == Key.Up)
{
SpeedReverse();
}
else if (key == Key.Tab)
{
ToggleTools();
}
//Slide forward / page down button To work with Logitech PowerPoint remote
else if (key == Key.Next)
{
//PageDown();
SpeedForward();
}
//Slid back button / page up To work with Logitech PowerPoint remote
else if (key == Key.Prior)
{
//PageUp();
SpeedReverse();
}
//F5 To work with Logitech PowerPoint remote
else if (key == Key.F5 ||
key == Key.MediaStop ||
key == Key.MediaPlayPause ||
key == Key.Escape ||
key == Key.Space)
{
PauseScrolling();
}
//Period To work with Logitech PowerPoint remote
else if (key == Key.OemPeriod)
{
ScrollToTop();
}
else if (key == Key.MediaPreviousTrack)
{
PageUp();
}
else if (key == Key.MediaNextTrack)
{
PageDown();
}
else if (key == Key.OemPlus)
{
SpeedSliderValue += 0.1;
}
else if (key == Key.OemMinus)
{
SpeedSliderValue -= 0.1;
}
//Numbers 1-9 should jump to the corresponding bookmark
else if ((key >= Key.D0 && key <= Key.D9) ||
(key >= Key.NumPad0 && key <= Key.NumPad9))
{
var converter = new KeyConverter();
string val = converter.ConvertToString(key);
JumpToBookmarkByOrdinal(int.Parse(val));
//To allow text boxes to get numbers
handled = false;
}
else if (key == Key.F1)
{
LoadRandomBibleChapter();
}
else if (key == Key.Insert)
{
InsertBookmarkAtCurrentEyelineMark();
}
else
{
handled = false;
}
return(handled);
}
public UserDocumentView()
{
_oKeyConverter = new KeyConverter();
InitializeComponent();
}
static ViSDGlobalCount()
{
_number = 0;
KeyConv = new KeyConverter();
}
private void InitlializeShortucts()
{
// shortcuts dictionary
_shortcuts = new Dictionary <Tuple <Key, ModifierKeys>, Action>();
// key converters
var keyConverter = new KeyConverter();
var modifiersKeyConverter = new ModifierKeysConverter();
// open shortcut
_shortcuts.Add(
new Tuple <Key, ModifierKeys>(
(Key)keyConverter.ConvertFromString("O"),
(ModifierKeys)modifiersKeyConverter.ConvertFromString("Control")),
() => Open());
// save shortcut
_shortcuts.Add(
new Tuple <Key, ModifierKeys>(
(Key)keyConverter.ConvertFromString("S"),
(ModifierKeys)modifiersKeyConverter.ConvertFromString("Control")),
() => Save());
// export shortcut
_shortcuts.Add(
new Tuple <Key, ModifierKeys>(
(Key)keyConverter.ConvertFromString("E"),
(ModifierKeys)modifiersKeyConverter.ConvertFromString("Control")),
() => Export());
// undo shortcut
_shortcuts.Add(
new Tuple <Key, ModifierKeys>(
(Key)keyConverter.ConvertFromString("Z"),
(ModifierKeys)modifiersKeyConverter.ConvertFromString("Control")),
() => _view.Undo());
// redo shortcut
_shortcuts.Add(
new Tuple <Key, ModifierKeys>(
(Key)keyConverter.ConvertFromString("Y"),
(ModifierKeys)modifiersKeyConverter.ConvertFromString("Control")),
() => _view.Redo());
// snap shortcut
_shortcuts.Add(
new Tuple <Key, ModifierKeys>(
(Key)keyConverter.ConvertFromString("S"),
ModifierKeys.None),
() => _view.ToggleSnap());
// clear shortcut
_shortcuts.Add(
new Tuple <Key, ModifierKeys>(
(Key)keyConverter.ConvertFromString("Delete"),
(ModifierKeys)modifiersKeyConverter.ConvertFromString("Control")),
() => _view.Clear());
// editor shortcuts
foreach (var editor in _view.Editors)
{
var _editor = editor;
_shortcuts.Add(
new Tuple <Key, ModifierKeys>(
(Key)keyConverter.ConvertFromString(editor.Key),
editor.Modifiers == "" ? ModifierKeys.None : (ModifierKeys)modifiersKeyConverter.ConvertFromString(editor.Modifiers)),
() => _view.Enable(_editor));
}
// block shortcut
_shortcuts.Add(
new Tuple <Key, ModifierKeys>(
(Key)keyConverter.ConvertFromString("G"),
ModifierKeys.None),
() => _view.CreateBlock());
// delete shortcut
_shortcuts.Add(
new Tuple <Key, ModifierKeys>(
(Key)keyConverter.ConvertFromString("Delete"),
ModifierKeys.None),
() => _view.Delete());
}
public static string KeyToUniCode(int keyCode)
{
KeyConverter kc = new KeyConverter();
return(kc.ConvertToString(keyCode).ToUpper());
}
public static void Main(string[] имяФайла)
{
var conv = new KeyConverter();
var cult = CultureInfo.GetCultureInfo("ru");
var s = conv.ConvertToString(null, CultureInfo.GetCultureInfo("ru"), Key.A);
//var sru =
//var k = conv.ConvertFromString("ф");
Хранилище.Типы.Add(typeof(Выходное_устройство));
Хранилище.Типы.Add(typeof(Входное_устройство));
Хранилище.Типы.Add(typeof(АПереадресация));
Хранилище.Типы.Add(typeof(АссинхроннаяПереадресация));
Хранилище.Типы.Add(typeof(ДобавитьВХранилище));
Хранилище.ПересчитатьКодыТипов();
//ДисковоеХранилище.Тест();
if (имяФайла.Length != 0)
{
try
{
Хранилище.Восстановить(имяФайла[0]);
}
catch
{
MessageBox.Show(" Не удалось восстановить диспетчер");
}
}
else
{
//var сервер = new Сервер_хранилища();
var адресРегистратра = Хранилище.Добавить(new егистраторАдресов());// регистратор по 0 адресу
СтрокаЮникода.Создать("место хранения");
СтрокаЮникода.Создать("Имя");
Хранилище.Добавить(new АдресВХранилище());
var словарь = new СловарьПлохой();
словарь.Добавить(new СтрокаЮникода()
{
Значение = "ключ"
}, new СтрокаЮникода()
{
Значение = "значение"
});
словарь.Добавить(new СтрокаЮникода()
{
Значение = "ключ2"
}, new СтрокаЮникода()
{
Значение = "значение2"
});
Хранилище.Добавить(словарь);
var группа = new ГруппаОбъектов();
Хранилище.Добавить(группа);
группа.Добавить(new АдресВХранилище()
{
НомерВХранилище = 1
});
группа.Добавить(new АдресВХранилище()
{
НомерВХранилище = 2
});
группа.Добавить(new СтрокаЮникода()
{
Значение = "строка добавленая в группу"
});
//var тспсервер = new ТСПСвязьВходящая();
//тспсервер.Старт();
var гр = new ГруппаОбъектов();
Хранилище.Добавить(гр);
var Группа2 = new ГруппаАдресовИзСловаря();
Группа2.Перечисление = Клавиатура.ЮНИКОДСимволКодыРусскихБуквПрописные;
гр.Добавить(Группа2);
гр.Добавить(new АдресВХранилище()
{
НомерВХранилище = 1
});
гр.Добавить(new АдресВГруппе()
{
НомерВГруппе = 12
});
гр.Добавить(new СтрокаЮникода()
{
Значение = "строка из группы"
});
гр.Добавить(new Пустота());
var гр2 = new ГруппаОбъектов();
гр.Добавить(гр2);
гр2.Добавить(new СтрокаЮникода()
{
Значение = "строка из группы"
});
гр2.Добавить(new Пустота());
гр2.Добавить(new СтрокаЮникода()
{
Значение = "строка из группы"
});
Dictionary <Type, Type> видыОбъектов = new Dictionary <Type, Type>()
{
[typeof(ГруппаОбъектов)] = typeof(ВидГруппаОбъектов),
[typeof(СтрокаЮникода)] = typeof(ВидСтрока),
[typeof(Символ)] = typeof(ВидСимвола),
[typeof(ГруппаАдресовИзСловаря)] = typeof(ВидГруппаГоризонтальная),
[typeof(ПроксиОбъекта)] = typeof(ВидЗначениеАдреса)
};
var окноГруппы = new ВидОкно();
окноГруппы.ВыборВидов = видыОбъектов; // объекты должны иметь свободные слоты, которые добавляются из справочника по мере надобности, ненужные не создаются похоже на список переменных в блоке кода
окноГруппы.ДобавьСодержание(гр);
окноГруппы.Показать();
var вывод = new Выходное_устройство()
{
Имя = new СтрокаЮникода("Окно Вывода полученого текста")
};
var адресВывод = Хранилище.Добавить(вывод);
var адресСвязиВывод = вывод.ДобавьСвязь(new Связь()
{
ольУдаленного = "поставщик", ТипСвязи = "входящая", ИмяСвязи = "Связь входящая выводного окна"
});
вывод.Запуск();
var переадресация = new АссинхроннаяПереадресация();
var адреспере = Хранилище.Добавить(переадресация);
var адресСвязиПере = переадресация.ДобавьСвязь(new Связь()
{
ольУдаленного = "поставщик", ТипСвязи = "входящая"
});
переадресация.ДобавьСвязь(new Связь()
{
ольУдаленного = "получатель", ТипСвязи = "исходящая",
});
var адресдВХ = Хранилище.Добавить(new ДобавитьВХранилище());
var ввод = new Входное_устройство();
var адресввода = Хранилище.Добавить(ввод);
ввод.Запуск();
var удалЦелое1 = new Активность();
}
var a = new Application();
w = new ОкноХранилища();
var ff = new DependencyObject();
ff.SetValue(Control.BackgroundProperty, Brushes.LightBlue);
var ht = ff.GetValue(Control.BackgroundProperty);
a.Run(w);
// после завершение приложеня
}
private void OnUserKeyboardPress(object sender, KeyEventArgs e)
{
idletime = 0;
if ((int)e.KeyCode == ActivateKey)
{
MacroActivate = true;
if (testing)
{
string name = WindowManager.GetActiveWindowTitle();
string exe = WindowManager.GetActiveWindowExename();
TopMostMessageBox.Show(
String.Format(Translations.Get("window_info_result_text"), name, exe),
Translations.Get("window_info_result_title"));
testing = false;
}
}
switch (e.KeyCode)
{
case System.Windows.Forms.Keys.LShiftKey:
case System.Windows.Forms.Keys.RShiftKey:
case System.Windows.Forms.Keys.Shift:
case System.Windows.Forms.Keys.ShiftKey:
shift = true;
break;
}
while (PressedKeys.Contains(e.KeyCode))
{
PressedKeys.Remove(e.KeyCode);
}
PressedKeys.Add(e.KeyCode);
if (KeyHelper.Form_Visible)
{
KeyHelper.BoxContent += KeyConverter.WinFormKey2Name(e.KeyCode) + "\n";
e.Handled = true;
}
else if (ProceedRewriteMacros(e.KeyCode))
{
e.Handled = true;
}
//Handle french ^ and ¨ key modifiers: êâôëü
if ((int)e.KeyCode == 221 && !circumflex)
{
circumflex = true;
e.Handled = true;
if (shift)
{
diaeresis = true;
}
}
else if (circumflex && !circumflexOn)
{
circumflexOn = true;
switch (e.KeyCode)
{
case (System.Windows.Forms.Keys) 221:
circumflex = false;
diaeresis = false;
if (diaeresis)
{
KeySender.KeyPress(KeyConverter.Name2Key("Shift"));
KeySender.KeyStroke(KeySender.VkKeyScan('^'));
KeySender.KeyStroke(KeySender.VkKeyScan('^'));
KeySender.KeyRelease(KeyConverter.Name2Key("Shift"));
}
else
{
KeySender.KeyStroke(KeySender.VkKeyScan('^'));
KeySender.KeyStroke(KeySender.VkKeyScan('^'));
}
break;
case System.Windows.Forms.Keys.A:
case System.Windows.Forms.Keys.E:
case System.Windows.Forms.Keys.I:
case System.Windows.Forms.Keys.O:
case System.Windows.Forms.Keys.U:
case System.Windows.Forms.Keys.Y:
if (diaeresis)
{
KeySender.KeyPress(KeyConverter.Name2Key("Shift"));
KeySender.KeyStroke(KeySender.VkKeyScan('^'));
KeySender.KeyRelease(KeyConverter.Name2Key("Shift"));
}
else
{
KeySender.KeyStroke(KeySender.VkKeyScan('^'));
}
circumflex = false;
diaeresis = false;
break;
default:
circumflex = false;
diaeresis = false;
break;
}
circumflexOn = false;
}
}
/// <summary>
/// Process pressed keys.
/// </summary>
/// <param name="sender">Sender object.</param>
/// <param name="e">KeyEventArgs.</param>
private void Window_KeyDown(object sender, KeyEventArgs e)
{
bool shiftPressed = (Keyboard.Modifiers & ModifierKeys.Shift) == ModifierKeys.Shift;
// print number
if (!shiftPressed && Utils.IsNumericKey(e.Key))
{
KeyConverter keyConverter = new KeyConverter();
this.outputProcessor.PrintNumber(keyConverter.ConvertToString(e.Key));
}
// print decimal separator (comma)
if (!shiftPressed && (e.Key == Key.Decimal || e.Key == Key.OemComma || e.Key == Key.OemPeriod))
{
this.outputProcessor.PrintComma();
}
// calculate result
if (e.Key == Key.Enter || e.Key == Key.Return || !shiftPressed && e.Key == Key.OemPlus)
{
this.mathProcessor.CalculateResult(this.GetNumericAns(), false, true);
}
// remove last number
if (e.Key == Key.Back)
{
this.outputProcessor.Backspace();
}
// sum
if (e.Key == Key.Add || shiftPressed && e.Key == Key.OemPlus)
{
this.mathProcessor.ProcessSum(this.GetNumericAns());
}
// sub
if (e.Key == Key.Subtract || !shiftPressed && e.Key == Key.OemMinus)
{
this.mathProcessor.ProcessSub(this.GetNumericAns());
}
// mult
if (e.Key == Key.Multiply || shiftPressed && e.Key == Key.D8)
{
this.mathProcessor.ProcessMult(this.GetNumericAns());
}
// div
if (e.Key == Key.Divide || !shiftPressed && e.Key == Key.OemQuestion)
{
this.mathProcessor.ProcessDiv(this.GetNumericAns());
}
// fact
if (shiftPressed && e.Key == Key.D1)
{
this.mathProcessor.ProcessFact(this.GetNumericAns());
}
// pow
if (shiftPressed && e.Key == Key.D6)
{
this.mathProcessor.ProcessPow(this.GetNumericAns());
}
}
private void CustomActionTextKeyDown(object sender, KeyEventArgs e)
{
string displayVal = null;
string sendVal = null;
switch (e.Key)
{
case Key.LeftAlt:
case Key.RightAlt:
case Key.System:
displayVal = "Alt";
sendVal = "%";
break;
case Key.LeftCtrl:
case Key.RightCtrl:
displayVal = "Ctrl";
sendVal = "^";
break;
case Key.LeftShift:
case Key.RightShift:
displayVal = "Shift";
sendVal = "+";
break;
case Key.Back:
displayVal = "Backspace";
sendVal = "{BACKSPACE}";
break;
// There seems to be a bug with caps lock that causes SendWait to enter caps lock twice so it doesn't do anything
//case Key.Capital:
// displayVal = "Caps Lock";
// sendVal = "{CAPSLOCK}";
// break;
case Key.Delete:
displayVal = "Delete";
sendVal = "{DELETE}";
break;
case Key.End:
displayVal = "End";
sendVal = "{END}";
break;
case Key.Escape:
displayVal = "ESC";
sendVal = "{ESC}";
break;
case Key k when k >= Key.F1 && k <= Key.F16:
displayVal = k.ToString();
sendVal = "{" + displayVal + "}";
break;
case Key.Home:
displayVal = "Home";
sendVal = "{HOME}";
break;
case Key.Oem1:
displayVal = ";";
sendVal = ";";
break;
case Key.Oem3:
displayVal = "`";
sendVal = "`";
break;
case Key.Oem5:
displayVal = @"\";
sendVal = @"\";
break;
case Key.Oem6:
displayVal = "]";
sendVal = "{]}";
break;
case Key.OemComma:
displayVal = ",";
sendVal = ",";
break;
case Key.OemMinus:
displayVal = "-";
sendVal = "-";
break;
case Key.OemOpenBrackets:
displayVal = "[";
sendVal = "{[}";
break;
case Key.OemPeriod:
displayVal = ".";
sendVal = ".";
break;
case Key.OemPlus:
displayVal = "+";
sendVal = "+";
break;
case Key.OemQuestion:
displayVal = "/";
sendVal = "/";
break;
case Key.OemQuotes:
displayVal = "'";
sendVal = "'";
break;
case Key.Pause:
displayVal = "Break";
sendVal = "{BREAK}";
break;
case Key.PageDown:
displayVal = "Page Down";
sendVal = "{PGDN}";
break;
case Key.PageUp:
displayVal = "Page Up";
sendVal = "{PGUP}";
break;
case Key.Return:
displayVal = "Enter/Return";
sendVal = "{ENTER}";
break;
// There seems to be a bug with space that causes SendWait to enter space until it stack overflows
//case Key.Space:
// displayVal = "Space";
// sendVal = " ";
// break;
case Key.Tab:
displayVal = "Tab";
sendVal = "{TAB}";
break;
default:
if ((e.Key >= Key.A && e.Key <= Key.Z) || (e.Key >= Key.D0 && e.Key <= Key.D9))
{
KeyConverter keyConverter = new KeyConverter();
displayVal = keyConverter.ConvertToString(e.Key);
sendVal = keyConverter.ConvertToString(e.Key).ToLower();
}
break;
}
if (openAppCheckBox.IsChecked == false && displayVal != null && sendVal != null)
{
if (customActionText.Text == "Enter Keyboard Shortcut")
{
customActionText.Text = displayVal;
customActionText.Tag = sendVal;
savePermanentButton.IsEnabled = true;
saveNewActionButton.IsEnabled = true;
}
else if (customActionText.Text.Count(x => x == '+') < 2)
{
customActionText.Text = customActionText.Text + "+" + displayVal;
customActionText.Tag = (string)customActionText.Tag + sendVal;
}
e.Handled = true;
}
}
private void button1_Click(object sender, EventArgs e)
{
//get the key
if (String.IsNullOrEmpty(textBox1.Text))
{
return;
}
KeyConverter k = new KeyConverter();
Key key = (Key)k.ConvertFromString(textBox1.Text);
//hotkey type
string sType = comboBox1.SelectedItem.ToString();
int count = bot.GetHotkeys().Count;
string hotkeyID = Convert.ToString(count + 1);
Hotkey hotkey;
string slot;
switch (sType)
{
case "Use item on yourself":
hotkey = new Hotkey(hotkeyID, textBox1.Text, HotkeyType.UseOnYourself);
hotkey.ItemId = BotUtil.Number(textBox2.Text);
if (hotkey.ItemId < 0)
{
return;
}
//add from grid
this.dataGridView1.Rows.Add(hotkeyID, textBox1.Text, "Use item on yourself", textBox2.Text, "");
bot.AddHotkey(hotkey);
break;
case "Use item on target":
hotkey = new Hotkey(hotkeyID, textBox1.Text, HotkeyType.UseOnTarget);
hotkey.ItemId = BotUtil.Number(textBox2.Text);
if (hotkey.ItemId < 0)
{
return;
}
//add from grid
this.dataGridView1.Rows.Add(hotkeyID, textBox1.Text, "Use item on target", textBox2.Text, "");
bot.AddHotkey(hotkey);
break;
case "Use with crosshairs":
hotkey = new Hotkey(hotkeyID, textBox1.Text, HotkeyType.UseWithCrosshairs);
hotkey.ItemId = BotUtil.Number(textBox2.Text);
if (hotkey.ItemId < 0)
{
return;
}
//add from grid
this.dataGridView1.Rows.Add(hotkeyID, textBox1.Text, "Use with crosshairs", textBox2.Text, "");
bot.AddHotkey(hotkey);
break;
case "Use item":
hotkey = new Hotkey(hotkeyID, textBox1.Text, HotkeyType.UseItem);
hotkey.ItemId = BotUtil.Number(textBox2.Text);
if (hotkey.ItemId < 0)
{
return;
}
//add from grid
this.dataGridView1.Rows.Add(hotkeyID, textBox1.Text, "Use item", textBox2.Text, "");
bot.AddHotkey(hotkey);
break;
case "Equip item":
hotkey = new Hotkey(hotkeyID, textBox1.Text, HotkeyType.EquipItem);
hotkey.ItemId = BotUtil.Number(textBox2.Text);
if (hotkey.ItemId < 0)
{
return;
}
//add from grid
slot = comboBox2.SelectedItem.ToString();
this.dataGridView1.Rows.Add(hotkeyID, textBox1.Text, "Equip item", textBox2.Text, slot);
hotkey.InventoryLocation = getInventoryLocationByString(slot);
bot.AddHotkey(hotkey);
break;
case "Unequip item":
hotkey = new Hotkey(hotkeyID, textBox1.Text, HotkeyType.UnequipItem);
//add from grid
slot = comboBox2.SelectedItem.ToString();
this.dataGridView1.Rows.Add(hotkeyID, textBox1.Text, "Unequip item", "", slot);
hotkey.InventoryLocation = getInventoryLocationByString(slot);
bot.AddHotkey(hotkey);
break;
}
textBox1.Clear();
}
// 热键注册/响应
private void RegisterHotKey()
{
var kc = new KeyConverter();
var mkc = new ModifierKeysConverter();
try
{
if (Settings.Default.hotKeyModQ != "" && Settings.Default.hotKeyQ != "")
{
ModifierKeys mod = (ModifierKeys)mkc.ConvertFromString(Settings.Default.hotKeyModQ);
Key key = (Key)kc.ConvertFromString(Settings.Default.hotKeyQ);
HotKeyManage.Register(key, mod);
}
else
{
HotKeyManage.Register(Key.Q, ModifierKeys.Control);
Settings.Default.hotKeyModQ = mkc.ConvertToString(ModifierKeys.Control);
Settings.Default.hotKeyQ = kc.ConvertToString(Key.Q);
}
Mvvm.HotKeyQ = HotKeyManage.ToString();
}
catch (Exception err)
{
MessageBox.Show(err.ToString());
Mvvm.HotKeyQ = HotKeyManage.ToString() + "(冲突)";
}
//////////////////////////////////////////////////
try
{
if (Settings.Default.hotKeyModW != "" && Settings.Default.hotKeyW != "")
{
ModifierKeys mod = (ModifierKeys)mkc.ConvertFromString(Settings.Default.hotKeyModW);
Key key = (Key)kc.ConvertFromString(Settings.Default.hotKeyW);
HotKeyManage.Register(key, mod);
}
else
{
HotKeyManage.Register(Key.W, ModifierKeys.Control);
Settings.Default.hotKeyModW = mkc.ConvertToString(ModifierKeys.Control);
Settings.Default.hotKeyW = kc.ConvertToString(Key.W);
}
Mvvm.HotKeyW = HotKeyManage.ToString();
}
catch (Exception err)
{
MessageBox.Show(err.ToString());
Mvvm.HotKeyW = HotKeyManage.ToString() + "(冲突)";
}
//////////////////////////////////////////////////
try
{
if (Settings.Default.hotKeyModB != "" && Settings.Default.hotKeyB != "")
{
ModifierKeys mod = (ModifierKeys)mkc.ConvertFromString(Settings.Default.hotKeyModB);
Key key = (Key)kc.ConvertFromString(Settings.Default.hotKeyB);
HotKeyManage.Register(key, mod);
}
else
{
HotKeyManage.Register(Key.B, ModifierKeys.Control);
Settings.Default.hotKeyModB = mkc.ConvertToString(ModifierKeys.Control);
Settings.Default.hotKeyB = kc.ConvertToString(Key.B);
}
Mvvm.HotKeyB = HotKeyManage.ToString();
}
catch (Exception err)
{
MessageBox.Show(err.ToString());
Mvvm.HotKeyB = HotKeyManage.ToString() + "(冲突)";
}
//////////////////////////////////////////////////
try
{
if (Settings.Default.hotKeyModG != "" && Settings.Default.hotKeyG != "")
{
ModifierKeys mod = (ModifierKeys)mkc.ConvertFromString(Settings.Default.hotKeyModG);
Key key = (Key)kc.ConvertFromString(Settings.Default.hotKeyG);
HotKeyManage.Register(key, mod);
}
else
{
HotKeyManage.Register(Key.G, ModifierKeys.Control);
Settings.Default.hotKeyModG = mkc.ConvertToString(ModifierKeys.Control);
Settings.Default.hotKeyG = kc.ConvertToString(Key.G);
}
Mvvm.HotKeyG = HotKeyManage.ToString();
}
catch (Exception err)
{
MessageBox.Show(err.ToString());
Mvvm.HotKeyG = HotKeyManage.ToString() + "(冲突)";
}
Settings.Default.Save();
}
private void TreeView_Keydown(object sender, KeyEventArgs e)
{
var selected = TreeFolderBrowser.SelectedItem as PathItem;
// this works without a selection
if (e.Key == Key.F2 && Keyboard.IsKeyDown(Key.LeftShift))
{
if (selected == null || !selected.IsEditing)
{
FolderBrowserContextMenu.MenuAddFile_Click(sender, null);
e.Handled = true;
}
return;
}
if (e.Key == Key.F8)
{
if (selected == null || !selected.IsEditing)
{
FolderBrowserContextMenu.MenuAddDirectory_Click(sender, null);
e.Handled = true;
}
}
if (selected == null)
{
return;
}
if (e.Key == Key.Enter || e.Key == Key.Tab)
{
if (!selected.IsEditing)
{
HandleItemSelection(forceEditorFocus: true);
}
else
{
RenameOrCreateFileOrFolder();
}
e.Handled = true;
}
else if (e.Key == Key.Escape)
{
if (selected.IsEditing)
{
selected.IsEditing = false;
if (!string.IsNullOrEmpty(selected.OriginalRenamePath))
{
selected.FullPath = selected.OriginalRenamePath;
selected.OriginalRenamePath = null;
}
else
{
selected.Parent?.Files?.Remove(selected);
}
}
}
else if (e.Key == Key.F2)
{
if (!selected.IsEditing)
{
FolderBrowserContextMenu.MenuRenameFile_Click(sender, null);
}
}
else if (e.Key == Key.Delete)
{
if (!selected.IsEditing)
{
FolderBrowserContextMenu.MenuDeleteFile_Click(sender, null);
}
}
else if (e.Key == Key.G && Keyboard.IsKeyDown(Key.LeftCtrl))
{
if (!selected.IsEditing)
{
FolderBrowserContextMenu.MenuCommitGit_Click(null, null);
e.Handled = true;
}
}
else if (e.Key == Key.Z && Keyboard.IsKeyDown(Key.LeftCtrl))
{
if (!selected.IsEditing)
{
FolderBrowserContextMenu.MenuUndoGit_Click(null, null);
e.Handled = true;
}
}
if (selected.IsEditing)
{
return;
}
// search key
if (e.Key >= Key.A && e.Key <= Key.Z ||
e.Key >= Key.D0 && e.Key <= Key.D9 ||
e.Key == Key.OemPeriod ||
e.Key == Key.Space ||
e.Key == Key.Separator ||
e.Key == Key.OemMinus &&
(!Keyboard.IsKeyDown(Key.LeftCtrl) && !Keyboard.IsKeyDown(Key.LeftAlt)))
{
//Debug.WriteLine("Treeview TreeDown: " + e.Key + " shfit: " + Keyboard.IsKeyDown(Key.LeftShift));
var keyConverter = new KeyConverter();
string k;
if (e.Key == Key.OemPeriod)
{
k = ".";
}
else if (e.Key == Key.OemMinus && Keyboard.IsKeyDown(Key.LeftShift))
{
k = "_";
}
else if (e.Key == Key.OemMinus)
{
k = "-";
}
else if (e.Key == Key.Space)
{
k = " ";
}
else
{
k = keyConverter.ConvertToString(e.Key);
}
if (searchFilterLast > DateTime.Now.AddSeconds(-1.2))
{
searchFilter += k.ToLower();
}
else
{
searchFilter = k.ToLower();
}
Window.ShowStatus("File search filter: " + searchFilter, 2000);
var lowerFilter = searchFilter.ToLower();
var parentPath = selected.Parent;
if (parentPath == null)
{
parentPath = ActivePathItem; // root
}
var item = parentPath.Files.FirstOrDefault(sf => sf.DisplayName.ToLower().StartsWith(lowerFilter));
if (item != null)
{
item.IsSelected = true;
}
searchFilterLast = DateTime.Now;
}
}
public ComplexInputGestureConverter()
{
_keyConverter = new KeyConverter();
_modifierKeysConverter = new ModifierKeysConverter();
}
internal bool RunEvents()
{
while (SDL.SDL_PollEvent(out var e) != 0)
{
Key k;
// ReSharper disable once SwitchStatementMissingSomeCases
switch (e.type)
{
case SDL.SDL_EventType.SDL_QUIT:
return(false);
case SDL.SDL_EventType.SDL_MOUSEWHEEL:
Mouse.ScrollY += e.wheel.y * 120;
Mouse.ScrollX += e.wheel.x * 120;
break;
case SDL.SDL_EventType.SDL_MOUSEBUTTONDOWN:
if (e.button.button == SDL.SDL_BUTTON_LEFT)
{
Mouse.LeftButton = true;
}
else if (e.button.button == SDL.SDL_BUTTON_RIGHT)
{
Mouse.RightButton = true;
}
else if (e.button.button == SDL.SDL_BUTTON_MIDDLE)
{
Mouse.MiddleButton = true;
}
else if (e.button.button == SDL.SDL_BUTTON_X1)
{
Mouse.XButton1 = true;
}
else if (e.button.button == SDL.SDL_BUTTON_X2)
{
Mouse.XButton2 = true;
}
break;
case SDL.SDL_EventType.SDL_MOUSEBUTTONUP:
if (e.button.button == SDL.SDL_BUTTON_LEFT)
{
Mouse.LeftButton = false;
}
else if (e.button.button == SDL.SDL_BUTTON_RIGHT)
{
Mouse.RightButton = false;
}
else if (e.button.button == SDL.SDL_BUTTON_MIDDLE)
{
Mouse.MiddleButton = false;
}
else if (e.button.button == SDL.SDL_BUTTON_X1)
{
Mouse.XButton1 = false;
}
else if (e.button.button == SDL.SDL_BUTTON_X2)
{
Mouse.XButton2 = false;
}
break;
case SDL.SDL_EventType.SDL_APP_LOWMEMORY:
MessageBox.Show("Low Memory", "The program is running low on memory, please close some programs.", MessageBoxType.Warning);
break;
case SDL.SDL_EventType.SDL_WINDOWEVENT:
// ReSharper disable once SwitchStatementMissingSomeCases
switch (e.window.windowEvent)
{
case SDL.SDL_WindowEventID.SDL_WINDOWEVENT_FOCUS_GAINED:
_parentGame.OnActivated?.Invoke(_parentGame, EventArgs.Empty);
break;
case SDL.SDL_WindowEventID.SDL_WINDOWEVENT_FOCUS_LOST:
_parentGame.OnDeactivated?.Invoke(_parentGame, EventArgs.Empty);
break;
case SDL.SDL_WindowEventID.SDL_WINDOWEVENT_RESIZED:
_parentGame.OnResize?.Invoke(_parentGame,
new Game.OnResizeEventArgs(_parentGame.Window.Bounds));
var width = _parentGame.Window.Bounds.Width;
var height = _parentGame.Window.Bounds.Height;
//OpenGL Viewport
GL.Viewport(0, 0, width, height);
break;
}
break;
case SDL.SDL_EventType.SDL_MOUSEMOTION:
_parentGame.Window.MouseState.X = e.motion.x;
_parentGame.Window.MouseState.Y = e.motion.y;
break;
case SDL.SDL_EventType.SDL_KEYDOWN:
k = KeyConverter.ToKey((int)e.key.keysym.sym);
if (!_parentGame.Keys.Contains(k))
{
_parentGame.Keys.Add(k);
}
Keyboard.KeyPressed.Invoke(_parentGame, new Keyboard.KeyEventArgs(k));
break;
case SDL.SDL_EventType.SDL_KEYUP:
k = KeyConverter.ToKey((int)e.key.keysym.sym);
while (_parentGame.Keys.Contains(k))
{
_parentGame.Keys.Remove(k);
}
Keyboard.KeyReleased.Invoke(_parentGame, new Keyboard.KeyEventArgs(k));
break;
}
}
return(true);
}
private void EditInputBinding(MenuItem menu, ModifierKeys modifier) {
KeyConverter k = new KeyConverter();
Key key = (Key)k.ConvertFromString(menu.InputGestureText);
InputBindingCollection InputBindingsCopy = new InputBindingCollection(InputBindings);
foreach (KeyBinding item in InputBindingsCopy) {
if (item.Key == key) {
if (modifier == ModifierKeys.None)
InputBindings.Remove(item);
else {
item.Modifiers = modifier;
if (modifier == ModifierKeys.Control)
menu.InputGestureText = "CTRL+" + menu.InputGestureText;
}
break;
}
}
}
