private void KeyModifierCheck(object sender, EventArgs e)
#endif
{
if (CtrlPressed)
{
if (!KeyBoard.IsKeyDown(Key.LeftCtrl) && !KeyBoard.IsKeyDown(Key.RightCtrl))
{
CtrlPressed = false;
}
}
if (ShiftPressed)
{
if (!KeyBoard.IsKeyDown(Key.LeftShift) && !KeyBoard.IsKeyDown(Key.RightShift))
{
ShiftPressed = false;
}
}
if (AltPressed)
{
if (!KeyBoard.IsKeyDown(Key.LeftAlt) && !KeyBoard.IsKeyDown(Key.RightAlt) && !KeyBoard.IsKeyDown(Key.System))
{
AltPressed = false;
}
}
if (!CtrlPressed && !ShiftPressed && !AltPressed)
{
keyCheck.Stop();
}
}
/// <summary>
/// This method handles the list view scrolling keys for the specified dependency object.
/// </summary>
/// <param name="element">Dependency object</param>
/// <param name="e">Key event arguments</param>
/// <remarks>
/// Handled keys: Up, Down, (Ctrl+)PageUp, (Ctrl+)PageDown, Home, End
/// </remarks>
public static void HandleListViewKeyEvents(this DependencyObject element, KeyEventArgs e)
{
var stack = element.GetInnerStackPanel();
if (stack == null)
{
return;
}
var sw = element.GetScrollViewer();
if (sw == null)
{
return;
}
var ctrlPressed = WindowsKeyboard.IsKeyDown(Key.LeftCtrl) || WindowsKeyboard.IsKeyDown(Key.RightCtrl);
var multiplier = ctrlPressed ? 10 : 1;
switch (e.Key)
{
case Key.Up:
sw.ScrollToVerticalOffset(stack.VerticalOffset - 1.0);
e.Handled = true;
break;
case Key.Down:
sw.ScrollToVerticalOffset(stack.VerticalOffset + 1.0);
e.Handled = true;
break;
case Key.PageUp:
sw.ScrollToVerticalOffset(stack.VerticalOffset - stack.ViewportHeight * multiplier);
e.Handled = true;
break;
case Key.PageDown:
sw.ScrollToVerticalOffset(stack.VerticalOffset + stack.ViewportHeight * multiplier);
e.Handled = true;
break;
case Key.Home:
if (ctrlPressed)
{
sw.ScrollToTop();
e.Handled = true;
}
break;
case Key.End:
if (ctrlPressed)
{
sw.ScrollToBottom();
e.Handled = true;
}
break;
}
}
void Editor_PreviewKeyUp(object sender, KeyEventArgs e)
{
switch (e.Key)
{
case Key.Back:
case Key.Delete:
DeleteMissingVisualLabels();
break;
case Key.C:
case Key.V:
case Key.X:
if (Keyboard.IsKeyDown(Key.LeftCtrl) || Keyboard.IsKeyDown(Key.RightCtrl))
{
DeleteMissingVisualLabels();
}
break;
}
}
protected KeyModifiers GetKeyboardModifiers()
{
KeyModifiers mod = KeyModifiers.None;
if (Keyboard.IsKeyDown(Key.LeftCtrl) || Keyboard.IsKeyDown(Key.RightCtrl))
{
mod |= KeyModifiers.Ctrl;
}
if (Keyboard.IsKeyDown(Key.LeftShift) || Keyboard.IsKeyDown(Key.RightShift))
{
mod |= KeyModifiers.Shift;
}
if (Keyboard.IsKeyDown(Key.LeftAlt) || Keyboard.IsKeyDown(Key.RightAlt))
{
mod |= KeyModifiers.Alt;
}
if (Keyboard.IsKeyDown(Key.LWin) || Keyboard.IsKeyDown(Key.RWin))
{
mod |= KeyModifiers.Win;
}
return(mod);
}
// AltNumpad key handler
private bool HandleAltNumpadEntry(Key key, int scanCode, bool isExtendedKey)
{
bool handled = false;
Debug.Assert(_altNumpadEntryMode);
// All Numpad keys (either numlock or not) are not an extended key.
// We're interested in only NumPad key so we can filter them first.
if (isExtendedKey)
{
return(handled);
}
// If Alt key is up, we will quit AltNumpadEntryMode.
if (!Keyboard.IsKeyDown(Key.LeftAlt) && !Keyboard.IsKeyDown(Key.RightAlt))
{
return(false);
}
//
// Windows has historically offered a back-door for entering
// characters that are not available on the keyboard. The
// user can hold down one of the Alt keys, type in the numerical
// value of the desried character using the num-pad keys, and
// the release the Alt key. The numeric value will be converted
// into Unicode, and a text event will
// be raised.
//
if (scanCode == NumpadScanCode.NumpadDot)
{
if (IsHexNumpadEnabled)
{
_altNumpadEntry = 0;
_altNumpadConversionMode = AltNumpadConversionMode.HexDefaultCodePage;
handled = true;
}
else
{
// reset alt numpad entry and mode.
_altNumpadEntry = 0;
_altNumpadConversionMode = AltNumpadConversionMode.OEMCodePage;
handled = false;
}
}
else if (scanCode == NumpadScanCode.NumpadPlus)
{
if (IsHexNumpadEnabled)
{
_altNumpadEntry = 0;
_altNumpadConversionMode = AltNumpadConversionMode.HexUnicode;
handled = true;
}
else
{
// reset alt numpad entry and mode.
_altNumpadEntry = 0;
_altNumpadConversionMode = AltNumpadConversionMode.OEMCodePage;
handled = false;
}
}
else
{
int newEntry = GetNewEntry(key, scanCode);
if (newEntry == -1)
{
_altNumpadEntry = 0;
_altNumpadConversionMode = AltNumpadConversionMode.OEMCodePage;
// we don't handle this case to cancel TextComposition.
handled = false;
}
else
{
// If the first key is NumPad0, it is the default codepage.
if ((_altNumpadEntry == 0) && (newEntry == 0))
{
_altNumpadConversionMode = AltNumpadConversionMode.DefaultCodePage;
}
if (HexConversionMode)
{
_altNumpadEntry = (_altNumpadEntry * 0x10) + newEntry;
}
else
{
_altNumpadEntry = (_altNumpadEntry * 10) + newEntry;
}
handled = true;
}
}
return(handled);
}
public void KeyToChar(Key key, ref IoCmd_t KeyDecode)
{
bool iscap;
//bool caplock;
bool shift;
KeyDecode.key = key;
KeyDecode.alt = Keyboard.IsKeyDown(Key.LeftAlt) ||
Keyboard.IsKeyDown(Key.RightAlt);
KeyDecode.ctrl = Keyboard.IsKeyDown(Key.LeftCtrl) ||
Keyboard.IsKeyDown(Key.RightCtrl);
KeyDecode.shift = Keyboard.IsKeyDown(Key.LeftShift) ||
Keyboard.IsKeyDown(Key.RightShift);
if (KeyDecode.alt || KeyDecode.ctrl)
{
KeyDecode.printable = false;
KeyDecode.type = 1;
}
else
{
KeyDecode.printable = true;
KeyDecode.type = 0;
}
shift = KeyDecode.shift;
//caplock = Console.CapsLock; //Keyboard.IsKeyToggled(Key.CapsLock);
//iscap = (caplock && !shift) || (!caplock && shift);
iscap = false;
switch (key)
{
case Key.Enter: KeyDecode.character = '\n'; return;
case Key.A: KeyDecode.character = (iscap ? 'A' : 'a'); return;
case Key.B: KeyDecode.character = (iscap ? 'B' : 'b'); return;
case Key.C: KeyDecode.character = (iscap ? 'C' : 'c'); return;
case Key.D: KeyDecode.character = (iscap ? 'D' : 'd'); return;
case Key.E: KeyDecode.character = (iscap ? 'E' : 'e'); return;
case Key.F: KeyDecode.character = (iscap ? 'F' : 'f'); return;
case Key.G: KeyDecode.character = (iscap ? 'G' : 'g'); return;
case Key.H: KeyDecode.character = (iscap ? 'H' : 'h'); return;
case Key.I: KeyDecode.character = (iscap ? 'I' : 'i'); return;
case Key.J: KeyDecode.character = (iscap ? 'J' : 'j'); return;
case Key.K: KeyDecode.character = (iscap ? 'K' : 'k'); return;
case Key.L: KeyDecode.character = (iscap ? 'L' : 'l'); return;
case Key.M: KeyDecode.character = (iscap ? 'M' : 'm'); return;
case Key.N: KeyDecode.character = (iscap ? 'N' : 'n'); return;
case Key.O: KeyDecode.character = (iscap ? 'O' : 'o'); return;
case Key.P: KeyDecode.character = (iscap ? 'P' : 'p'); return;
case Key.Q: KeyDecode.character = (iscap ? 'Q' : 'q'); return;
case Key.R: KeyDecode.character = (iscap ? 'R' : 'r'); return;
case Key.S: KeyDecode.character = (iscap ? 'S' : 's'); return;
case Key.T: KeyDecode.character = (iscap ? 'T' : 't'); return;
case Key.U: KeyDecode.character = (iscap ? 'U' : 'u'); return;
case Key.V: KeyDecode.character = (iscap ? 'V' : 'v'); return;
case Key.W: KeyDecode.character = (iscap ? 'W' : 'w'); return;
case Key.X: KeyDecode.character = (iscap ? 'X' : 'x'); return;
case Key.Y: KeyDecode.character = (iscap ? 'Y' : 'y'); return;
case Key.Z: KeyDecode.character = (iscap ? 'Z' : 'z'); return;
case Key.D0: KeyDecode.character = (shift ? ')' : '0'); return;
case Key.D1: KeyDecode.character = (shift ? '!' : '1'); return;
case Key.D2: KeyDecode.character = (shift ? '@' : '2'); return;
case Key.D3: KeyDecode.character = (shift ? '#' : '3'); return;
case Key.D4: KeyDecode.character = (shift ? '$' : '4'); return;
case Key.D5: KeyDecode.character = (shift ? '%' : '5'); return;
case Key.D6: KeyDecode.character = (shift ? '^' : '6'); return;
case Key.D7: KeyDecode.character = (shift ? '&' : '7'); return;
case Key.D8: KeyDecode.character = (shift ? '*' : '8'); return;
case Key.D9: KeyDecode.character = (shift ? '(' : '9'); return;
case Key.OemPlus: KeyDecode.character = (shift ? '+' : '='); return;
case Key.OemMinus: KeyDecode.character = (shift ? '_' : '-'); return;
case Key.OemQuestion: KeyDecode.character = (shift ? '?' : '/'); return;
case Key.OemComma: KeyDecode.character = (shift ? '<' : ','); return;
case Key.OemPeriod: KeyDecode.character = (shift ? '>' : '.'); return;
case Key.OemOpenBrackets: KeyDecode.character = (shift ? '{' : '['); return;
case Key.OemQuotes: KeyDecode.character = (shift ? '"' : '\''); return;
case Key.Oem1: KeyDecode.character = (shift ? ':' : ';'); return;
case Key.Oem3: KeyDecode.character = (shift ? '~' : '`'); return;
case Key.Oem5: KeyDecode.character = (shift ? '|' : '\\'); return;
case Key.Oem6: KeyDecode.character = (shift ? '}' : ']'); return;
case Key.Tab: KeyDecode.character = '\t'; return;
case Key.Space: KeyDecode.character = ' '; return;
// Number Pad
case Key.NumPad0: KeyDecode.character = '0'; return;
case Key.NumPad1: KeyDecode.character = '1'; return;
case Key.NumPad2: KeyDecode.character = '2'; return;
case Key.NumPad3: KeyDecode.character = '3'; return;
case Key.NumPad4: KeyDecode.character = '4'; return;
case Key.NumPad5: KeyDecode.character = '5'; return;
case Key.NumPad6: KeyDecode.character = '6'; return;
case Key.NumPad7: KeyDecode.character = '7'; return;
case Key.NumPad8: KeyDecode.character = '8'; return;
case Key.NumPad9: KeyDecode.character = '9'; return;
case Key.Subtract: KeyDecode.character = '-'; return;
case Key.Add: KeyDecode.character = '+'; return;
case Key.Decimal: KeyDecode.character = '.'; return;
case Key.Divide: KeyDecode.character = '/'; return;
case Key.Multiply: KeyDecode.character = '*'; return;
default:
KeyDecode.type = 1;
KeyDecode.printable = false;
KeyDecode.character = '\x00';
return;
}
}