internal static void RegisterCommandHandler(Type controlType, RoutedCommand command, ExecutedRoutedEventHandler executedRoutedEventHandler,
CanExecuteRoutedEventHandler canExecuteRoutedEventHandler,
InputGesture inputGesture, InputGesture inputGesture2, InputGesture inputGesture3, InputGesture inputGesture4)
{
PrivateRegisterCommandHandler(controlType, command, executedRoutedEventHandler, canExecuteRoutedEventHandler,
inputGesture, inputGesture2, inputGesture3, inputGesture4);
}
/// <summary>
/// Adds the elements of the given collection to the end of this list. If
/// required, the capacity of the list is increased to twice the previous
/// capacity or the new size, whichever is larger.
/// </summary>
/// <param name="collection">collection to append</param>
public void AddRange(ICollection collection)
{
if (IsReadOnly)
{
throw new NotSupportedException(SR.Get(SRID.ReadOnlyInputGesturesCollection));
}
if (collection == null)
{
throw new ArgumentNullException("collection");
}
if (collection.Count > 0)
{
if (_innerGestureList == null)
{
_innerGestureList = new System.Collections.Generic.List <InputGesture>(collection.Count);
}
IEnumerator collectionEnum = collection.GetEnumerator();
while (collectionEnum.MoveNext())
{
InputGesture inputGesture = collectionEnum.Current as InputGesture;
if (inputGesture != null)
{
_innerGestureList.Add(inputGesture);
}
else
{
throw new NotSupportedException(SR.Get(SRID.CollectionOnlyAcceptsInputGestures));
}
}
}
}
public FullscreenCommand(string name, MainWindow wnd, InputGesture inputGesture)
: base(name, inputGesture)
{
this.wnd = wnd;
this.wnd.PreviewKeyDown += wnd_PreviewKeyDown;
this.fullscreenHandler = new FullscreenHandler(wnd);
this.fullscreenHandler.FullscreenChanged += fullscreenHandler_FullscreenChanged;
}
/// <summary>
/// Contains
/// </summary>
/// <param name="key">key</param>
/// <returns>true - if found, false - otherwise</returns>
public bool Contains(InputGesture key)
{
if (_innerGestureList != null && key != null)
{
return(_innerGestureList.Contains(key));
}
return(false);
}
//------------------------------------------------------
//
// Protected Methods
//
//------------------------------------------------------
//------------------------------------------------------
//
// Private Methods
//
//------------------------------------------------------
#region Internal
internal InputGesture FindMatch(object targetElement, InputEventArgs inputEventArgs)
{
for (int i = 0; i < Count; i++)
{
InputGesture inputGesture = this[i];
if (inputGesture.Matches(targetElement, inputEventArgs))
{
return(inputGesture);
}
}
return(null);
}
public InputBinding(ICommand command, InputGesture gesture)
{
if (command == null)
throw new ArgumentNullException("command");
if (gesture == null)
throw new ArgumentNullException("gesture");
// Check before assignment to avoid continuation
CheckSecureCommand(command, gesture);
Command = command;
_gesture = gesture;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="command">Command</param>
/// <param name="gesture">Input Gesture</param>
public InputBinding(ICommand command, InputGesture gesture)
{
if (command == null)
{
throw new ArgumentNullException("command");
}
if (gesture == null)
{
throw new ArgumentNullException("gesture");
}
Command = command;
_gesture = gesture;
}
void CommandTest (RoutedUICommand cmd,
string text, string name, InputGesture[] gestures)
{
Assert.AreEqual (cmd.OwnerType, typeof (ApplicationCommands));
Assert.AreEqual (text, cmd.Text);
Assert.AreEqual (name, cmd.Name);
if (gestures == null) {
Assert.AreEqual (0, cmd.InputGestures.Count);
}
else {
Assert.AreEqual (gestures.Length, cmd.InputGestures.Count);
for (int i = 0; i < gestures.Length; i ++) {
Assert.AreEqual (gestures[i].GetType(), cmd.InputGestures[i].GetType());
}
}
}
/// <summary>
/// Add
/// </summary>
/// <param name="inputGesture"></param>
public int Add(InputGesture inputGesture)
{
if (IsReadOnly)
{
throw new NotSupportedException(SR.Get(SRID.ReadOnlyInputGesturesCollection));
}
if (inputGesture == null)
{
throw new ArgumentNullException("inputGesture");
}
EnsureList();
_innerGestureList.Add(inputGesture);
return(0); // ICollection.Add no longer returns the indice
}
void CheckSecureCommand(ICommand command, InputGesture gesture)
{
// In v3.5, only ApplicationCommands.Paste was treated as ISecureCommand,
// causing the below demand to fail if a binding for it was created. As
// there's no provable security vulnerability and for backwards compat
// reasons, we special-case Cut and Copy not to be subject to this check
// even though they have been promoted to ISecureCommand in v4.0.
ISecureCommand secure = command as ISecureCommand;
if (secure != null &&
command != ApplicationCommands.Cut &&
command != ApplicationCommands.Copy)
{
secure.UserInitiatedPermission.Demand();
}
}
protected BaseCommand(string name, InputGesture inputGesture)
{
this.Name = name;
if (inputGesture != null)
{
this.InputBinding = new System.Windows.Input.InputBinding(this, inputGesture);
if (inputGesture is KeyGesture)
{
var kg = (KeyGesture)inputGesture;
var keyText = keyReplacements.ContainsKey(kg.Key) ? keyReplacements[kg.Key] : kg.Key.ToString();
this.GestureText = modifierText[kg.Modifiers] + keyText;
}
}
}
/// <summary>
/// Indexing operator
/// </summary>
object IList.this[int index]
{
get
{
return(this[index]);
}
set
{
InputGesture inputGesture = value as InputGesture;
if (inputGesture == null)
{
throw new NotSupportedException(SR.Get(SRID.CollectionOnlyAcceptsInputGestures));
}
this[index] = inputGesture;
}
}
/// <summary>
/// Insert
/// </summary>
/// <param name="index">index at which to insert the item</param>
/// <param name="inputGesture">item value to insert</param>
public void Insert(int index, InputGesture inputGesture)
{
if (IsReadOnly)
{
throw new NotSupportedException(SR.Get(SRID.ReadOnlyInputGesturesCollection));
}
if (inputGesture == null)
{
throw new NotSupportedException(SR.Get(SRID.CollectionOnlyAcceptsInputGestures));
}
if (_innerGestureList != null)
{
_innerGestureList.Insert(index, inputGesture);
}
}
/// <summary>
/// Remove
/// </summary>
/// <param name="inputGesture"></param>
public void Remove(InputGesture inputGesture)
{
if (IsReadOnly)
{
throw new NotSupportedException(SR.Get(SRID.ReadOnlyInputGesturesCollection));
}
if (inputGesture == null)
{
throw new ArgumentNullException("inputGesture");
}
if (_innerGestureList != null && _innerGestureList.Contains(inputGesture))
{
_innerGestureList.Remove(inputGesture as InputGesture);
}
}
public InputBinding(ICommand command, InputGesture gesture)
{
if (command == null)
{
throw new ArgumentNullException("command");
}
if (gesture == null)
{
throw new ArgumentNullException("gesture");
}
// Check before assignment to avoid continuation
CheckSecureCommand(command, gesture);
Command = command;
_gesture = gesture;
}
void CheckSecureCommand(ICommand command, InputGesture gesture)
{
// In v3.5, only ApplicationCommands.Paste was treated as ISecureCommand,
// causing the below demand to fail if a binding for it was created. As
// there's no provable security vulnerability and for backwards compat
// reasons, we special-case Cut and Copy not to be subject to this check
// even though they have been promoted to ISecureCommand in v4.0.
//
// See Dev10 bug 815844 on reevaluating the threat model around protection
// of key bindings. The following demand may be unnecessary or misguided.
ISecureCommand secure = command as ISecureCommand;
if (secure != null &&
command != ApplicationCommands.Cut &&
command != ApplicationCommands.Copy)
{
secure.UserInitiatedPermission.Demand();
}
}
/// <summary>
/// Constructor with parameters</summary>
/// <param name="commandTag">Command ID</param>
/// <param name="menuTag">Unique ID for menu command attached to</param>
/// <param name="groupTag">Unique ID for command's group</param>
/// <param name="text">User visible command text, as on menu item</param>
/// <param name="menuPath">String array describing menu path</param>
/// <param name="description">Command description</param>
/// <param name="imageSourceKey">Image resource for command</param>
/// <param name="inputGestures">Sequence of input device gestures to execute command</param>
/// <param name="visibility">Flags indicating where command is visible: on toolbar, menus, etc.</param>
public CommandDef(
object commandTag,
object menuTag,
object groupTag,
string text,
string[] menuPath,
string description,
object imageSourceKey,
InputGesture[] inputGestures,
CommandVisibility visibility)
: this(commandTag, menuTag, groupTag, text, description)
{
ImageSourceKey = imageSourceKey;
if(menuPath != null)
MenuPath = menuPath;
if (inputGestures != null)
InputGestures = inputGestures;
Visibility = visibility;
}
public void CopyTo(InputGesture[] inputGestures, int index)
{
}
public int IndexOf(InputGesture value)
{
return default(int);
}
/// <summary>
/// CopyTo - to copy the collection starting from given index into an array
/// </summary>
/// <param name="inputGestures">Array of InputGesture</param>
/// <param name="index">start index of items to copy</param>
public void CopyTo(InputGesture[] inputGestures, int index)
{
if (_innerGestureList != null)
_innerGestureList.CopyTo(inputGestures, index);
}
/// <summary>
/// Remove
/// </summary>
/// <param name="inputGesture"></param>
public void Remove(InputGesture inputGesture)
{
if (IsReadOnly)
{
throw new NotSupportedException(SR.Get(SRID.ReadOnlyInputGesturesCollection));
}
if (inputGesture == null)
{
throw new ArgumentNullException("inputGesture");
}
if (_innerGestureList != null && _innerGestureList.Contains(inputGesture))
{
_innerGestureList.Remove(inputGesture as InputGesture);
}
}
/// <summary>
/// Add
/// </summary>
/// <param name="inputGesture"></param>
public int Add(InputGesture inputGesture)
{
if (IsReadOnly)
{
throw new NotSupportedException(SR.Get(SRID.ReadOnlyInputGesturesCollection));
}
if (inputGesture == null)
{
throw new ArgumentNullException("inputGesture");
}
EnsureList();
_innerGestureList.Add(inputGesture);
return 0; // ICollection.Add no longer returns the indice
}
private static RoutedCommand DeclareCommand(ref RoutedCommand command,
string commandDebugName, InputGesture gesture)
{
if (command == null)
{
InputGestureCollection collection = null;
if (gesture != null)
{
collection = new InputGestureCollection();
collection.Add(gesture);
}
command = new RoutedCommand(commandDebugName,
typeof(ThumbViewer), collection);
}
return command;
}// end:DeclareCommand()
public int IndexOf(InputGesture value)
{
return(default(int));
}
public void Insert(int index, InputGesture inputGesture)
{
}
public int Add(InputGesture inputGesture)
{
return(default(int));
}
public bool Contains(InputGesture key)
{
return(default(bool));
}
public void Remove(InputGesture inputGesture)
{
}
private GestureCommand FindOrCreateLookup(UIElement uiElement, InputGesture gesture)
{
foreach(var item in uiElement.InputBindings)
{
var binding = (InputBinding)item;
var command = binding.Command as GestureCommand;
if(command != null
&& AreGestureEqual(gesture, command.Gesture))
{
return command;
}
}
var lookup = new GestureCommand(gesture);
uiElement.InputBindings.Add(
new InputBinding(lookup, gesture)
);
return lookup;
}
public static void SetInputBinding(InputBindingCollection inputCollection, ICommand command, InputGesture gesture)
{
var binding = new InputBinding(command, gesture);
inputCollection.Remove(binding);
inputCollection.Add(binding);
}
public bool Contains(InputGesture key)
{
return default(bool);
}
public void Remove(InputGesture inputGesture)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="GestureCommand"/> class.
/// </summary>
/// <param name="gesture">The gesture.</param>
public GestureCommand(InputGesture gesture)
{
_gesture = gesture;
}
public int IndexOf(InputGesture value)
{
throw new NotImplementedException();
}
//http://wekempf.spaces.live.com/blog/cns!D18C3EC06EA971CF!255.entry?wa=wsignin1.0
public static void Register(Type hostType, SimpleRoutedCommand simpleRoutedCommand, InputGesture inputGesture)
{
CommandManager.RegisterClassCommandBinding(hostType, simpleRoutedCommand.CommandBinding);
CommandManager.RegisterClassInputBinding(hostType, new InputBinding(simpleRoutedCommand, inputGesture));
simpleRoutedCommand._routedCommand.InputGestures.Add(inputGesture);
}
public bool Contains(InputGesture key)
{
return(list.Contains(key));
}
/// <summary>
/// IndexOf
/// </summary>
/// <param name="value"></param>
/// <returns></returns>
public int IndexOf(InputGesture value)
{
return (_innerGestureList != null) ? _innerGestureList.IndexOf(value) : -1;
}
public InputBinding(ICommand command, InputGesture gesture)
{
}
/// <summary>
/// Insert
/// </summary>
/// <param name="index">index at which to insert the item</param>
/// <param name="inputGesture">item value to insert</param>
public void Insert(int index, InputGesture inputGesture)
{
if (IsReadOnly)
throw new NotSupportedException(SR.Get(SRID.ReadOnlyInputGesturesCollection));
if (inputGesture == null)
throw new NotSupportedException(SR.Get(SRID.CollectionOnlyAcceptsInputGestures));
if (_innerGestureList != null)
_innerGestureList.Insert(index, inputGesture);
}
public void Insert(int index, InputGesture inputGesture)
{
}
/// <summary>
/// Contains
/// </summary>
/// <param name="key">key</param>
/// <returns>true - if found, false - otherwise</returns>
public bool Contains(InputGesture key)
{
if (_innerGestureList != null && key != null)
{
return _innerGestureList.Contains(key) ;
}
return false;
}
public int Add(InputGesture inputGesture)
{
return default(int);
}
/// <summary>
/// IndexOf
/// </summary>
/// <param name="value"></param>
/// <returns></returns>
int IList.IndexOf(object value)
{
InputGesture inputGesture = value as InputGesture;
return((inputGesture != null) ? this.IndexOf(inputGesture) : -1);
}
private static Func<InputBinding, bool> GestureEquals(InputGesture gesture)
{
return existingBinding => InputGestureEqualityComparer.Instance.Equals(gesture, existingBinding.Gesture);
}
/// <summary>
/// IndexOf
/// </summary>
/// <param name="value"></param>
/// <returns></returns>
public int IndexOf(InputGesture value)
{
return((_innerGestureList != null) ? _innerGestureList.IndexOf(value) : -1);
}
/// <summary>
/// Perform the binding operation for any kind of button
/// </summary>
private static void GenericBinder(UIElement a_element, InputGesture a_gesture, ICommand a_newCommand, ICommand a_oldCommand)
{
if ( a_oldCommand != null )
{
var existingBindings = a_element.InputBindings.Cast<InputBinding>().Where(a_binding => a_binding.Command == a_oldCommand).ToList();
existingBindings.ForEach(a_element.InputBindings.Remove);
}
if ( a_newCommand != null )
{
if ( a_gesture is MouseGesture )
a_element.InputBindings.Add(new MouseBinding(a_newCommand, a_gesture as MouseGesture));
else
a_element.InputBindings.Add(new InputBinding(a_newCommand, a_gesture));
}
}
public static void AddShortcut(this UIElement element, InputGesture gesture, Action action)
{
element.CommandBindings.Add(new CommandBinding(new RoutedCommand() { InputGestures = { gesture } }, (o, e) => action()));
}
public InputBinding (ICommand command, InputGesture gesture)
{
}
internal static void RegisterCommandHandler(Type controlType, RoutedCommand command, ExecutedRoutedEventHandler executedRoutedEventHandler,
InputGesture inputGesture, InputGesture inputGesture2)
{
PrivateRegisterCommandHandler(controlType, command, executedRoutedEventHandler, null, inputGesture, inputGesture2);
}
private bool AreGestureEqual(InputGesture left, InputGesture right)
{
if(left.GetType() != right.GetType()) return false;
var leftKeyGesture = left as UnrestrictedKeyGesture;
if(leftKeyGesture != null)
{
var rightKeyGesture = (UnrestrictedKeyGesture)right;
return rightKeyGesture.Key == leftKeyGesture.Key
&& rightKeyGesture.Modifiers == leftKeyGesture.Modifiers;
}
var leftMouseGesture = left as MouseGesture;
if(leftMouseGesture != null)
{
var rightMouseGesture = (MouseGesture)right;
return rightMouseGesture.MouseAction == leftMouseGesture.MouseAction
&& rightMouseGesture.Modifiers == leftMouseGesture.Modifiers;
}
return false;
}
public DelegateCommand(string name, Action<object> executeAction, Predicate<object> canExecuteFunc, InputGesture inputGesture)
: base(name, inputGesture)
{
this.executeAction = executeAction;
this.canExecuteFunc = canExecuteFunc;
}
public int Add(InputGesture inputGesture)
{
return(list.Add(inputGesture));
}
