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 OnModelPropertyChanged(object sender, PropertyChangedEventArgs e)
{
SearchCommand.RaiseCanExecuteChanged();
AddCommand.RaiseCanExecuteChanged();
DeleteCommand.RaiseCanExecuteChanged();
SaveCommand.RaiseCanExecuteChanged();
CancelCommand.RaiseCanExecuteChanged();
}
private void UpdateCommandsCanExecuteStatus()
{
CancelCommand.RaiseCanExecuteChanged();
CommitCommand.RaiseCanExecuteChanged();
BeginEditCommand.RaiseCanExecuteChanged();
AddCommand.RaiseCanExecuteChanged();
DeleteCommand.RaiseCanExecuteChanged();
}
protected virtual void RaiseAllCanExecuteChanged()
{
SearchCommand.RaiseCanExecuteChanged();
AddCommand.RaiseCanExecuteChanged();
DeleteCommand.RaiseCanExecuteChanged();
SaveCommand.RaiseCanExecuteChanged();
CancelCommand.RaiseCanExecuteChanged();
}
private void RefreshCommands()
{
AddCommand.RaiseCanExecuteChanged();
MoveUpCommand.RaiseCanExecuteChanged();
MoveDownCommand.RaiseCanExecuteChanged();
DeleteCommand.RaiseCanExecuteChanged();
DeleteAllCommand.RaiseCanExecuteChanged();
}
private void ButtonUpdate()
{
AddCommand.RaiseCanExecuteChanged();
ChangeCommand.RaiseCanExecuteChanged();
OkCommand.RaiseCanExecuteChanged();
CancelCommand.RaiseCanExecuteChanged();
SelectAndChangeCommand.RaiseCanExecuteChanged();
}
private async void Init(string ip)
{
await Load(null);
QueryCommand.RaiseCanExecuteChanged();
AddCommand.RaiseCanExecuteChanged();
EditCommand.RaiseCanExecuteChanged();
DeleteCommand.RaiseCanExecuteChanged();
}
private void RefreshCommands()
{
SaveCommand.RaiseCanExecuteChanged();
CancelCommand.RaiseCanExecuteChanged();
DeleteCommand.RaiseCanExecuteChanged();
CreateCommand.RaiseCanExecuteChanged();
RemoveCommand.RaiseCanExecuteChanged();
AddCommand.RaiseCanExecuteChanged();
}
private void SignalsGenerated(object sender, EventArgs args)
{
AddCommand.RaiseCanExecuteChanged();
DivideCommand.RaiseCanExecuteChanged();
MultiplyCommand.RaiseCanExecuteChanged();
SubtractCommand.RaiseCanExecuteChanged();
SwapCommand.RaiseCanExecuteChanged();
CorrelationCommand.RaiseCanExecuteChanged();
ConvolutionCommand.RaiseCanExecuteChanged();
}
private void AddedEditPropertyChanged(object obj, PropertyChangedEventArgs e)
{
Editeur editeur = obj as Editeur;
if (editeur == null)
{
return;
}
AddCommand.RaiseCanExecuteChanged();
}
private void Add()
{
Entries.Add(new Entry {
Value = double.Parse(InputValue), DateTime = DateTime.Now
});
InputValue = null;
NotifyPropertyChanged(nameof(InputValue));
NotifyPropertyChanged(nameof(Total));
AddCommand.RaiseCanExecuteChanged();
}
private void RaiseCanExecuteChanged()
{
RaisePropertyChanged();
AddCommand.RaiseCanExecuteChanged();
EditCommand.RaiseCanExecuteChanged();
SaveCommand.RaiseCanExecuteChanged();
DelCommand.RaiseCanExecuteChanged();
TranslateSelectedCommand.RaiseCanExecuteChanged();
}
private void TestListViewModel_PropertyChanged(object sender, PropertyChangedEventArgs e)
{
if (e.PropertyName == "CurrentTest")
{
BeginCommand.RaiseCanExecuteChanged();
AddCommand.RaiseCanExecuteChanged();
EditCommand.RaiseCanExecuteChanged();
ShowResultsCommand.RaiseCanExecuteChanged();
}
}
// Permet de rafraîchir le bouton de validation lorsque l'on modifie une proppriétée du jeu
private void AddedJeuPropertyChanged(object obj, PropertyChangedEventArgs e)
{
Jeu jeu = obj as Jeu;
if (jeu == null)
{
return;
}
AddCommand.RaiseCanExecuteChanged();
}
protected void UpdateCrudCommands()
{
ExecuteUIThread(() =>
{
EditCommand.RaiseCanExecuteChanged();
SaveCommand.RaiseCanExecuteChanged();
CancelCommand.RaiseCanExecuteChanged();
AddCommand.RaiseCanExecuteChanged();
DeleteCommand.RaiseCanExecuteChanged();
});
}
public RealtorDictionaryViewModel(IServiceLocator serviceLocator, IRealtorService dictionaryService,
IMessageService messageService)
: base(serviceLocator, messageService)
{
_DictionaryService = dictionaryService;
PropertyChanged += (sender, args) =>
{
if (args.PropertyName == PropertySupport.ExtractPropertyName(() => Name))
{
AddCommand.RaiseCanExecuteChanged();
}
};
_DictionaryService.StartSession();
}
private void OnEventReceived(object sender, EventArgs e)
{
var argsEdit = e as EditeurEventArgs;
var argsVisibility = e as VisibilityEventArgs;
if (argsEdit != null)
{
AddedEdit = argsEdit.Editeur;
AddedEdit.PropertyChanged += AddedEditPropertyChanged;
AddCommand.RaiseCanExecuteChanged();
}
if (argsVisibility != null)
{
IsVisible = argsVisibility.Visibility;
}
}
private void OnEventReceived(object sender, EventArgs e)
{
var argsJeu = e as JeuEventArgs;
var argsVisibility = e as VisibilityEventArgs;
if (argsJeu != null)
{
AddedJeu = argsJeu.Jeu;
AddedJeu.PropertyChanged += AddedJeuPropertyChanged;
AddCommand.RaiseCanExecuteChanged();
}
if (argsVisibility != null)
{
IsVisible = argsVisibility.Visibility;
}
}
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 void OnCmdConnect()
{
try
{
LogEntryView.ConnectionTest();
IsDbConnect = true;
AddCommand.RaiseCanExecuteChanged();
LoadCommand.RaiseCanExecuteChanged();
ConnectCommand.RaiseCanExecuteChanged();
CustomerCommand.RaiseCanExecuteChanged();
LocationTreeCommand.RaiseCanExecuteChanged();
}
catch (Exception ex)
{
MessageBox.Show(
ex.Message);
}
}
public string this[string propertyName]
{
get
{
CollectErrors();
if (Errors.Any())
{
HasErrors = true;
AddCommand.RaiseCanExecuteChanged();
}
else
{
HasErrors = false;
AddCommand.RaiseCanExecuteChanged();
}
return(Errors.ContainsKey(propertyName) ? Errors[propertyName] : string.Empty);
}
}
private async void execute_AddCommand(object obj)
{
isWorking = true;
AddCommand.RaiseCanExecuteChanged();
RemoveCommand.RaiseCanExecuteChanged();
var result = await PowerShellUtils.AddAppxPackageAsync(InstallLocation);
await RefreshRegisterStatusAsync();
if (result)
{
MessageBox.Show("添加成功！", nameof(WindowsAppsRegister), MessageBoxButton.OK, MessageBoxImage.Information);
}
else
{
MessageBox.Show("添加失败！", nameof(WindowsAppsRegister), MessageBoxButton.OK, MessageBoxImage.Warning);
}
isWorking = false;
AddCommand.RaiseCanExecuteChanged();
RemoveCommand.RaiseCanExecuteChanged();
}
public async Task InitializeAsync()
{
_serviceStarted = await Task.Factory.StartNew(() => _tokenService.Ping());
if (!_serviceStarted)
{
_synchronizationService.RunInMainThread(() => RaisePropertyChanged(nameof(AllowAdd)));
_dialogService.ShowErrorDialog("Service not available");
return;
}
var tokens = await _tokenService.GetTokensAsync(_userCredentials.GetName());
if (Items.Any())
{
_synchronizationService.RunInMainThread(() => Items.Clear());
}
foreach (var token in tokens)
{
var tokenKey = token.Key;
var imageData = _tokenService.GetTokenImage(tokenKey);
var ringItemViewModel =
new RingItemViewModel {
Name = token.Value, Token = tokenKey, Image = imageData.ImageBytes
};
ringItemViewModel.SetDefaultName(ringItemViewModel.Name);
_synchronizationService.RunInMainThread(() => Items.Add(ringItemViewModel));
}
_synchronizationService.RunInMainThread(() =>
{
RaisePropertyChanged(nameof(AllowAdd));
AddCommand.RaiseCanExecuteChanged();
});
}
protected DictionaryViewModel(IServiceLocator serviceLocator, IMessageService messageService)
{
_ServiceLocator = serviceLocator;
_MessageService = messageService;
Entities = new ListCollectionView(_Entities);
Entities.CurrentChanged += (sender, args) => DeleteCommand.RaiseCanExecuteChanged();
AddCommand = new DelegateCommand(() =>
{
var viewModel = CreateNewViewModel(CreateNewModel());
var error = viewModel.Error;
if (error == null)
{
viewModel.SaveToDatabase();
_Entities.Add(viewModel);
ClearProperties();
}
else
{
_MessageService.ShowMessage(error, "Ошибка", image: MessageBoxImage.Error);
}
AddCommand.RaiseCanExecuteChanged();
}, CanAdd);
DeleteCommand = new DelegateCommand(() =>
{
if (Entities.CurrentItem != null)
{
var current = Entities.CurrentItem;
Entities.Remove(current);
}
else
{
_MessageService.ShowMessage("Выберите удаляемый элемент", "Ошибка", image: MessageBoxImage.Error);
}
DeleteCommand.RaiseCanExecuteChanged();
}, CanDelete);
}
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();
}
private void OnStatusChanged()
{
AddCommand.RaiseCanExecuteChanged();
RemoveCommand.RaiseCanExecuteChanged();
}
public TreemapViewModel(TreemapChart treemap, ChartData data, TreemapAlgorithm algo) : this()
{
Treemap = treemap;
Data = data;
Columns = Data.ColumnNames;
Algorithm = algo;
InitParameters();
InitColorViewModels();
SetColorViewModel();
Messenger.Default.Register <PropertyChangedMessageBase>
(
this, true,
(m) =>
{
if (IsDead || !IsSentBySelf(m.Sender))
{
return;
}
if (m.PropertyName == "ColorMethod")
{
SetColorViewModel();
}
ShowLegendDecimalPlaces = LegendFormatType != FormatType.Text;
if (!LockRefresh)
{
DrawChart();
}
}
);
RefreshCommand = new RelayCommand <object>(_ => DrawChart(true));
DeleteCommand = new RelayCommand <object>(
_ =>
{
LockRefresh = true;
Indexes.RemoveAt(Indexes.Count - 1);
Indexes.Last().AsChildIndex();
DeleteCommand.RaiseCanExecuteChanged();
AddCommand.RaiseCanExecuteChanged();
DrawChart();
LockRefresh = false;
},
_ => Indexes.Count > 1);
AddCommand = new RelayCommand <object>(
_ =>
{
LockRefresh = true;
Indexes.Last().AsParentIndex();
string freeColumn = Columns.Where(c => !Indexes.Select(i => i.Column).Contains(c)).First();
Indexes.Add(new TreemapIndexViewModel(freeColumn));
DeleteCommand.RaiseCanExecuteChanged();
AddCommand.RaiseCanExecuteChanged();
DrawChart();
LockRefresh = false;
},
_ => Indexes.Count < Columns.Count);
DrawChart();
}
public void Task_PropertyChanged(object sender, PropertyChangedEventArgs e)
{
AddCommand.RaiseCanExecuteChanged();
}
private void BuySellSignalConfigurationViewmodel_PropertyChanged(object sender, System.ComponentModel.PropertyChangedEventArgs e)
{
AddCommand.RaiseCanExecuteChanged();
}
private void RaiseCanExecuteChanged(object sender, EventArgs e)
{
SaveCommand.RaiseCanExecuteChanged();
AddCommand.RaiseCanExecuteChanged();
}