protected void OnCanExecuteChanged()
{
if (CanExecuteChanged != null)
{
CanExecuteChanged.Invoke(this, new EventArgs());
}
}
public void RefreshState()
{
if (CanExecuteChanged != null)
{
CanExecuteChanged.Invoke(this, EventArgs.Empty);
}
}
public void FireCanExecuteChanged()
{
if (this.CanExecuteChanged != null)
{
CanExecuteChanged.Invoke(this, null);
}
}
public void OnCanExecuteChanged(Object sender, EventArgs e)
{
if (CanExecuteChanged != null)
{
CanExecuteChanged.Invoke(this, EventArgs.Empty);
}
}
public void ChangesHappened()
{
if (CanExecuteChanged != null)
{
CanExecuteChanged.Invoke(this, new EventArgs());
}
}
protected virtual void OnCanExecuteChanged()
{
if (CanExecuteChanged != null)
{
CanExecuteChanged.Invoke(this, EventArgs.Empty);
}
}
public void NotifyCanExecuteChanged(Object parameter)
{
if (CanExecuteChanged != null)
{
CanExecuteChanged.Invoke(parameter, new EventArgs());
}
}
public void RaiseCanExecuteChanged()
{
if (CanExecuteChanged != null)
{
CanExecuteChanged.Invoke(this, null);
}
}
public void OnCanExecuteChanged() // jeśli ktoś wybierze zamówienie wysłana notyfikacja to przekaże informacje do CanExecuteChange
{
if (CanExecuteChanged != null)
{
CanExecuteChanged.Invoke(this, EventArgs.Empty);
}
}
void LoginViewModelPropertyChanged(object sender, System.ComponentModel.PropertyChangedEventArgs e)
{
if (CanExecuteChanged != null)
{
CanExecuteChanged.Invoke(sender, new EventArgs());
}
}
public override void RaiseCanExecChanged()
{
if (CanExecuteChanged != null)
{
CanExecuteChanged.Invoke(this, new EventArgs());
}
}
public void RaiseCanExecuteChanged()
{
if (CanExecuteChanged != null)
{
CanExecuteChanged.Invoke(this, EventArgs.Empty);
}
}
// Handle PropertyChanged of the ModelContainer is equivalent to handling
// SelectedItem changes of the view (If the container is used consequently):
public virtual void OnSelectedItemsChanged(Object sender, PropertyChangedEventArgs e)
{
if (CanExecuteChanged != null)
{
CanExecuteChanged.Invoke(this, EventArgs.Empty);
}
}
/// <summary>
/// Комманда которая аттачится к ViewModel.IsBusy - если модель занята, то
/// любая другая команда, кроме SimpleCommand не сработает.
/// После того как команда выполнится, то IsBusy автоматически становится false,
/// давая возможность другим командам выполняться
/// </summary>
/// <param name="vm">ViewModel которая будет блокироваться после нажатия</param>
/// <param name="funcArg">Действие которое будет выполнено</param>
public LockCommand(BaseViewModel vm, FuncArgAsync funcArg, bool isBusy = false)
{
viewModel = vm ?? throw new Exception("ViewModel не должна быть null");
isCommandCanBlocked = isBusy;
if (isCommandCanBlocked)
{
func = async(arg) =>
{
await funcArg(arg);
vm.IsBusy = false;
}
}
;
else
{
func = async(arg) =>
{
await funcArg(arg);
isEnable = true;
if (CanExecuteChanged != null)
{
CanExecuteChanged.Invoke(this, new EventArgs());
}
}
};
}
public void RaiseCanExecuteChanged()
{
//Self Invoke to evaluate Can Execute.
if (null != CanExecuteChanged)
{
CanExecuteChanged.Invoke(this, EventArgs.Empty);
}
}
public void SetCanExecute(bool in_can_execute)
{
if (m_can_execute != in_can_execute)
{
m_can_execute = in_can_execute;
CanExecuteChanged.Invoke(this, EventArgs.Empty);
}
}
public void SetCanExecute(bool value)
{
if (this.canExecute == value)
{
this.canExecute = value;
CanExecuteChanged.Invoke(this, null);
}
}
public bool CanExecute(object parameter)
{
if (CanExecuteChanged != null)
{
CanExecuteChanged.Invoke(parameter, new EventArgs());
}
return(true);
}
public void Enable()
{
isManualDisable = false;
isEnable = true;
if (CanExecuteChanged != null)
{
CanExecuteChanged.Invoke(this, new EventArgs());
}
}
/// <summary>
/// Сделать кнопку активной
/// </summary>
public void TurnEnable()
{
isEnable = true;
if (CanExecuteChanged != null)
{
CanExecuteChanged.Invoke(this, new EventArgs());
}
}
public bool RaiseCanExecuteChanged()
{
bool result = false;
if (CanExecuteChanged != null)
{
result = true;
CanExecuteChanged.Invoke(this, EventArgs.Empty);
}
Save();
return(result);
}
public void RaiseCanExecuteChanged(object item)
{
if (items != null && items.Any() && items.ContainsKey(item))
{
items[item] += 1;
}
if (CanExecuteChanged != null)
{
CanExecuteChanged.Invoke(item, new System.EventArgs());
}
}
public void Execute(object parameter)
{
try
{
_CanExecute = false;
CanExecuteChanged.Invoke(this, new EventArgs());
ExecuteImpl(parameter);
}
finally
{
_CanExecute = true;
CanExecuteChanged.Invoke(this, new EventArgs());
}
}
public void SetCanExecute(bool value)
{
if (canExecute == value)
{
return;
}
canExecute = value;
if (CanExecuteChanged != null)
{
CanExecuteChanged.Invoke(this, EventArgs.Empty);
}
}
public void Execute(object parameter)
{
try
{
Logger.Debug("Executing command {command}", this);
if (!CanExecute(parameter))
{
throw new Exception();
}
Type type;
Window w;
HandleParameter(parameter, out w, out type);
if (type == null)
{
throw new ArgumentException(
$"Invalid parameter for command {this}, parameter {parameter}",
"parameter");
}
if (w != null)
{
if (w.Visibility != Visibility.Visible)
{
w.Show();
}
return;
}
w = type.GetConstructor(Type.EmptyTypes).Invoke(null) as Window;
if (w == null)
{
throw new ArgumentException();
}
w.Show();
w.Initialized += (sender, args) =>
{
Logger.Debug("In initialized, calling CanExecuteChanged handler.");
var eventArgs = new EventArgs();
CanExecuteChanged.Invoke(this, EventArgs.Empty);
};
}
catch (Exception ex)
{
Logger.Error("Failure in command. {exception}.", ex);
}
}
public void Execute(object parameter)
{
if (parameter is MainViewModel viewModel)
{
viewModel.Tasks.Add(new TaskViewModels()
{
IsDone = false, TaskName = viewModel.EnteredTaskName
});
viewModel.EnteredTaskName = "";
CanExecuteChanged.Invoke(this, EventArgs.Empty);
}
else
{
return;
}
}
public virtual void OnCanExecuteChanged(Object sender, EventArgs e)
{
if (CanExecuteChanged != null)
{
if (GuiThreadHelper.IsInGuiThread())
{
CanExecuteChanged.Invoke(this, EventArgs.Empty);
}
else
{
SyncContext.Send((object state) =>
{
CanExecuteChanged.Invoke(this, EventArgs.Empty);
}, null);
}
}
}
public bool CanExecute(object parameter)
{
if (_canExecute == null)
{
return(_canExecuteCache);
}
var temp = _canExecute(parameter);
if (_canExecuteCache == temp)
{
return(_canExecuteCache);
}
_canExecuteCache = temp;
if (CanExecuteChanged != null)
{
CanExecuteChanged.Invoke(this, new EventArgs());
}
return(_canExecuteCache);
}
public async Task ExecuteAsync()
{
if (CanExecute())
{
try
{
_isRunning = true;
await _executeHandler();
}
catch (Exception ex)
{
_errorHandler?.Invoke(ex);
}
finally
{
_isRunning = false;
}
}
CanExecuteChanged.Invoke(this, EventArgs.Empty);
}
public void Execute(object parameter)
{
if (viewModel != null && viewModel.IsBusy)
{
return;
}
if (isCommandCanBlocked)
{
viewModel.IsBusy = true;
}
else
{
isEnable = false;
}
if (CanExecuteChanged != null)
{
CanExecuteChanged.Invoke(this, new EventArgs());
}
func(parameter);
}
