/// <summary>
/// Gets the individual key that was pressed in the given key stroke without any modifier flags.
/// </summary>
/// <param name="keyStroke">The key stroke from which the pressed key is to be extracted.</param>
/// <param name="control">True if the <see cref="XKeys.Control"/> modifier was pressed; False otherwise.</param>
/// <param name="alt">True if the <see cref="XKeys.Alt"/> modifier was pressed; False otherwise.</param>
/// <param name="shift">True if the <see cref="XKeys.Shift"/> modifier was pressed; False otherwise.</param>
/// <returns>A single value from the <see cref="XKeys"/> enumeration excluding
/// <see cref="XKeys.Control"/>, <see cref="XKeys.Alt"/> and <see cref="XKeys.Shift"/> (i.e. not a bitwise combination).</returns>
protected static XKeys GetKeyPressed(XKeys keyStroke, out bool control, out bool alt, out bool shift)
{
control = IsKeyPressModifiedByControl(keyStroke);
alt = IsKeyPressModifiedByAlt(keyStroke);
shift = IsKeyPressModifiedByShift(keyStroke);
return(GetKeyPressed(keyStroke));
}
public void TestEmptyStringParse()
{
// empty strings should parse to XKeys.None
XKeys keyCode = (XKeys)_converter.ConvertFromString(string.Empty);
Assert.AreEqual(XKeys.None, keyCode, "empty strings should parse to XKeys.None");
}
public void TestSpecialCase()
{
// test special case where the key separator is a key name on its own
const string message = "Special Case";
const XKeys key = XKeys.OemPlus;
CultureInfo culture = _dummyCulture;
string actualKeyName = XKeysConverter.KeySeparator.ToString();
AssertEquivalency(string.Format("{0}", actualKeyName), (XKeys)key, culture, message);
AssertEquivalency(string.Format("Control+{0}", actualKeyName), XKeys.Control | (XKeys)key, culture, message);
AssertEquivalency(string.Format("Alt+{0}", actualKeyName), XKeys.Alt | (XKeys)key, culture, message);
AssertEquivalency(string.Format("Shift+{0}", actualKeyName), XKeys.Shift | (XKeys)key, culture, message);
AssertEquivalency(string.Format("Control+Alt+{0}", actualKeyName), XKeys.Control | XKeys.Alt | (XKeys)key, culture, message);
AssertEquivalency(string.Format("Alt+Shift+{0}", actualKeyName), XKeys.Alt | XKeys.Shift | (XKeys)key, culture, message);
AssertEquivalency(string.Format("Control+Shift+{0}", actualKeyName), XKeys.Control | XKeys.Shift | (XKeys)key, culture, message);
AssertEquivalency(string.Format("Control+Alt+Shift+{0}", actualKeyName), XKeys.Control | XKeys.Alt | XKeys.Shift | (XKeys)key, culture, message);
AssertStringParse(string.Format("{0} ", actualKeyName), (XKeys)key, culture, message);
AssertStringParse(string.Format(" {0}", actualKeyName), (XKeys)key, culture, message);
AssertStringParse(string.Format(" {0} ", actualKeyName), (XKeys)key, culture, message);
AssertStringParse(string.Format("Control + {0}", actualKeyName), XKeys.Control | (XKeys)key, culture, message);
AssertStringParse(string.Format("Control+ {0}", actualKeyName), XKeys.Control | (XKeys)key, culture, message);
AssertStringParse(string.Format("{0}+Control", actualKeyName), XKeys.Control | (XKeys)key, culture, message);
AssertStringParse(string.Format("{0} +Control", actualKeyName), XKeys.Control | (XKeys)key, culture, message);
AssertStringParse(string.Format("Alt+{0}+Control", actualKeyName), XKeys.Control | XKeys.Alt | (XKeys)key, culture, message);
AssertStringParse(string.Format("Alt+{0} +Control", actualKeyName), XKeys.Control | XKeys.Alt | (XKeys)key, culture, message);
AssertStringParse(string.Format("Alt+ {0}+Control", actualKeyName), XKeys.Control | XKeys.Alt | (XKeys)key, culture, message);
AssertStringParse(string.Format("Alt+ {0} +Control", actualKeyName), XKeys.Control | XKeys.Alt | (XKeys)key, culture, message);
}
/// <summary>
/// Tests whether or not a given key combination is a valid key stroke by invoking the <see cref="ValidateKeyStroke"/> event.
/// </summary>
/// <param name="keyStroke">The key combination to be tested.</param>
/// <returns>True if the key combination is a valid key stroke; False otherwise.</returns>
protected bool IsValidKeyStroke(XKeys keyStroke)
{
ValidateKeyStrokeEventArgs e = new ValidateKeyStrokeEventArgs(keyStroke);
this.OnValidateKeyStroke(e);
return(e.IsValid);
}
public void TestInvariantKeyCombos()
{
// test combining keys with modifiers in the invariant case
const string message = "Invariant Combinations";
CultureInfo culture = CultureInfo.InvariantCulture;
foreach (string keyName in Enum.GetNames(typeof(XKeys)))
{
switch (keyName)
{
case "Modifiers":
case "KeyCode":
case "None":
case "Control":
case "Shift":
case "Alt":
// these aren't real keys anyway
continue;
}
XKeys key = (XKeys)Enum.Parse(typeof(XKeys), keyName);
string actualKeyName = _converter.ConvertToString(null, culture, key);
AssertEquivalency(string.Format("Ctrl+{0}", actualKeyName), XKeys.Control | (XKeys)key, culture, message);
AssertEquivalency(string.Format("Alt+{0}", actualKeyName), XKeys.Alt | (XKeys)key, culture, message);
AssertEquivalency(string.Format("Shift+{0}", actualKeyName), XKeys.Shift | (XKeys)key, culture, message);
AssertEquivalency(string.Format("Ctrl+Alt+{0}", actualKeyName), XKeys.Control | XKeys.Alt | (XKeys)key, culture, message);
AssertEquivalency(string.Format("Alt+Shift+{0}", actualKeyName), XKeys.Alt | XKeys.Shift | (XKeys)key, culture, message);
AssertEquivalency(string.Format("Ctrl+Shift+{0}", actualKeyName), XKeys.Control | XKeys.Shift | (XKeys)key, culture, message);
AssertEquivalency(string.Format("Ctrl+Alt+Shift+{0}", actualKeyName), XKeys.Control | XKeys.Alt | XKeys.Shift | (XKeys)key, culture, message);
}
}
private void AssertStringFormat(string sKeys, XKeys eKeys, CultureInfo culture, string message)
{
string actualString = _converter.ConvertToString(null, culture, eKeys);
//System.Diagnostics.Trace.WriteLine(actualString);
Assert.AreEqual(sKeys, actualString, message + ": converting " + (int)eKeys + " which is " + eKeys.ToString());
}
private void AssertStringParse(string sKeys, XKeys eKeys, CultureInfo culture, string message)
{
XKeys actualEnum = (XKeys)_converter.ConvertFromString(null, culture, sKeys);
//System.Diagnostics.Trace.WriteLine(actualEnum);
Assert.AreEqual((int)eKeys, (int)actualEnum, message + ": converting " + sKeys + " which is " + actualEnum.ToString());
}
private void HandleTextBoxKeyDown(object sender, KeyEventArgs e)
{
XKeys keyData = Convert(e.KeyData);
e.Handled = true;
e.SuppressKeyPress = true;
// if control is read-only, ignore any user input
if (this.ReadOnly)
{
return;
}
if (!_keyStrokeAccepted)
{
this.UpdateText(keyData);
}
XKeys key = GetKeyPressed(keyData);
if (key != XKeys.None && !_currentKeys.Contains(key))
{
_currentKeys.Add(key);
}
}
/// <summary>
/// Formats a key stroke as a human-readable string.
/// </summary>
/// <remarks>
/// The default implementation separates modifiers from the key pressed,
/// translates each modifier/key individually using <see cref="GetKeyName"/>,
/// and combines them together using <see cref="KeySeparator"/>.
/// A trailing <see cref="KeySeparator"/> is shown if this particular key stroke
/// is not valid as determined by <see cref="IsValidKeyStroke"/>.
/// A key stroke of <see cref="XKeys.None"/> is formatted as an empty string.
/// </remarks>
/// <param name="keyStroke">The key stroke to be formatted.</param>
/// <returns>A human-readable string representing the key stroke.</returns>
protected virtual string FormatKeyStroke(XKeys keyStroke)
{
if (keyStroke == 0)
{
return(string.Empty);
}
bool control, alt, shift;
bool valid = IsValidKeyStroke(keyStroke);
XKeys key = GetKeyPressed(keyStroke, out control, out alt, out shift);
List <string> keys = new List <string>(4);
if (control)
{
keys.Add(GetKeyName(XKeys.Control));
}
if (alt)
{
keys.Add(GetKeyName(XKeys.Alt));
}
if (shift)
{
keys.Add(GetKeyName(XKeys.Shift));
}
// display a trailing '+' if the keystroke is invalid
keys.Add(valid ? GetKeyName(key) : string.Empty);
return(string.Join(_keySeparator ?? string.Empty, keys.ToArray()));
}
public void TestInvalidCastToXKeys()
{
try
{
XKeys keys = (XKeys) new XMouseButtonCombo(XMouseButtons.Left | XMouseButtons.Right, ModifierFlags.None);
Assert.Fail("Casting a multi-button combo as an XKeys should be invalid");
}
catch (InvalidCastException) {}
}
public void Load(XmlElement e)
{
foreach (var item in e)
{
if (item.Name == "XKeys")
{
XmlElement keys = item[KeyframeDataCollection.ElementName];
if (keys != null)
{
XKeys.Load(keys);
}
}
else if (item.Name == "YKeys")
{
XmlElement keys = item[KeyframeDataCollection.ElementName];
if (keys != null)
{
YKeys.Load(keys);
}
}
else if (item.Name == "ZKeys")
{
XmlElement keys = item[KeyframeDataCollection.ElementName];
if (keys != null)
{
ZKeys.Load(keys);
}
}
if (item.Name == "RXKeys")
{
XmlElement keys = item[KeyframeDataCollection.ElementName];
if (keys != null)
{
RXKeys.Load(keys);
}
}
else if (item.Name == "RYKeys")
{
XmlElement keys = item[KeyframeDataCollection.ElementName];
if (keys != null)
{
RYKeys.Load(keys);
}
}
else if (item.Name == "RZKeys")
{
XmlElement keys = item[KeyframeDataCollection.ElementName];
if (keys != null)
{
RZKeys.Load(keys);
}
}
}
}
public void TestInvalidMultipleKeyWithModifierStringParse()
{
try
{
// multiple non-modifier keys are also not allowed as you can't represent that using the flags enumeration
XKeys keyCode = (XKeys)_converter.ConvertFromString("Alt+A+Enter");
Assert.Fail("Expected an exception because you can't have multiple non-modifier keys");
}
catch (FormatException) {}
}
public void TestInvalidKeyLeadingSeparatorStringParse()
{
try
{
// on the other hand, invalid key strings should throw exceptions during conversion
XKeys keyCode = (XKeys)_converter.ConvertFromString("+Alt");
Assert.Fail("Expected an exception because of a leading separator in the parse string");
}
catch (FormatException) {}
}
public void TestInvalidKeyWithModifiersStringParse()
{
try
{
// on the other hand, invalid key strings should throw exceptions during conversion
XKeys keyCode = (XKeys)_converter.ConvertFromString("Ctrl+NonExistentKey+Alt");
Assert.Fail("Expected an exception because the parsed string has an invalid key name");
}
catch (FormatException) {}
}
public void TestInvalidStringParse()
{
try
{
// on the other hand, invalid key strings should throw exceptions during conversion
XKeys keyCode = (XKeys)_converter.ConvertFromString("\n");
Assert.Fail("Expected an exception because the parsed string has an invalid character");
}
catch (FormatException) {}
}
/// <summary>
/// Raises the <see cref="ValidateKeyStroke"/> event.
/// </summary>
/// <param name="e">A <see cref="ValidateKeyStrokeEventArgs"/> that contains the event data.</param>
protected virtual void OnValidateKeyStroke(ValidateKeyStrokeEventArgs e)
{
XKeys key = GetKeyPressed(e.KeyStroke);
e.IsValid = !(key == XKeys.ControlKey || key == XKeys.AltKey || key == XKeys.ShiftKey);
if (_validateKeyStrokeEventHandler != null)
{
_validateKeyStrokeEventHandler.Invoke(this, e);
}
}
// Is key pressed
public bool isKeyPressed(XKeys key)
{
int keyCode = (int)key;
bool result = !_keysChecked[keyCode] && _keysPressed[keyCode];
if (_keysPressed[keyCode])
{
_keysChecked[keyCode] = true;
}
return(result);
}
private XMouseEventArgs ConvertToXMouseEventArgs(uint gdkButton, Gdk.EventType type, Gdk.ModifierType state, double x, double y)
{
XMouseButtons mb = XMouseButtons.None;
switch (gdkButton)
{
case 1:
mb = XMouseButtons.Left;
break;
case 2:
mb = XMouseButtons.Middle;
break;
case 3:
mb = XMouseButtons.Right;
break;
}
int clickCount = 0;
switch (type)
{
case Gdk.EventType.ButtonPress:
clickCount = 1;
break;
case Gdk.EventType.TwoButtonPress:
clickCount = 2;
break;
case Gdk.EventType.ThreeButtonPress:
clickCount = 3;
break;
}
XKeys modifiers = XKeys.None;
if ((state & Gdk.ModifierType.ShiftMask) != 0)
{
modifiers |= XKeys.Shift;
}
if ((state & Gdk.ModifierType.ControlMask) != 0)
{
modifiers |= XKeys.Control;
}
if ((state & Gdk.ModifierType.Mod1Mask) != 0)
{ // ALT key
modifiers |= XKeys.Alt;
}
return(new XMouseEventArgs(mb, clickCount, (int)x, (int)y, 0, modifiers));
}
private static string GetKeyName(XKeys key, IDictionary <XKeys, string> map)
{
if (map.ContainsKey(key))
{
return(map[key]);
}
else if (Enum.IsDefined(typeof(XKeys), (int)key))
{
return(Enum.GetName(typeof(XKeys), (int)key));
}
return(string.Empty);
}
public void TestStringParseWhitespaceIndifference()
{
// whitespace between individual keys in the string should not matter
XKeys keyCode = (XKeys)_converter.ConvertFromString("Ctrl\t +Attn \t+Alt");
Assert.AreEqual(XKeys.Control | XKeys.Alt | XKeys.Attn, keyCode, "Whitespace between key string elements should not matter");
keyCode = (XKeys)_converter.ConvertFromString("Ctrl+ \tAlt+ Attn");
Assert.AreEqual(XKeys.Control | XKeys.Alt | XKeys.Attn, keyCode, "Whitespace between key string elements should not matter");
keyCode = (XKeys)_converter.ConvertFromString("Attn + \t Ctrl\t+ Alt");
Assert.AreEqual(XKeys.Control | XKeys.Alt | XKeys.Attn, keyCode, "Whitespace between key string elements should not matter");
}
public void TestStringParseOrderIndifference()
{
// ordering of individual keys in the string should not matter
XKeys keyCode = (XKeys)_converter.ConvertFromString("Ctrl+Attn+Alt");
Assert.AreEqual(XKeys.Control | XKeys.Alt | XKeys.Attn, keyCode, "Order of key string elements should not matter");
keyCode = (XKeys)_converter.ConvertFromString("Ctrl+Alt+Attn");
Assert.AreEqual(XKeys.Control | XKeys.Alt | XKeys.Attn, keyCode, "Order of key string elements should not matter");
keyCode = (XKeys)_converter.ConvertFromString("Attn+Ctrl+Alt");
Assert.AreEqual(XKeys.Control | XKeys.Alt | XKeys.Attn, keyCode, "Order of key string elements should not matter");
}
/// <summary>
/// Parses a string as an <see cref="XKeys"/> value using the specified <see cref="CultureInfo"/>.
/// </summary>
/// <param name="s">The string to be parsed.</param>
/// <param name="culture">The <see cref="CultureInfo"/> for which the string should be parsed.</param>
/// <param name="result">The <see cref="XKeys"/> value parsed from <paramref name="s"/> if the string was successfully parsed; <see cref="XKeys.None"/> otherwise.</param>
/// <returns>True if the string was successfully parsed; False otherwise.</returns>
public static bool TryParse(string s, CultureInfo culture, out XKeys result)
{
try
{
result = Parse(s, culture);
return(true);
}
catch (FormatException)
{
result = XKeys.None;
return(false);
}
}
/// <summary>
/// 检测当前被按下的键值
/// Enum.GetValues (https://msdn.microsoft.com/zh-cn/library/system.enum.getvalues.aspx)
/// typeof (https://docs.microsoft.com/zh-cn/dotnet/csharp/language-reference/keywords/typeof)
/// </summary>
/// <returns></returns>
private XKeys GetCurDownKey()
{
XKeys vKey = XKeys.None;
foreach (Int32 key in Enum.GetValues(typeof(XKeys)))
{
if (isKeyDown((XKeys)key))
{
vKey = (XKeys)key;
break;
}
}
return(vKey);
}
public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType)
{
if (destinationType == typeof(string))
{
List <string> keyNames = new List <string>(4);
XKeys keyValue = (XKeys)value;
IDictionary <XKeys, string> map = GetKeyNamesMap(culture);
if ((keyValue & XKeys.Control) == XKeys.Control)
{
string modifierName = GetKeyName(XKeys.Control, map);
if (!string.IsNullOrEmpty(modifierName))
{
keyNames.Add(modifierName);
}
}
if ((keyValue & XKeys.Alt) == XKeys.Alt)
{
string modifierName = GetKeyName(XKeys.Alt, map);
if (!string.IsNullOrEmpty(modifierName))
{
keyNames.Add(modifierName);
}
}
if ((keyValue & XKeys.Shift) == XKeys.Shift)
{
string modifierName = GetKeyName(XKeys.Shift, map);
if (!string.IsNullOrEmpty(modifierName))
{
keyNames.Add(modifierName);
}
}
if ((keyValue & XKeys.KeyCode) != XKeys.None)
{
string keyName = GetKeyName(keyValue & XKeys.KeyCode, map);
if (!string.IsNullOrEmpty(keyName))
{
keyNames.Add(keyName);
}
}
if (keyNames.Count == 0)
{
return(string.Empty);
}
return(string.Join(KeySeparator.ToString(), keyNames.ToArray()));
}
return(base.ConvertTo(context, culture, value, destinationType));
}
public XmlElement ToXmlElement()
{
XmlElement rootMotion = new XmlElement(ElementName);
if (XKeys.Count > 0)
{
XmlElement xKeys = new XmlElement("XKeys");
xKeys.AppendChild(XKeys.ToXmlElement());
rootMotion.AppendChild(xKeys);
}
if (YKeys.Count > 0)
{
XmlElement yKeys = new XmlElement("YKeys");
yKeys.AppendChild(YKeys.ToXmlElement());
rootMotion.AppendChild(yKeys);
}
if (ZKeys.Count > 0)
{
XmlElement zKeys = new XmlElement("ZKeys");
zKeys.AppendChild(ZKeys.ToXmlElement());
rootMotion.AppendChild(zKeys);
}
if (RXKeys.Count > 0)
{
XmlElement rxKeys = new XmlElement("RXKeys");
rxKeys.AppendChild(RXKeys.ToXmlElement());
rootMotion.AppendChild(rxKeys);
}
if (RYKeys.Count > 0)
{
XmlElement ryKeys = new XmlElement("RYKeys");
ryKeys.AppendChild(RYKeys.ToXmlElement());
rootMotion.AppendChild(ryKeys);
}
if (RZKeys.Count > 0)
{
XmlElement rzKeys = new XmlElement("RZKeys");
rzKeys.AppendChild(RZKeys.ToXmlElement());
rootMotion.AppendChild(rzKeys);
}
return(rootMotion);
}
/// <remarks>
/// A reference implementation for ToString taken originally from GetTooltipTest(IClickAction) of
/// ClearCanvas.Desktop.View.WinForms/ActiveToolbarButton.cs/r12907.
/// This method now uses XKeysConverter, which is why we compare our results
/// against this reference implementation.
/// </remarks>
private static string ReferenceToStringImplementation(XKeys keyStroke)
{
bool ctrl = (keyStroke & XKeys.Control) == XKeys.Control;
bool alt = (keyStroke & XKeys.Alt) == XKeys.Alt;
bool shift = (keyStroke & XKeys.Shift) == XKeys.Shift;
XKeys keyCode = keyStroke & XKeys.KeyCode;
StringBuilder builder = new StringBuilder();
if (keyCode != XKeys.None)
{
if (ctrl)
{
builder.Append("Ctrl");
}
if (alt)
{
if (ctrl)
{
builder.Append("+");
}
builder.Append("Alt");
}
if (shift)
{
if (ctrl || alt)
{
builder.Append("+");
}
builder.Append("Shift");
}
if (ctrl || alt || shift)
{
builder.Append("+");
}
builder.Append(XKeysConverter.FormatInvariant(keyCode));
}
return(builder.ToString());
}
public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
{
if (value is string)
{
string stringValue = (string)value;
if (string.IsNullOrEmpty(stringValue))
{
return(XKeys.None);
}
Match m = _keyStringParser.Match((string)value);
if (!m.Success)
{
throw new FormatException(string.Format("Input string was not in the expected format for {0}", typeof(XKeys).FullName));
}
XKeys modifiers = XKeys.None;
XKeys keyCode = XKeys.None;
IDictionary <string, XKeys> map = GetKeyValuesMap(culture);
for (int n = 1; n <= 4; n++)
{
if (m.Groups[n].Length == 0)
{
break;
}
XKeys keyValue = GetKeyValue(m.Groups[n].Value, map);
if ((keyValue & XKeys.Modifiers) > 0)
{
modifiers |= keyValue;
}
else if ((keyValue & XKeys.KeyCode) > 0)
{
if (keyCode != XKeys.None)
{
throw new FormatException(string.Format("Values for {0} may have only one non-modifier key.", typeof(XKeys).FullName));
}
keyCode = keyValue;
}
}
return(modifiers | keyCode);
}
return(base.ConvertFrom(context, culture, value));
}
private void HandleCheckBoxCheckedChanged(object sender, EventArgs e)
{
if (!_updatingCheckBoxChecked)
{
XKeys keyModifiers = XKeys.None;
if (_checkBoxCtrl.Checked)
{
keyModifiers |= XKeys.Control;
}
if (_checkBoxAlt.Checked)
{
keyModifiers |= XKeys.Alt;
}
if (_checkBoxShift.Checked)
{
keyModifiers |= XKeys.Shift;
}
this.KeyModifiers = keyModifiers;
}
}
public void KeyboardEventsHandler()
{
XKeyboardEventArgs e;
XKeys xKeyDown = GetCurDownKey();
if (xKeyDown != XKeys.None)
{
// 有新的按键被按下
this.m_oldKey = xKeyDown;
e = new XKeyboardEventArgs(xKeyDown);
this.OnKeyDown(e);
}
else if (this.m_oldKey != XKeys.None && !isKeyDown(this.m_oldKey))
{
// 有旧的按键被释放
e = new XKeyboardEventArgs(this.m_oldKey);
this.OnKeyUp(e);
this.m_oldKey = XKeys.None;
}
}
private void DeserializeGroupPresets(PresetVoiLutCollection presets, XmlNodeList presetNodes)
{
foreach (XmlElement presetNode in presetNodes)
{
string keyStrokeAttribute = presetNode.GetAttribute("keystroke");
XKeys keyStroke = XKeys.None;
if (!String.IsNullOrEmpty(keyStrokeAttribute))
{
keyStroke = (XKeys)_xkeysConverter.ConvertFromInvariantString(keyStrokeAttribute);
}
string factoryName = presetNode.GetAttribute("factory");
IPresetVoiLutOperationFactory factory = PresetVoiLutOperationFactories.GetFactory(factoryName);
if (factory == null)
{
continue;
}
PresetVoiLutConfiguration configuration = PresetVoiLutConfiguration.FromFactory(factory);
XmlNodeList configurationItems = presetNode.SelectNodes("configuration/item");
foreach (XmlElement configurationItem in configurationItems)
{
configuration[configurationItem.GetAttribute("key")] = configurationItem.GetAttribute("value");
}
try
{
IPresetVoiLutOperation operation = factory.Create(configuration);
PresetVoiLut preset = new PresetVoiLut(operation);
preset.KeyStroke = keyStroke;
presets.Add(preset);
}
catch (Exception e)
{
Platform.Log(LogLevel.Error, e);
continue;
}
}
}
/// <summary>
/// Maps a single key value to an appropriate key name.
/// </summary>
/// <remarks>
/// <para>
/// The default implementation uses an <see cref="XKeysConverter"/>.
/// </para>
/// </remarks>
/// <param name="key">A single value from the <see cref="XKeys"/> enumeration.</param>
/// <returns>The key name for the given key.</returns>
protected virtual string GetKeyName(XKeys key)
{
return TypeDescriptor.GetConverter(typeof (XKeys)).ConvertToString(key);
}
/// <summary>
/// Constructor.
/// </summary>
public KeyboardButtonMessage(XKeys keyData, ButtonActions buttonAction)
{
_buttonAction = buttonAction;
_buttonShortcut = new KeyboardButtonShortcut(keyData);
}
/// <summary>
/// Formats a <see cref="XKeys"/> value as a string using the <see cref="CultureInfo.InvariantCulture"/>.
/// </summary>
/// <param name="value">The <see cref="XKeys"/> value to be formatted.</param>
/// <returns>The string representation of the given <paramref name="value"/>.</returns>
public static string FormatInvariant(XKeys value)
{
return Format(value, CultureInfo.InvariantCulture);
}
public AbstractClickAction(string id, string path)
: base(id, path)
{
_keyStroke = XKeys.None;
}
public KeyModifiersFlagPropertyDescriptor(XKeys modifier)
: base(typeof (XKeys), Enum.GetName(typeof (XKeys), modifier), typeof (bool))
{
_modifier = modifier;
}
/// <summary>
/// Gets the individual key that was pressed in the given key stroke without any modifier flags.
/// </summary>
/// <param name="keyStroke">The key stroke from which the pressed key is to be extracted.</param>
/// <returns>A single value from the <see cref="XKeys"/> enumeration excluding
/// <see cref="XKeys.Control"/>, <see cref="XKeys.Alt"/> and <see cref="XKeys.Shift"/> (i.e. not a bitwise combination).</returns>
protected static XKeys GetKeyPressed(XKeys keyStroke)
{
return (keyStroke & ~XKeys.Modifiers);
}
/// <summary>
/// Tests whether or not a given key combination is a valid key stroke by invoking the <see cref="ValidateKeyStroke"/> event.
/// </summary>
/// <param name="keyStroke">The key combination to be tested.</param>
/// <returns>True if the key combination is a valid key stroke; False otherwise.</returns>
protected bool IsValidKeyStroke(XKeys keyStroke)
{
ValidateKeyStrokeEventArgs e = new ValidateKeyStrokeEventArgs(keyStroke);
this.OnValidateKeyStroke(e);
return e.IsValid;
}
/// <summary>
/// Tests whether or not a given key stroke is modified by the <see cref="XKeys.Alt"/> modifier key.
/// </summary>
/// <param name="keyStroke">The key stroke to be tested.</param>
/// <returns>True if the key stroke is modified by <see cref="XKeys.Alt"/>; False otherwise.</returns>
protected static bool IsKeyPressModifiedByAlt(XKeys keyStroke)
{
return (keyStroke & XKeys.Alt) == XKeys.Alt;
}
public CachedKey(XKeys Sym, bool Shift)
: this((uint)Sym, Shift) {
}
/// <summary>
/// Parses a string as an <see cref="XKeys"/> value using the specified <see cref="CultureInfo"/>.
/// </summary>
/// <param name="s">The string to be parsed.</param>
/// <param name="culture">The <see cref="CultureInfo"/> for which the string should be parsed.</param>
/// <param name="result">The <see cref="XKeys"/> value parsed from <paramref name="s"/> if the string was successfully parsed; <see cref="XKeys.None"/> otherwise.</param>
/// <returns>True if the string was successfully parsed; False otherwise.</returns>
public static bool TryParse(string s, CultureInfo culture, out XKeys result)
{
try
{
result = Parse(s, culture);
return true;
}
catch (FormatException)
{
result = XKeys.None;
return false;
}
}
/// <summary>
/// Parses a string as an <see cref="XKeys"/> value using the <see cref="CultureInfo.InvariantCulture"/>.
/// </summary>
/// <param name="s">The string to be parsed.</param>
/// <param name="result">The <see cref="XKeys"/> value parsed from <paramref name="s"/> if the string was successfully parsed; <see cref="XKeys.None"/> otherwise.</param>
/// <returns>True if the string was successfully parsed; False otherwise.</returns>
public static bool TryParseInvariant(string s, out XKeys result)
{
return TryParse(s, CultureInfo.InvariantCulture, out result);
}
/// <summary>
/// Formats a <see cref="XKeys"/> value as a string using the <see cref="CultureInfo.CurrentUICulture">current thread's UI CultureInfo</see>.
/// </summary>
/// <param name="value">The <see cref="XKeys"/> value to be formatted.</param>
/// <returns>The string representation of the given <paramref name="value"/>.</returns>
public static string Format(XKeys value)
{
return Format(value, CultureInfo.CurrentUICulture);
}
/// <summary>
/// Constructor.
/// </summary>
public KeyboardButtonDownPreview(XKeys keyData)
{
_buttonShortcut = new KeyboardButtonShortcut(keyData);
}
/// <summary>
/// Tests whether or not a given key stroke is modified by one or more of the modifier keys
/// (<see cref="XKeys.Control"/>, <see cref="XKeys.Alt"/> and <see cref="XKeys.Shift"/>).
/// </summary>
/// <param name="keyStroke">The key stroke to be tested.</param>
/// <returns>True if the key stroke is modified; False otherwise.</returns>
protected static bool IsKeyPressModified(XKeys keyStroke)
{
return (keyStroke & XKeys.Modifiers) != 0;
}
/// <summary>
/// Formats a key stroke as a human-readable string.
/// </summary>
/// <remarks>
/// The default implementation separates modifiers from the key pressed,
/// translates each modifier/key individually using <see cref="GetKeyName"/>,
/// and combines them together using <see cref="KeySeparator"/>.
/// A trailing <see cref="KeySeparator"/> is shown if this particular key stroke
/// is not valid as determined by <see cref="IsValidKeyStroke"/>.
/// A key stroke of <see cref="XKeys.None"/> is formatted as an empty string.
/// </remarks>
/// <param name="keyStroke">The key stroke to be formatted.</param>
/// <returns>A human-readable string representing the key stroke.</returns>
protected virtual string FormatKeyStroke(XKeys keyStroke)
{
if (keyStroke == 0)
return string.Empty;
bool control, alt, shift;
bool valid = IsValidKeyStroke(keyStroke);
XKeys key = GetKeyPressed(keyStroke, out control, out alt, out shift);
List<string> keys = new List<string>(4);
if (control)
keys.Add(GetKeyName(XKeys.Control));
if (alt)
keys.Add(GetKeyName(XKeys.Alt));
if (shift)
keys.Add(GetKeyName(XKeys.Shift));
// display a trailing '+' if the keystroke is invalid
keys.Add(valid ? GetKeyName(key) : string.Empty);
return string.Join(_keySeparator ?? string.Empty, keys.ToArray());
}
/// <summary>
/// Initializes a new instance of <see cref="ValidateKeyStrokeEventArgs"/>.
/// </summary>
/// <param name="keyStroke">The key stroke which is to be validated.</param>
public ValidateKeyStrokeEventArgs(XKeys keyStroke)
{
this.KeyStroke = keyStroke;
this.IsValid = true;
}
/// <summary>
/// Gets the individual key that was pressed in the given key stroke without any modifier flags.
/// </summary>
/// <param name="keyStroke">The key stroke from which the pressed key is to be extracted.</param>
/// <param name="control">True if the <see cref="XKeys.Control"/> modifier was pressed; False otherwise.</param>
/// <param name="alt">True if the <see cref="XKeys.Alt"/> modifier was pressed; False otherwise.</param>
/// <param name="shift">True if the <see cref="XKeys.Shift"/> modifier was pressed; False otherwise.</param>
/// <returns>A single value from the <see cref="XKeys"/> enumeration excluding
/// <see cref="XKeys.Control"/>, <see cref="XKeys.Alt"/> and <see cref="XKeys.Shift"/> (i.e. not a bitwise combination).</returns>
protected static XKeys GetKeyPressed(XKeys keyStroke, out bool control, out bool alt, out bool shift)
{
control = IsKeyPressModifiedByControl(keyStroke);
alt = IsKeyPressModifiedByAlt(keyStroke);
shift = IsKeyPressModifiedByShift(keyStroke);
return GetKeyPressed(keyStroke);
}
/// <summary>
/// Parses a string as an <see cref="XKeys"/> value using the <see cref="CultureInfo.CurrentUICulture">current thread's UI CultureInfo</see>.
/// </summary>
/// <param name="s">The string to be parsed.</param>
/// <param name="result">The <see cref="XKeys"/> value parsed from <paramref name="s"/> if the string was successfully parsed; <see cref="XKeys.None"/> otherwise.</param>
/// <returns>True if the string was successfully parsed; False otherwise.</returns>
public static bool TryParse(string s, out XKeys result)
{
return TryParse(s, CultureInfo.CurrentUICulture, out result);
}
/// <summary>
/// Tests whether or not a given key stroke is modified by the <see cref="XKeys.Shift"/> modifier key.
/// </summary>
/// <param name="keyStroke">The key stroke to be tested.</param>
/// <returns>True if the key stroke is modified by <see cref="XKeys.Shift"/>; False otherwise.</returns>
protected static bool IsKeyPressModifiedByShift(XKeys keyStroke)
{
return (keyStroke & XKeys.Shift) == XKeys.Shift;
}
private static string GetKeyName(XKeys key, IDictionary<XKeys, string> map)
{
if (map.ContainsKey(key))
return map[key];
else if (Enum.IsDefined(typeof (XKeys), (int) key))
return Enum.GetName(typeof (XKeys), (int) key);
return string.Empty;
}
/// <summary>
/// Tests whether or not a given key stroke is modified by the <see cref="XKeys.Control"/> modifier key.
/// </summary>
/// <param name="keyStroke">The key stroke to be tested.</param>
/// <returns>True if the key stroke is modified by <see cref="XKeys.Control"/>; False otherwise.</returns>
protected static bool IsKeyPressModifiedByControl(XKeys keyStroke)
{
return (keyStroke & XKeys.Control) == XKeys.Control;
}
private void UpdateText(XKeys keyStroke)
{
base.Text = _textBox.Text = this.FormatKeyStroke(keyStroke);
_textBox.SelectionStart = _textBox.TextLength;
}
/// <summary>
/// Resets the <see cref="KeyStroke"/> property to its default value.
/// </summary>
public virtual void ResetKeyStroke()
{
this.KeyStroke = XKeys.None;
}
public AbstractActionModelTreeLeafClickAction(IClickAction clickAction) : base(clickAction)
{
_keyStroke = clickAction.KeyStroke;
}
/// <remarks>
/// A reference implementation for ToString taken originally from GetTooltipTest(IClickAction) of
/// ClearCanvas.Desktop.View.WinForms/ActiveToolbarButton.cs/r12907.
/// This method now uses XKeysConverter, which is why we compare our results
/// against this reference implementation.
/// </remarks>
private static string ReferenceToStringImplementation(XKeys keyStroke)
{
bool ctrl = (keyStroke & XKeys.Control) == XKeys.Control;
bool alt = (keyStroke & XKeys.Alt) == XKeys.Alt;
bool shift = (keyStroke & XKeys.Shift) == XKeys.Shift;
XKeys keyCode = keyStroke & XKeys.KeyCode;
StringBuilder builder = new StringBuilder();
if (keyCode != XKeys.None)
{
if (ctrl)
builder.Append("Ctrl");
if (alt)
{
if (ctrl)
builder.Append("+");
builder.Append("Alt");
}
if (shift)
{
if (ctrl || alt)
builder.Append("+");
builder.Append("Shift");
}
if (ctrl || alt || shift)
builder.Append("+");
builder.Append(XKeysConverter.FormatInvariant(keyCode));
}
return builder.ToString();
}
public bool IsValidKeyStroke(XKeys keyStroke)
{
return this.RequestValidation("KeyStrokePreview", keyStroke);
}
public AbstractClickAction(IClickAction concreteAction)
: base(concreteAction)
{
_keyStroke = concreteAction.KeyStroke;
}
protected virtual void OnKeyStrokeChanged()
{
this.NotifyItemChanged();
this.Action.KeyStroke = _keyStroke;
}
public AbstractClickAction(string id, string path, IResourceResolver resourceResolver)
: base(id, path, resourceResolver)
{
_keyStroke = XKeys.None;
}
/// <summary>
/// Formats a <see cref="XKeys"/> value as a string using the specified <see cref="CultureInfo"/>.
/// </summary>
/// <param name="value">The <see cref="XKeys"/> value to be formatted.</param>
/// <param name="culture">The <see cref="CultureInfo"/> for which the value should be formatted.</param>
/// <returns>The string representation of the given <paramref name="value"/>.</returns>
public static string Format(XKeys value, CultureInfo culture)
{
return Default.ConvertToString(null, culture, value);
}
