public void Fkt_Test(object obj)
{
//if (obj is object[])
//{
// var param = obj as object[];
// FieldContent[4] = param[0].ToString();
// OnNotifyPropertyChanged("FieldContent");
// TextContent = param[1].ToString();
// OnNotifyPropertyChanged("TextContent");
//}
//else
//{
// string input = obj as String;
// char[] seperator = { '|' };
// string[] param = input.Split(seperator);
// FieldContent[4] = param[0].ToString();
// OnNotifyPropertyChanged("FieldContent");
// TextContent = param[1].ToString();
// OnNotifyPropertyChanged("TextContent");
//}
TextContent = CanExecute.ToString() + " " + GameInProgress.ToString();
OnNotifyPropertyChanged("TextContent");
OnNotifyPropertyChanged("FieldContent");
}
public FormatTemplateElement SetCanFormat([CanBeNull] CanExecute canFormat)
{
if (IsFrozen)
{
throw new InvalidOperationException("This object is Frozen");
}
CanFormat = canFormat;
return(this);
}
public LoginContent()
{
UserId.EnableValidation(() => UserId);
Password.EnableValidation(() => Password);
CanExecute.Bind(
context => !string.IsNullOrEmpty(context.GetValueAt <string>(0)) && !string.IsNullOrEmpty(context.GetValueAt <string>(1)),
UserId, Password
);
}
public FormatTemplateElement([NotNull] Delegate formatTemplate,
[CanBeNull] CanExecute canFormat,
[NotNull] Type inputTypes,
[CanBeNull] Type outputType,
[NotNull][ItemNotNull] MultiFormatterInfo[] argumentMeta)
{
Format = formatTemplate ?? throw new ArgumentNullException(nameof(formatTemplate));
CanFormat = canFormat;
InputTypes = inputTypes ?? throw new ArgumentNullException(nameof(inputTypes));
OutputType = outputType ?? throw new ArgumentNullException(nameof(outputType));
MetaData = new MultiFormatterInfoCollection(argumentMeta ?? throw new ArgumentNullException(nameof(argumentMeta)));
if (MetaData.Any(e => e == null))
{
throw new InvalidOperationException("You cannot use a Null value in the collection of MultiFormatterInfo");
}
}
protected override async Task OnInitializedAsync()
{
await base.OnInitializedAsync();
if (CanExecute.HasDelegate)
{
var ev = new CanExecuteEventArgs();
await CanExecute.InvokeAsync(ev);
_canExecute = ev.Result;
}
else
{
_canExecute = true;
}
}
public ButtonCellTestViewModel(IPageDialogService pageDialog)
{
CanExecute.Value = CanExecutes[0];
Commands[0] = CanExecute.ToReactiveCommand();
Commands[1] = CanExecute.ToReactiveCommand();
CommandParameter.Value = Parameters[0];
Command.Value = Commands[0];
Commands[0].Subscribe(async p =>
{
await pageDialog.DisplayAlertAsync("Command1", p?.ToString(), "OK");
});
Commands[1].Subscribe(async p =>
{
await pageDialog.DisplayAlertAsync("Command2", p?.ToString(), "OK");
});
}
public LabelCellTestViewModel(INavigationService navigationService, IPageDialogService pageDialog)
{
BackgroundColor.Value = Color.White;
PickerTitle.Value = "Hoge";
TimeFormat.Value = "t";
Time.Value = new TimeSpan(12, 0, 0);
DateFormat.Value = DateFormats[0];
TodayText.Value = TodayTexts[0];
Date.Value = Dates[0];
MaxDate.Value = MaxDates[0];
MinDate.Value = MinDates[0];
CanExecute.Value = CanExecutes[0];
Commands[0] = CanExecute.ToReactiveCommand();
Commands[1] = CanExecute.ToReactiveCommand();
CommandParameter.Value = Parameters[0];
Command.Value = Commands[0];
Commands[0].Subscribe(async p =>
{
await pageDialog.DisplayAlertAsync("Command1", p?.ToString(), "OK");
await navigationService.NavigateAsync("ContentPage");
});
Commands[1].Subscribe(async p =>
{
await pageDialog.DisplayAlertAsync("Command2", p?.ToString(), "OK");
});
NumberSelectedCommand.Subscribe(async p =>
{
await pageDialog.DisplayAlertAsync("", p.ToString(), "OK");
});
TextSelectedCommand.Subscribe(async p => {
await pageDialog.DisplayAlertAsync("", p?.ToString(), "OK");
});
}
protected override async Task OnInitializedAsync()
{
await base.OnInitializedAsync();
if (CanExecute.HasDelegate)
{
var ev = new CanExecuteEventArgs();
await CanExecute.InvokeAsync(ev);
_canExecute = ev.Result;
}
else
{
_canExecute = true;
if (Screen != null)
{
var dws = Screen.GetDataWorkspace();
if (dws != null)
{
dws.SavedChanges += Dws_SavedChanges;
}
}
}
}
/// <summary> /// Raises the <see cref="CanExecute"/> event. /// </summary> private void RaiseCanExecute(DependencyObject element, ICommand command, Object parameters, CanExecuteRoutedEventData data) => CanExecute?.Invoke(element, command, parameters, data);
public FormatTemplateElement SetCanFormat([CanBeNull] CanExecute canFormat)
{
CanFormat = canFormat;
return(this);
}
public InternalReactiveCommand(MonoBehaviour disposer)
{
CanExecute.Subscribe(_ => CanExecuteChanged?.Invoke(this, EventArgs.Empty)).AddTo(disposer);
}
/// <inheritdoc/>
protected override bool ICommandCanExecute(object parameter)
{
return(CanExecute.FirstAsync().Wait());
}
public virtual bool OnCanExecute(TArgs args) => CanExecute?.Invoke(args) ?? true;
/// <summary>
/// Initializes a new instance of the <see cref="DelegateCommand"/> class.
/// </summary>
/// <param name="canDoAction">The delegate that defines if the command is enabled.</param>
/// <param name="doAction">The delegate that defines the command action.</param>
public DelegateCommand(CanExecute canDoAction, Execute doAction)
: this(null, canDoAction, doAction)
{
}
public FormatTemplateElement([NotNull] Func <object, object, object> formatTemplate,
[CanBeNull] CanExecute canFormat, [NotNull] Type inputTypes,
[CanBeNull] Type outputType, [NotNull][ItemNotNull] MultiFormatterInfo[] argumentMeta)
: this((Delegate)formatTemplate, canFormat, inputTypes, outputType, argumentMeta)
{
}
public PlanExecutionEvents OnCanExecute(bool canExecute)
{
CanExecute?.Invoke(this, new PlanCanExecuteUpdatedEventArgs(backupPlan, canExecute));
return(this);
}
public void RaiseCanExecute(object sender, CanExecuteEventArgs args)
{
CanExecute.NullableInvoke(sender, args);
}
public IDisposable NonGenericSubscribe(Action <object> onNext)
{
return(CanExecute.Subscribe(obj => onNext.Invoke(obj)));
}
/// <summary>
/// Initializes a new instance of the <see cref="DelegateCommand"/> class.
/// </summary>
/// <param name="canDoAction">The delegate that defines if the command is enabled.</param>
/// <param name="doAction">The delegate that defines the command action.</param>
public DelegateCommand(CanExecute canDoAction, Execute doAction)
: this(null, canDoAction, doAction)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="CombinedReactiveCommand{TParam, TResult}"/> class.
/// </summary>
/// <param name="childCommands">The child commands which will be executed.</param>
/// <param name="canExecute">A observable when the command can be executed.</param>
/// <param name="outputScheduler">The scheduler where to dispatch the output from the command.</param>
/// <exception cref="ArgumentNullException">Fires when required arguments are null.</exception>
/// <exception cref="ArgumentException">Fires if the child commands container is empty.</exception>
protected internal CombinedReactiveCommand(
IEnumerable <ReactiveCommandBase <TParam, TResult> > childCommands,
IObservable <bool> canExecute,
IScheduler outputScheduler)
{
if (childCommands is null)
{
throw new ArgumentNullException(nameof(childCommands));
}
if (canExecute is null)
{
throw new ArgumentNullException(nameof(canExecute));
}
if (outputScheduler is null)
{
throw new ArgumentNullException(nameof(outputScheduler));
}
var childCommandsArray = childCommands.ToArray();
if (childCommandsArray.Length == 0)
{
throw new ArgumentException("No child commands provided.", nameof(childCommands));
}
_exceptions = new ScheduledSubject <Exception>(outputScheduler, RxApp.DefaultExceptionHandler);
var canChildrenExecute = childCommandsArray.Select(x => x.CanExecute)
.CombineLatest()
.Select(x => x.All(y => y));
var combinedCanExecute = canExecute
.Catch <bool, Exception>(ex =>
{
_exceptions.OnNext(ex);
return(Observables.False);
})
.StartWith(false)
.CombineLatest(canChildrenExecute, (ce, cce) => ce && cce)
.DistinctUntilChanged()
.Replay(1)
.RefCount();
_exceptionsSubscription = childCommandsArray.Select(x => x.ThrownExceptions)
.Merge()
.Subscribe(ex => _exceptions.OnNext(ex));
_innerCommand = new ReactiveCommand <TParam, IList <TResult> >(
param =>
childCommandsArray
.Select(x => x.Execute(param))
.CombineLatest(),
combinedCanExecute,
outputScheduler);
// we already handle exceptions on individual child commands above, but the same exception
// will tick through innerCommand. Therefore, we need to ensure we ignore it or the default
// handler will execute and the process will be torn down
_innerCommand
.ThrownExceptions
.Subscribe();
CanExecute.Subscribe(OnCanExecuteChanged);
}
/// <summary>
/// Initializes a new instance of the <see cref="DelegateCommand"/> class.
/// </summary>
/// <param name="name">The name.</param>
/// <param name="canDoAction">The can do action.</param>
/// <param name="doAction">The do action.</param>
public DelegateCommand(string name, CanExecute canDoAction, Execute doAction)
{
this.name = name;
this.canDoAction = canDoAction;
this.doAction = doAction;
}
/// <summary>
/// Initializes a new instance of the <see cref="DelegateCommand"/> class.
/// </summary>
/// <param name="name">The name.</param>
/// <param name="canDoAction">The can do action.</param>
/// <param name="doAction">The do action.</param>
public DelegateCommand(string name, CanExecute canDoAction, Execute doAction)
{
this.name = name;
this.canDoAction = canDoAction;
this.doAction = doAction;
}
public AddCommandPageViewModel(INavigationService navigationService)
{
Navigation = navigationService;
EffectOn = true;
EffectColor = Color.FromHex("#FFFF00");
IsExecutedCommand = false;
IsExecutedLong = false;
EnableRipple = true;
TestParam = "Hoge";
TestLongParam = "LongHoge";
EnableSound = true;
SyncCanExecute = true;
ToggleCanExecute.Subscribe(_ => {
CanExecute.Value = !CanExecute.Value;
});
IDisposable subCommand = null;
ChangeCommand.Subscribe(_ => {
if (EffectCommand != null)
{
subCommand?.Dispose();
EffectCommand = null;
}
else
{
EffectCommand = CanExecute.ToReactiveCommand();
subCommand = EffectCommand.Subscribe(ExecCommand);
}
OnPropertyChanged(() => this.EffectCommand);
});
ChangeCommand.Execute();
IDisposable subLongCommand = null;
ChangeLongCommand.Subscribe(_ => {
if (LongCommand != null)
{
subLongCommand.Dispose();
LongCommand = null;
}
else
{
LongCommand = CanExecute.ToReactiveCommand();
subLongCommand = LongCommand.Subscribe(ExecLongCommand);
}
OnPropertyChanged(() => this.LongCommand);
});
ChangeLongCommand.Execute();
CanExecuteNullToggle.Subscribe(_ => {
if (CanExecuteCommand != null)
{
CanExecuteCommand = null;
CommandParameterText = "Command is null";
}
else
{
CanExecuteCommand = CanExecute.ToAsyncReactiveCommand();
CanExecuteCommand.Subscribe(async x => {
CommandParameterText = "Done Command";
await Task.Delay(500);
});
}
OnPropertyChanged(() => CanExecuteCommand);
});
CanExecuteLongNullToggle.Subscribe(_ => {
if (CanExecuteLongCommand != null)
{
CanExecuteLongCommand = null;
CommandParameterText = "LongCommand is null";
}
else
{
CanExecuteLongCommand = CanExecuteLong.ToReactiveCommand();
CanExecuteLongCommand.Subscribe(async x => {
CommandParameterText = "Done Long Command";
await Task.Delay(500);
});
}
OnPropertyChanged(() => CanExecuteLongCommand);
});
CanExecuteNullToggle.Execute();
CanExecuteLongNullToggle.Execute();
}