public SimpleGraphViewModel()
{
var observer = MementoObserver.Monitor(service);
UndoCommand = DelegateCommand.Create()
.OnCanExecute(o => service.CanUndo)
.OnExecute(o => service.Undo())
.AddMonitor(observer);
RedoCommand = DelegateCommand.Create()
.OnCanExecute(o => service.CanRedo)
.OnExecute(o => service.Redo())
.AddMonitor(observer);
var person = new Person()
{
FirstName = "Mauro",
LastName = "Servienti"
};
var entity = new PersonViewModel();
service.Attach(entity);
entity.Initialize(person, false);
Entity = entity;
}
public WarehouseViewModel(WarehouseView owner)
{
this.owner = owner;
Warehouses = new ObservableCollection <Warehouse>();
AddCommand = DelegateCommand.Create(Add);
ToDetailCommand = DelegateCommand.Create(owner.ToDetail);
}
/// <summary>
/// This basic implementation just sets a binding on the targeted
/// <see cref="DependencyObject"/> and returns the appropriate
/// <see cref="BindingExpressionBase"/> instance.<br/>
/// All this work is delegated to the decorated <see cref="Binding"/>
/// instance.
/// </summary>
/// <param name="provider">Object that can provide services for the markup
/// extension.</param>
/// <returns>
/// The object value to set on the property where the extension is applied.
/// In case of a valid binding expression, this is a <see cref="BindingExpressionBase"/>
/// instance.
/// </returns>
public override object ProvideValue(IServiceProvider provider)
{
/*
* We basically have a problem here, since we cannot
* create the "runtime" delagate command until the target
* object is loaded if we return the base provided value,
* that is a "Binding" object the binding is runtime evaluated
* and null is returned because obviously the Path does not exists
* on the source object.
*
* So if the base CommandBinding returns itself it means the we are
* currently using a Shared Dependency Property so we need to delay the
* resolution; otherwise we return a fake empty command just to let the
* Wpf binding engine to belive everything is working fine and wait for
* the target to be loaded.
*/
//var value = base.ProvideValue( provider );
//if( Object.Equals( value, this ) )
//{
// return this;
//}
base.ProvideValue(provider);
if (this.IsUsingSharedDependencyProperty(provider))
{
return(this);
}
var fakePlaceholder = DelegateCommand.Create();
return(fakePlaceholder);
}
public MainPageViewModel(IWorkerServiceClientFactory factory)
{
this.factory = factory;
this.ExecuteEcho = DelegateCommand.Create()
.OnExecute(o =>
{
var context = TaskScheduler.FromCurrentSynchronizationContext();
using (var client = this.factory.CreateAsyncClient())
{
client.WorkOnAsync(new Job(new EchoJobTask()
{
Message = this.Message
}))
.ContinueWith(e =>
{
var r = e.Result.GetTaskResult <EchoJobTaskResult>().EchoedMessage;
this.EchoResult = r;
}, context);
}
using (var client = this.factory.CreateAsyncClient())
{
client.ExecuteAsync(new SampleCommand())
.ContinueWith(e =>
{
var r = e.Result as EmptyCommandExecutionResult;
}, context);
}
});
}
public TabControlRegionViewModel(IViewResolver viewResolver, IRegionService regionService)
{
AddNewGammaViewCommand =
DelegateCommand.Create()
.OnExecute(x =>
{
var view = viewResolver.GetView <GammaView>();
if (view != null)
{
regionService.GetKnownRegionManager <TabControlRegionView>()
.GetRegion <ISwitchingElementsRegion>("MainTabRegion")
.Add(view);
}
});
ActivateGammaViewCommand =
DelegateCommand.Create()
.OnExecute(x =>
{
var region = regionService.GetKnownRegionManager <TabControlRegionView>()
.GetRegion <ISwitchingElementsRegion>("MainTabRegion");
var elements = region.GetElements <DependencyObject>()
.OfType <GammaView>()
.Cast <DependencyObject>()
.ToList();
if (elements.Count > 0)
{
var index = elements.IndexOf(region.ActiveContent);
if (index >= 0)
{
DependencyObject viewToActivate = index + 1 < elements.Count
? elements[index + 1]
: elements[0];
region.Activate(viewToActivate);
}
else
{
region.Activate(elements[0]);
}
}
});
RemoveLastViewCommand =
DelegateCommand.Create()
.OnExecute(x =>
{
var region = regionService.GetKnownRegionManager <TabControlRegionView>()
.GetRegion <ISwitchingElementsRegion>("MainTabRegion");
var lastElement = region.GetElements <DependencyObject>().LastOrDefault();
if (lastElement != null)
{
region.Remove(lastElement);
}
});
}
public ViewModel()
{
CreateSerializer();
HtmlPage.RegisterScriptableObject("eventViewerViewModel", this);
Events = new ObservableCollection <IEvent>();
ReloadCommand = DelegateCommand.Create(Reload);
Load();
}
public ItemViewModel(ItemView owner)
{
this.owner = owner;
Items = new ObservableCollection <Item>();
UpdateCommand = DelegateCommand.Create(Update);
ResetCommand = DelegateCommand.Create(o => InitAsync());
DeleteCommand = DelegateCommand.Create(Delete);
}
public CustomerViewModel(CustomerView owner)
{
this.owner = owner;
Customers = new ObservableCollection <Customer>();
UpdateCommand = DelegateCommand.Create(Update);
ResetCommand = DelegateCommand.Create(o => InitAsync());
DeleteCommand = DelegateCommand.Create(Delete);
ToDealCommand = DelegateCommand.Create(owner.ToDeal);
}
public ShellStartScreenViewModel(IMessageBroker messageBroker)
{
Debug.WriteLine("ShellStartScreenViewModel()");
this.messageBroker = messageBroker;
this.OpenView = DelegateCommand.Create()
.OnExecute(OpenViewHandler);
}
public CompositeAppViewModel(IMessageBroker messageBroker)
{
Debug.WriteLine("CompositeAppViewModel()");
this.messageBroker = messageBroker;
this.OpenStartScreen = DelegateCommand.Create()
.OnExecute(p => OpenStartScreenHandler());
}
public SalemanViewModel(SalemanView owner)
{
this.owner = owner;
Salemen = new ObservableCollection <Salesman>();
UpdateCommand = DelegateCommand.Create(Update);
ResetCommand = DelegateCommand.Create(o => InitAsync());
DeleteCommand = DelegateCommand.Create(Delete);
ToDealCommand = DelegateCommand.Create(owner.ToDeal);
}
public TransferViewModel(IMessenger messenger, IAccountsOverview accountsOverview)
{
_messenger = messenger;
Amount = "0";
messenger.SubscribeTo <TransferMessage>(t =>
{
From = t.AccountNumber;
To = string.Empty;
Amount = "0";
});
_accountsOverview = accountsOverview;
TransferCommand = DelegateCommand.Create(Transfer);
}
public void delegateCommand_trigger_using_mementoMonitor_and_manually_calling_notifyChanged_should_raise_CanExecuteChanged()
{
var expected = 1;
var actual = 0;
var svc = MockRepository.GenerateStub <IChangeTrackingService>();
var monitor = new MementoMonitor(svc);
var target = DelegateCommand.Create().AddMonitor(monitor);
target.CanExecuteChanged += (s, e) => actual++;
monitor.NotifyChanged();
actual.Should().Be.EqualTo(expected);
}
public void delegateCommand_trigger_using_PropertyObserver_ForAllproperties_should_trigger_canExecuteChanged()
{
var expected = 2;
var actual = 0;
var stub = new TestStub();
var target = DelegateCommand.Create().Observe(stub);
target.CanExecuteChanged += (s, e) => actual++;
stub.Value = "this raises PropertyChanged";
stub.AnotherValue = "this raises PropertyChanged";
actual.Should().Be.EqualTo(expected);
}
/// <summary>
/// Internally exposed constructor for Unit Testing
/// </summary>
internal HomePageViewModel(
IFolderBrowserDialogWrapper folderBrowserDialog,
IScannedFileStore scannedFileStore,
string userAppDataPath) : base(scannedFileStore, userAppDataPath)
{
_folderBrowserDialog = folderBrowserDialog;
_userAppDataPath = userAppDataPath;
this.Locations = new ObservableCollection <ScanLocation>();
_add = DelegateCommand.Create(AddLocation);
_remove = DelegateCommand.Create(RemoveLocation, false);
_scan = DelegateCommand.Create(ShowScanPage, false);
this.Add = _add;
this.Remove = _remove;
this.Scan = _scan;
this.PageLoaded = AsyncCommand.Create(OnPageLoaded);
}
public void delegateCommand_trigger_using_mementoMonitor_and_triggering_changes_on_the_memento_should_raise_canExecuteChanged()
{
var expected = 1;
var actual = 0;
var svc = MockRepository.GenerateStub <IChangeTrackingService>();
var raiser = svc.GetEventRaiser(obj => obj.TrackingServiceStateChanged += null);
var monitor = new MementoMonitor(svc);
var target = DelegateCommand.Create().AddMonitor(monitor);
target.CanExecuteChanged += (s, e) => actual++;
raiser.Raise(svc, EventArgs.Empty);
actual.Should().Be.EqualTo(expected);
}
public OverviewViewModel(IMessenger messenger, IAccountsOverview accountsOverview)
{
_messenger = messenger;
Accounts = accountsOverview.GetAccountsOverview();
accountsOverview.OnAccountBalanceChanged((accountNumber, balance) =>
{
foreach (var accountOverview in Accounts)
{
if (accountOverview.AccountNumber == accountNumber)
{
accountOverview.Balance = balance;
}
}
});
TransferCommand = DelegateCommand.Create <string>(Transfer);
}
public void DelegateCommand_Create()
{
var callCount = 0;
Action <string> execute = p => callCount++;
Func <string, bool> canExecute = p => true;
var x = DelegateCommand.Create(execute, canExecute);
Assert.AreEqual(true, x.CanExecute(""));
x.Execute("");
Assert.AreEqual(1, callCount);
var y = (ICommand)x;
Assert.AreEqual(true, y.CanExecute(""));
y.Execute("");
Assert.AreEqual(2, callCount);
}
public override void Handle(object sender, ViewLoaded message)
{
if (this.RegionService.HoldsRegionManager(message.View))
{
var manager = this.RegionService.GetRegionManager(message.View);
var registryMenu = new MenuItem();
registryMenu.Header = "Registry";
registryMenu.Items.Add(new MenuItem()
{
Header = "Create...",
Command = DelegateCommand.Create()
.OnExecute(o =>
{
this.Broker.Broadcast(this, new Messaging.CreateNewCompany());
})
});
manager.GetRegion <IElementsRegion>("MainMenuRegion").Add(registryMenu);
}
}
internal ResultPageViewModel(
ILogger logger,
IProcess process,
IRecycleFile recycleFile,
string userAppDataPath,
IScannedFileStore scannedFileStore) : base(scannedFileStore, userAppDataPath)
{
_logger = logger;
_process = process;
_recycle = AsyncCommand.Create(() => RecycleSelectionAsync());
_preview = AsyncCommand.Create(() => PreviewSelectionAsync(), false);
_recycleFile = recycleFile;
_userAppDataPath = userAppDataPath;
Duplicates = new ObservableCollection <ScanResult>();
DuplicatesViewSource = new CollectionViewSource();
DuplicatesViewSource.Source = Duplicates;
PageLoaded = AsyncCommand.Create(() => PageLoadedAsync());
Recycle = _recycle;
Preview = _preview;
SelectedItemsChangedCommand = DelegateCommand.Create(ToggleButtons);
}
public virtual IDelegateCommand CreateCommand(CommandData commandData)
{
var text = (commandData.Description == null) ?
String.Empty :
commandData.Description.DisplayText;
var command = ( DelegateCommand )DelegateCommand.Create(text);
command.SetData(commandData);
command.OnCanExecute(o =>
{
var data = command.GetData <CommandData>();
if (data.Fact != null)
{
return(data.Fact.Eval(o));
}
else if (data.BooleanFact != null)
{
var can = data.BooleanFact.FastGetter();
return(can);
}
return(true);
})
.OnExecute(o =>
{
var data = command.GetData <CommandData>();
if (data.HasParameter)
{
var prm = o;
if (o is IConvertible)
{
prm = Convert.ChangeType(o, data.ParameterType);
}
data.FastDelegate(data.DataContext, new[] { prm });
}
else
{
data.FastDelegate(data.DataContext, null);
}
});
if (commandData.KeyBindings != null)
{
commandData.KeyBindings
.ForEach(kb => command.AddKeyGesture(kb.Key, kb.Modifiers));
}
IMonitor monitor = null;
if (commandData.Fact != null)
{
monitor = commandData.Fact;
}
else if (commandData.BooleanFact != null)
{
monitor = PropertyObserver.For(( INotifyPropertyChanged )commandData.DataContext)
.Observe(commandData.BooleanFact.Name);
}
if (command != null && monitor != null)
{
command.AddMonitor(monitor);
commandData.Monitor = monitor;
}
return(command);
}
public LoginViewModel(LoginView owner)
{
this.owner = owner;
LoginCommand = DelegateCommand.Create(OnLogin);
}
public ComplexGraphViewModel()
{
var observer = MementoObserver.Monitor(this.service);
this.UndoCommand = DelegateCommand.Create()
.OnCanExecute(o => this.service.CanUndo)
.OnExecute(o => this.service.Undo())
.AddMonitor(observer);
this.RedoCommand = DelegateCommand.Create()
.OnCanExecute(o => this.service.CanRedo)
.OnExecute(o => this.service.Redo())
.AddMonitor(observer);
this.CreateNewAddressCommand = DelegateCommand.Create()
.OnExecute(o =>
{
var address = this.Entity.Addresses.AddNew();
this.SelectedAddress = address;
});
this.DeleteAddressCommand = DelegateCommand.Create()
.OnCanExecute(o => this.SelectedAddress != null)
.OnExecute(o =>
{
this.SelectedAddress.Delete();
this.SelectedAddress = this.Entity.Addresses.FirstOrDefault();
})
.AddMonitor
(
PropertyObserver.For(this)
.Observe(v => v.SelectedAddress)
);
var person = new Person()
{
FirstName = "Mauro",
LastName = "Servienti"
};
person.Addresses.Add(new Address(person)
{
City = "Treviglio",
Number = "11",
Street = "Where I live",
ZipCode = "20100"
});
person.Addresses.Add(new Address(person)
{
City = "Daolasa",
Number = "2",
Street = "Pierino",
ZipCode = "20100"
});
var entity = new PersonViewModel();
entity.Initialize(person, false);
this.service.Attach(entity);
this.Entity = entity;
}
public CustomPropertyMappingViewModel()
{
var data = new List <Person>()
{
new Person("topics")
{
FirstName = "Mauro",
LastName = "Servienti"
},
new Person("gioffy")
{
FirstName = "Giorgio",
LastName = "Formica"
},
new Person("imperugo")
{
FirstName = "Ugo",
LastName = "Lattanzi"
}
};
//var data = new List<dynamic>()
//{
// new
// {
// Username = "******",
// FirstName = "Mauro",
// LastName = "Servienti"
// },
// new
// {
// Username = "******",
// FirstName = "Giorgio",
// LastName = "Formica"
// },
// new
// {
// Username = "******",
// FirstName = "Ugo",
// LastName = "Lattanzi"
// }
//};
ToggleCustomProperty = DelegateCommand.Create()
.OnExecute(o =>
{
var temp = Items;
Items = null;
this.OnPropertyChanged(() => Items);
if (!temp.IsCustomPropertyDefined(propertyName))
{
var prop = temp.AddCustomProperty <string>("Nome proprietà", obj =>
{
return(obj.Item.EntityItem.FirstName + " " + obj.Item.EntityItem.LastName);
});
propertyName = prop.Name;
}
else
{
temp.RemoveCustomProperty(propertyName);
}
Items = temp;
this.OnPropertyChanged(() => Items);
});
Items = new EntityView <Person>(data);
Items.AddingNew += (s, e) =>
{
e.NewItem = new Person("--empty--");
};
}
protected override IDelegateCommand GetCommand(DependencyObject target, DependencyProperty targetProperty)
{
if (this.Path != null && target is INotifyAttachedOjectLoaded)
{
var dataContext = (( INotifyAttachedOjectLoaded )target)
.GetAttachedObject <FrameworkElement>()
.DataContext;
var path = this.Path.Path;
var methodName = path.EndsWith("Command") ? path.Remove(path.IndexOf("Command")) : path;
var method = dataContext.GetType().GetMethod(methodName);
var def = dataContext.GetType()
.GetMethods()
.Where(mi => mi.Name.Equals(methodName))
.Select(mi =>
{
var prms = mi.GetParameters();
return(new
{
FastDelegate = mi.CreateVoidDelegate(),
DataContext = dataContext,
HasParameter = prms.Length == 1,
ParameterType = prms.Length != 1 ? null : prms[0].ParameterType,
KeyBindings = mi.GetAttributes <KeyBindingAttribute>(),
Description = method.GetAttribute <CommandDescriptionAttribute>(),
Fact = dataContext.GetType()
.GetProperties()
.Where(pi => pi.PropertyType == typeof(Fact) && pi.Name.Equals("Can" + methodName))
.Select(pi => ( Fact )pi.GetValue(dataContext, null))
.SingleOrDefault()
});
})
.SingleOrDefault();
var text = (def.Description == null) ? String.Empty : def.Description.DisplayText;
var cmd = DelegateCommand.Create(text)
.OnCanExecute(o =>
{
return(def.Fact != null ?
def.Fact.Eval(o) :
true);
})
.OnExecute(o =>
{
if (def.HasParameter)
{
var prm = Convert.ChangeType(o, def.ParameterType);
def.FastDelegate(def.DataContext, new[] { prm });
}
else
{
def.FastDelegate(def.DataContext, null);
}
});
if (def.KeyBindings != null)
{
def.KeyBindings
.ForEach(kb => cmd.AddKeyGesture(kb.Key, kb.Modifiers));
}
if (def.Fact != null)
{
cmd.AddMonitor(def.Fact);
}
target.SetValue(targetProperty, cmd);
return(cmd);
}
return(null);
}
public DragAndDropSampleViewModel()
{
LeftPersons = new ObservableCollection <Person>()
{
new Person {
FirstName = "Mauro", LastName = "Servienti"
},
new Person {
FirstName = "Giovanni", LastName = "Rossi"
},
new Person {
FirstName = "Marco", LastName = "Verdi"
},
};
RightPersons = new ObservableCollection <Person>();
var dd = DelegateCommand.Create()
.OnCanExecute(state =>
{
var e = ( DragOverArgs )state;
X = e.Position.X;
Y = e.Position.Y;
return(true);
})
.OnExecute(state =>
{
var e = ( DropArgs )state;
if (e.Data.GetDataPresent("left/person"))
{
//dragging from left to right
var p = ( Person )e.Data.GetData("left/person");
LeftPersons.Remove(p);
RightPersons.Add(p);
if (LeftSelectedPerson == p)
{
LeftSelectedPerson = null;
}
RightSelectedPerson = p;
}
else if (e.Data.GetDataPresent("right/person"))
{
//dragging from right to left
var p = ( Person )e.Data.GetData("right/person");
RightPersons.Remove(p);
LeftPersons.Add(p);
if (RightSelectedPerson == p)
{
RightSelectedPerson = null;
}
LeftSelectedPerson = p;
}
else
{
//skip
}
});
DropPerson = dd;
}
public SampleViewModel()
{
AddItems = DelegateCommand.Create(AddItemsImpl);
}