private void OnSelectedAccountChanged()
{
_accountDetailsViewModel.Account = SelectedAccount;
CurrentViewModel = _accountDetailsViewModel;
EditCommand.RaiseCanExecuteChanged();
RemoveCommand.RaiseCanExecuteChanged();
}
private void RemoveState()
{
_numberOfStates--;
_triggerStateDataModels.Remove(_triggerStateDataModels.Last());
ObservableTriggerStates.Refresh();
RemoveCommand.RaiseCanExecuteChanged();
}
/// <summary>
/// Check the commands' enabled state
/// </summary>
private void CheckCommands()
{
RunCommand.RaiseCanExecuteChanged();
RemoveCommand.RaiseCanExecuteChanged();
RunReportCommand.RaiseCanExecuteChanged();
RunExportCommand.RaiseCanExecuteChanged();
}
/// <summary>
/// Add a input file.
/// </summary>
/// <param name="file">The path of the file</param>
public async Task AddInputFile(string file)
{
switch (OutOfProcessHelper.TestSourceFile(file))
{
//File is corrupt pdf.
case OutOfProcessHelper.SourceTestResult.Unreadable:
//Tell the user the pdf is corrupt.
Application.Current.Dispatcher.BeginInvoke(new Action(() => ((MetroWindow)Application.Current.MainWindow).ShowMessageAsync("The file " + Path.GetFileName(file) + " could not be opened as a PDF or image", "Some thing went wrong when opening " + Path.GetFileName(file))));
break;
//File is a valid pdf.
case OutOfProcessHelper.SourceTestResult.Ok:
//Add the pdf to the ListBox.
Application.Current.Dispatcher.Invoke(new Action(() => Files.Add(new PDFItem(file, null))));
break;
//File is a image (maybe not valid!).
case OutOfProcessHelper.SourceTestResult.Image:
break;
}
//Update Commands
Application.Current.Dispatcher.Invoke(() => MergeCommand.RaiseCanExecuteChanged());
MoveUpCommand.RaiseCanExecuteChanged();
MoveDownCommand.RaiseCanExecuteChanged();
Application.Current.Dispatcher.Invoke(() => RemoveCommand.RaiseCanExecuteChanged());
}
private void AddState()
{
_numberOfStates++;
_triggerStateDataModels.Add(new TriggerStateDataModel(_avalibleSignals, _numberOfStates));
ObservableTriggerStates.Refresh();
RemoveCommand.RaiseCanExecuteChanged();
}
protected override void OnPropertyChanged(string propertyName)
{
base.OnPropertyChanged(propertyName);
if (propertyName == "CanSave")
{
SaveCommand.RaiseCanExecuteChanged();
}
else if (propertyName == "CanCancel")
{
CancelCommand.RaiseCanExecuteChanged();
}
else if (propertyName == "CanDelete")
{
DeleteCommand.RaiseCanExecuteChanged();
}
else if (propertyName == "CanRemove")
{
RemoveCommand.RaiseCanExecuteChanged();
}
else if (propertyName == "CanAddNew")
{
AddCommand.RaiseCanExecuteChanged();
}
else if (propertyName == "IsBusy")
{
RefreshCommands();
}
}
private void Remove()
{
Entries.Remove(EntrySelected);
EntrySelected = null;
NotifyPropertyChanged(nameof(EntrySelected));
NotifyPropertyChanged(nameof(Total));
RemoveCommand.RaiseCanExecuteChanged();
}
private void ChangeTrackingService_HasChangesChanged(object sender, EventArgs e)
{
// let the commands re-evaluate
SaveCommand.RaiseCanExecuteChanged();
GetCommand.RaiseCanExecuteChanged();
RemoveCommand.RaiseCanExecuteChanged();
RevertCommand.RaiseCanExecuteChanged();
}
private void RemoveAccount()
{
if (SelectedAccount != null)
{
_allAccounts.Remove(SelectedAccount);
EditCommand.RaiseCanExecuteChanged();
RemoveCommand.RaiseCanExecuteChanged();
}
}
private void RefreshCommands()
{
SaveCommand.RaiseCanExecuteChanged();
CancelCommand.RaiseCanExecuteChanged();
DeleteCommand.RaiseCanExecuteChanged();
CreateCommand.RaiseCanExecuteChanged();
RemoveCommand.RaiseCanExecuteChanged();
AddCommand.RaiseCanExecuteChanged();
}
private void InitialiseNewCustomerContact()
{
if (NewCustomerContact != null)
{
NewCustomerContact.PropertyChanged -= NewCustomerContact_PropertyChanged;
}
NewCustomerContact = SelectedCustomerContact ?? new CustomerContact();
NewCustomerContact.PropertyChanged += NewCustomerContact_PropertyChanged;
SaveCommand.RaiseCanExecuteChanged();
RemoveCommand.RaiseCanExecuteChanged();
}
private void NavigateEditAccount()
{
try
{
_addEditAccountViewModel.EditMode = true;
_addEditAccountViewModel.Account = ConvertToEditableACcount(SelectedAccount);
CurrentViewModel = _addEditAccountViewModel;
EditCommand.RaiseCanExecuteChanged();
RemoveCommand.RaiseCanExecuteChanged();
}
catch (Exception ex)
{
Logger.LogException(ex);
}
}
private void NavigateAddAccount()
{
try
{
_addEditAccountViewModel.EditMode = false;
_addEditAccountViewModel.Account = new EditableAccount();
CurrentViewModel = _addEditAccountViewModel;
EditCommand.RaiseCanExecuteChanged();
RemoveCommand.RaiseCanExecuteChanged();
}
catch (Exception ex)
{
Logger.LogException(ex);
}
}
public ManipulateSeriesMvvmViewModel()
{
_renderableSeriesViewModels = new ObservableCollection <IRenderableSeriesViewModel>();
_addCommand = new ActionCommand(() =>
{
RenderableSeriesViewModels.Add(ViewModelsFactory.New(SelectedSeriesType.Type, 0));
ZoomExtents();
ClearCommand.RaiseCanExecuteChanged();
}, () => SelectedSeriesType != null);
_removeCommand = new ActionCommand(() =>
{
RenderableSeriesViewModels.RemoveWhere(s => s.IsSelected);
ClearCommand.RaiseCanExecuteChanged();
}, () => RenderableSeriesViewModels.Any(s => s.IsSelected));
_clearCommand = new ActionCommand(() =>
{
RenderableSeriesViewModels.Clear();
ClearCommand.RaiseCanExecuteChanged();
}, () => RenderableSeriesViewModels.Count > 0);
_selectionChangedCommand = new ActionCommand(() =>
{
var rSeriesVm = RenderableSeriesViewModels.FirstOrDefault(s => s.IsSelected);
if (rSeriesVm != null)
{
SelectedSeriesType = SeriesTypes.FirstOrDefault(x => x.Type == rSeriesVm.GetType());
}
RemoveCommand.RaiseCanExecuteChanged();
});
var data = DataManager.Instance.GetSinewave(1.0, 0.5, 100, 5);
var lineDataSeries = new XyDataSeries <double, double>();
lineDataSeries.Append(data.XData.Select(d => d * 5), data.YData);
FillSeriesTypes();
SelectedSeriesType = SeriesTypes[3];
_addCommand.Execute(null);
AddCommand.RaiseCanExecuteChanged();
RemoveCommand.RaiseCanExecuteChanged();
}
private async void OnRemoveExecute()
{
var isReferenced = await _programmingLanguageRepository.IsReferencedByFriendAsync(SelectedProgrammingLanguage.Id);
if (isReferenced)
{
await MessageDialogService.ShowInfoDialogAsync($"The language {SelectedProgrammingLanguage.Name} " +
"can't be removed, as it is referenced by at least one friend");
return;
}
SelectedProgrammingLanguage.PropertyChanged -= Wrapper_PropertyChanged;
_programmingLanguageRepository.Remove(SelectedProgrammingLanguage.Model);
ProgrammingLanguages.Remove(SelectedProgrammingLanguage);
SelectedProgrammingLanguage = null;
HasChanges = _programmingLanguageRepository.HasChanges();
RemoveCommand.RaiseCanExecuteChanged();
}
protected void Load(IEnumerable <TModel> units, IUnitOfWork unitOfWork, bool isNew)
{
UnitOfWork = unitOfWork;
var unitsArray = units as TModel[] ?? units.ToArray();
//проставляем количество родительских юнитов включенного оборудования
var productsIncluded = unitsArray.SelectMany(x => x.ProductsIncluded).ToList();
foreach (var productIncluded in productsIncluded)
{
productIncluded.ParentsCount = unitsArray.Count(x => x.ProductsIncluded.Contains(productIncluded));
}
//создаем контейнер
Groups = new GroupsCollection <TModel, TGroup, TMember>(GetGroups(unitsArray), isNew);
Groups.SumChanged += () => { RaisePropertyChanged(nameof(Sum)); };
// реакция на выбор группы
Groups.SelectedGroupChanged += group =>
{
RemoveCommand?.RaiseCanExecuteChanged();
AddProductIncludedCommand?.RaiseCanExecuteChanged();
RaisePropertyChanged(nameof(Prices));
RaisePropertyChanged(nameof(PricesLaborHours));
};
// реакция на выбор включенного оборудования
Groups.SelectedProductIncludedChanged += productIncluded =>
{
(RemoveProductIncludedCommand)?.RaiseCanExecuteChanged();
SetCustomFixedPriceCommand?.RaiseCanExecuteChanged();
};
// событие для того, чтобы вид перепривязал группы
RaisePropertyChanged(nameof(Groups));
// подписка на события изменения каждой группы и их членов
((IValidatableChangeTrackingCollection <TGroup>)Groups).PropertyChanged += (sender, args) => GroupChanged?.Invoke();
Groups.CollectionChanged += (sender, args) => GroupChanged?.Invoke();
// обновление прайса каждой группы
Groups.ForEach(RefreshPrice);
}
private void OnReturnedTo(object sender, AccountsChangedEventArgs e)
{
try
{
if (!e.ChangeCanceled)
{
Account account = ConvertToACcount(e.Account);
if (e.EditMode)
{
Account listAccount = _allAccounts.FirstOrDefault(a => a.Id == account.Id);
if (listAccount != null)
{
_allAccounts[_allAccounts.IndexOf(listAccount)] = account;
SelectedAccount = account;
}
}
else
{
if (_allAccounts.Any())
{
account.Id = _allAccounts.Select(a => a.Id).Max() + 1;
_allAccounts.Add(account);
SelectedAccount = account;
}
else
{
account.Id = 0;
_allAccounts.Add(account);
SelectedAccount = account;
}
}
}
CurrentViewModel = _accountDetailsViewModel;
EditCommand.RaiseCanExecuteChanged();
RemoveCommand.RaiseCanExecuteChanged();
}
catch (Exception ex)
{
Logger.LogException(ex);
}
}
public void RemoveGame(object o)
{
int indexEditeur = lesEdit.IndexOf(SelectedEdit);
lesEdit.Remove(SelectedEdit);
if (lesEdit.Count > 0)
{
if (lesEdit.Count == indexEditeur)
{
SelectedEdit = lesEdit[indexEditeur - 1];
}
else
{
SelectedEdit = lesEdit[indexEditeur];
}
}
else
{
AddVisibilityCommand.Execute(o);
RemoveCommand.RaiseCanExecuteChanged();
}
}
public ManipulateSeries3DMvvmViewModel()
{
RenderableSeries = new ObservableCollection <IRenderableSeries3DViewModel>();
SeriesTypes = new ObservableCollection <string>
{
"Column Series",
"Impulse Series",
"Mountain Series",
"PointLine Series",
"SurfaceMesh Series",
"Waterfall Series",
"Scatter Series"
};
AddCommand = new ActionCommand(() =>
{
RenderableSeries.Add(ViewModelFactory3D.New(SelectedType));
RemoveCommand.RaiseCanExecuteChanged();
ClearCommand.RaiseCanExecuteChanged();
});
RemoveCommand = new ActionCommand(() =>
{
RenderableSeries.Remove(RenderableSeries.Last());
ClearCommand.RaiseCanExecuteChanged();
RemoveCommand.RaiseCanExecuteChanged();
}, () => RenderableSeries.Any());
ClearCommand = new ActionCommand(() =>
{
RenderableSeries.Clear();
ClearCommand.RaiseCanExecuteChanged();
RemoveCommand.RaiseCanExecuteChanged();
}, () => RenderableSeries.Any());
}
//supprime le jeu sélectionné et sélectionne le précédent dans la liste. Si il ne reste plus de jeu après la suppression l'ajout est déclenché
public void RemoveGame(object o)
{
int indexJeu = lesJeux.IndexOf(SelectedJeu);
lesJeux.Remove(SelectedJeu);
if (lesJeux.Count > 0)
{
if (lesJeux.Count == indexJeu)
{
SelectedJeu = lesJeux[indexJeu - 1];
}
else
{
SelectedJeu = lesJeux[indexJeu];
}
}
else
{
AddVisibilityCommand.Execute(o);
RemoveCommand.RaiseCanExecuteChanged();
}
}
protected TechnicalRequrementsTasksBaseViewModel(IUnityContainer container) : base(container)
{
//костыль - удаление пустых задач
RemoveFailTasks();
Load();
this.SelectedLookupChanged += lookup =>
{
EditCommand.RaiseCanExecuteChanged();
RemoveCommand.RaiseCanExecuteChanged();
};
#region Commands
NewCommand = new DelegateLogCommand(
() =>
{
//RegionManager.RequestNavigateContentRegion<PriceCalculations.View.PriceCalculationView>(new NavigationParameters { { nameof(PriceCalculation), new PriceCalculation() } });
});
EditCommand = new DelegateLogCommand(
() =>
{
RegionManager.RequestNavigateContentRegion <TechnicalRequrementsTaskView>(new NavigationParameters {
{ nameof(TechnicalRequrementsTask), SelectedItem }
});
},
() => SelectedItem != null);
RemoveCommand = new DelegateLogCommand(
() =>
{
//var messageService = Container.Resolve<IMessageService>();
//var result = messageService.ShowYesNoMessageDialog("Удаление", "Действительно хотите удалить из расчет ПЗ?", defaultNo:true);
//if (result != MessageDialogResult.Yes) return;
//var unitOfWork = Container.Resolve<IUnitOfWork>();
//var calculation = unitOfWork.Repository<PriceCalculation>().GetById(SelectedItem.Id);
//foreach (var item in calculation.PriceCalculationItems.ToList())
//{
// var salesUnits = item.SalesUnits.ToList();
// //единицы, которы нельзя удалить из расчета, т.к. они размещены в производстве
// var salesUnitsNotForRemove = salesUnits
// .Where(x => x.SignalToStartProduction.HasValue)
// .Where(x => x.ActualPriceCalculationItem(unitOfWork).Id == item.Id)
// .ToList();
// if (salesUnitsNotForRemove.Any())
// {
// var salesUnitsToRemove = salesUnits.Except(salesUnitsNotForRemove).ToList();
// salesUnitsToRemove.ForEach(x => item.SalesUnits.Remove(x));
// if (!item.SalesUnits.Any())
// {
// calculation.PriceCalculationItems.Remove(item);
// unitOfWork.Repository<PriceCalculationItem>().Delete(item);
// }
// }
// else
// {
// calculation.PriceCalculationItems.Remove(item);
// unitOfWork.Repository<PriceCalculationItem>().Delete(item);
// }
//}
//if (calculation.PriceCalculationItems.Any())
//{
// messageService.ShowOkMessageDialog("Удаление", "Вы не можете удалить некоторые строки в расчете, т.к. они размещены в производстве.");
//}
//else
//{
// unitOfWork.Repository<PriceCalculation>().Delete(calculation);
// ((ICollection<PriceCalculationLookup>)Lookups).Remove(SelectedLookup);
//}
//unitOfWork.SaveChanges();
},
() => SelectedItem != null);
ReloadCommand = new DelegateLogCommand(Load);
#endregion
}
public ToolbarViewModel(IToolbarView view, IEventAggregator eventAggregator)
{
View = view;
View.DataContext = this;
_eventAggregator = eventAggregator;
IPList = new ObservableCollection <string>(LoadIpList());
FolderList = new ObservableCollection <string>(LoadFolderList());
AddCommand = new DelegateCommand(() =>
{
IPList.Add(SelectedIP);
AddCommand.RaiseCanExecuteChanged();
RemoveCommand.RaiseCanExecuteChanged();
UpdateFileList();
}, () => ValidateIP(SelectedIP) && !IPList.Contains(SelectedIP));
RemoveCommand = new DelegateCommand(() =>
{
IPList.Remove(SelectedIP);
AddCommand.RaiseCanExecuteChanged();
RemoveCommand.RaiseCanExecuteChanged();
UpdateFileList();
}, () => ValidateIP(SelectedIP) && IPList.Contains(SelectedIP));
ConnectCommand = new DelegateCommand(() =>
{
Connected = !Connected;
UpdateLastIp();
}, () => ValidateIP(SelectedIP));
DeployCommand = new DelegateCommand(() =>
{
_eventAggregator.GetEvent <DeployEvent>().Publish(new DeployModel(SelectedIP, Folder));
}, () => Connected);
OpenFolderCommand = new DelegateCommand(() =>
{
var dialog = new System.Windows.Forms.FolderBrowserDialog();
dialog.SelectedPath = Folder;
if (dialog.ShowDialog() == DialogResult.OK)
{
Folder = dialog.SelectedPath;
UpdateLastFolder();
FolderList.Add(Folder);
UpdateFolderList();
}
});
ConfigCommand = new DelegateCommand(() =>
{
_eventAggregator.GetEvent <ShowConfigEvent>().Publish(Folder);
});
LaunchAppCommand = new DelegateCommand(() =>
{
_eventAggregator.GetEvent <SendCommandEvent>().Publish(new EventModel(EventType.Launch, EventKey.Dev));
}, () => Connected);
Command = new DelegateCommand <DebuggerCommandEnum?>(cmd =>
{
if (cmd.HasValue)
{
_eventAggregator.GetEvent <CommandEvent>().Publish(new CommandModel(_port, cmd.ToString()));
}
});
ClearLogsCommand = new DelegateCommand(() =>
{
_eventAggregator.GetEvent <ClearLogsEvent>().Publish(null);
});
//_eventAggregator.GetEvent<LogEvent>().Subscribe(msg => Enable = msg.Message.Contains("Debugger>"), ThreadOption.UIThread);
_eventAggregator.GetEvent <OutputChangeEvent>().Subscribe(p => _port = p);
_eventAggregator.GetEvent <ConnectEvent>().Subscribe(ip => Connected = true, ThreadOption.UIThread);
_eventAggregator.GetEvent <DisconnectEvent>().Subscribe(obj => Connected = false, ThreadOption.UIThread);
LoadLastIp();
LoadLastFolder();
}
public void Default()
{
DefaultSize = SelectedItem;
RemoveCommand.RaiseCanExecuteChanged();
DefaultCommand.RaiseCanExecuteChanged();
}
private void CollectionModified(object sender, NotifyCollectionChangedEventArgs e)
{
RemoveCommand.RaiseCanExecuteChanged();
}
private void OnStatusChanged()
{
AddCommand.RaiseCanExecuteChanged();
RemoveCommand.RaiseCanExecuteChanged();
}
private void UpdateCommands()
{
RemoveCommand.RaiseCanExecuteChanged();
SaveChangesCommand.RaiseCanExecuteChanged();
}
public void Remove()
{
Try(() => Files.RemoveAt(SelectedIndex));
RemoveCommand.RaiseCanExecuteChanged();
}
private void OnSelectedItemChanged(ValueChangedEventArgs <PersonViewModel> args)
{
FireSelectedItemChanged(args.OldValue, args.NewValue);
OnPropertyChanged(nameof(SelectedIndex));
RemoveCommand.RaiseCanExecuteChanged();
}
private void CanExecuteChanged()
{
ReadCommand.RaiseCanExecuteChanged();
RemoveCommand.RaiseCanExecuteChanged();
ListenCommand.RaiseCanExecuteChanged();
}
