/// <summary>
/// Determines whether this factory produces commands
/// with the specified features.
/// </summary>
/// <param name="factory">The command factory.</param>
/// <param name="features">The features to test.</param>
/// <returns>
/// <c>true</c> if the command would have the features; otherwise, <c>false</c>.
/// </returns>
public static bool HasFeatures(this ICommandFactory factory, CommandFeatures features)
{
if (factory == null) {
throw new ArgumentNullException("factory");
}
return factory.CommandFeatures.HasFlag(features);
}
public ICommand this[CommandFeatures features]
{
get {
return Commands[features];
}
set {
Commands[features] = value;
}
}
public void Register(CommandFeatures features, string name)
{
if (this.registeredFeatures.ContainsKey(features)) {
throw new InvalidOperationException("Features already registered");
}
this.registeredFeatures[features] = name;
if (!this.defaultCommands.ContainsKey(features)) {
this.defaultCommands[features] = this.commandProvider.GetPreferredCommand(features);
}
}
public CommandProxy GetProxy(CommandFeatures features)
{
CommandProxy proxy;
if (this.proxies.TryGetValue(features, out proxy)) {
return proxy;
}
proxy = new FeaturedCommandProxy(this, features);
this.proxies[features] = proxy;
return proxy;
}
/// <summary>
/// Gets a command marked as preferred for the given features.
/// </summary>
/// <param name="commandProvider">The command provider.</param>
/// <param name="features">The features to test for.</param>
/// <returns>
/// An unpopulated instance of the preferred command type, or
/// null if none such type exists.
/// </returns>
public static ICommand GetPreferredCommand(this ICommandProvider commandProvider, CommandFeatures features)
{
if (commandProvider == null) {
throw new ArgumentNullException("commandProvider");
}
var factory = GetPreferredCommandFactory(commandProvider.CommandFactories, features);
if (factory == null) {
return null;
}
return factory.CreateCommand();
}
public static Predicate<object> GetFeatureFilterPredicate(CommandFeatures commandFeatures)
{
return (obj) => {
var objAsCommand = obj as ICommand;
if (objAsCommand != null) {
return objAsCommand.HasFeatures(commandFeatures);
}
var objAsFactory = obj as ICommandFactory;
if (objAsFactory != null) {
return objAsFactory.HasFeatures(commandFeatures);
}
return false;
};
}
public static bool TryGetCommandFeatures(object value, out CommandFeatures commandFeatures)
{
if (value is CommandFeatures) {
commandFeatures = (CommandFeatures) value;
return true;
}
string valueString = value as string;
if (valueString != null) {
return Enum.TryParse(valueString, true, out commandFeatures);
}
commandFeatures = 0;
return false;
}
/// <summary>
/// Gets the command factory marked as preferred for the given features.
/// </summary>
/// <param name="commandFactories">The command factories to test.</param>
/// <param name="features">The features to test for.</param>
/// <returns>
/// The preferred command factory for the given features, or
/// null if none such exists.
/// </returns>
public static ICommandFactory GetPreferredCommandFactory(IEnumerable<ICommandFactory> commandFactories, CommandFeatures features)
{
if (commandFactories == null) {
throw new ArgumentNullException("commandFactories");
}
// If you have Resharper, try auto-refactoring this into a Linq expression.
// I dare you.
foreach (var factory in commandFactories) {
var attributes = factory.GetType().GetCustomAttributes(typeof(PreferredCommandFactoryAttribute), false);
foreach (var attribute in attributes.OfType<PreferredCommandFactoryAttribute>()) {
if (attribute.CommandFeatures.HasFlag(features)) {
return factory;
}
}
}
return commandFactories.WithFeatures(features).FirstOrDefault();
}
public static IEnumerable<ICommandFactory> WithFeatures(this IEnumerable<ICommandFactory> commands, CommandFeatures features)
{
return commands.Where((command) => command.HasFeatures(features));
}
public bool ContainsKey(CommandFeatures features)
{
return this.commands.ContainsKey(features);
}
public static IBindableCollection<ICommandFactory> WithFeatures(this IBindableCollection<ICommandFactory> commands, CommandFeatures features)
{
return commands.Where((command) => command.HasFeatures(features));
}
private static ICommandFactory GetCommandFactory(Func<ICommand> commandGenerator, string name = "My factory", CommandFeatures features = (CommandFeatures) 0)
{
var mockCommandFactory = new Mock<ICommandFactory>(MockBehavior.Strict);
mockCommandFactory.Setup((factory) => factory.CreateCommand()).Returns(commandGenerator);
mockCommandFactory.Setup((factory) => factory.Name).Returns(name);
mockCommandFactory.Setup((factory) => factory.CommandFeatures).Returns(features);
mockCommandFactory.Setup((factory) => factory.PopulateCommand(It.IsAny<ICommand>(), It.IsAny<ICommandProvider>()));
return mockCommandFactory.Object;
}
private static ICommandFactory GetCommandFactory(string name = "My factory", CommandFeatures features = (CommandFeatures) 0)
{
ICommandFactory factory = null;
factory = GetCommandFactory(() => GetCommand(factory), name, features);
return factory;
}
/// <summary>
/// Marks the command factory as being preferred for the specified features.
/// </summary>
/// <param name="commandFeatures">
/// The command features for which this class is preferred.
/// </param>
public PreferredCommandFactoryAttribute(CommandFeatures commandFeatures)
{
this.commandFeatures = commandFeatures;
}
public static IEnumerable<ICommand> WithFeatures(this IEnumerable<ICommand> commands, CommandFeatures features)
{
return commands.Where((command) => CommandExtensions.HasFeatures(command, features));
}
public DefaultCommandItemThing(IFeatureRegistry registry, CommandFeatures features, FeaturedCommandCollection defaults)
{
this.registry = registry;
this.features = features;
this.defaults = defaults;
}
public ICommand GetDefaultCommand(CommandFeatures features)
{
return this.programSettings.DefaultCommands.GetProxy(features);
}
public FeaturedCommandProxy(FeaturedCommandCollection commandCollection, CommandFeatures features)
{
this.commandCollection = commandCollection;
this.features = features;
}
public string GetFeaturesName(CommandFeatures features)
{
return registeredFeatures[features];
}
