/// <summary> /// Called to check whether or not this instance can close. /// </summary> /// <param name="callback">The implementor calls this action with the result of the close check.</param> public override void CanClose(Action <bool> callback) { CloseStrategy.Execute(items.ToList(), (canClose, closable) => { if (!canClose && closable.Any()) { if (closable.Contains(ActiveItem)) { var list = items.ToList(); var next = ActiveItem; do { var previous = next; next = DetermineNextItemToActivate(list, list.IndexOf(previous)); list.Remove(previous); } while(closable.Contains(next)); var previousActive = ActiveItem; ChangeActiveItem(next, true); items.Remove(previousActive); var stillToClose = closable.ToList(); stillToClose.Remove(previousActive); closable = stillToClose; } closable.OfType <IDeactivate>().Apply(x => x.Deactivate(true)); items.RemoveRange(closable); } callback(canClose); }); }
public override void ActivateItem(T item) { if (item != null && item.Equals(ActiveItem)) { if (IsActive) { ScreenExtensions.TryActivate(item); OnActivationProcessed(item, true); } return; } CloseStrategy.Execute(new[] { ActiveItem }, (canClose, items) => { if (canClose) { ChangeActiveItem(item, true); } else { OnActivationProcessed(item, false); } }); }
/// <summary> /// Called to check whether or not this instance can close. /// </summary> /// <param name="callback">The implementer calls this action with the result of the close check.</param> public override void CanClose(Action <bool> callback) { CloseStrategy.Execute(items, (canClose, closable) => { closable.Apply(CloseItemCore); callback(canClose); }); }
public DynamicConductor() { CloseGuard = () => { var tcs = new TaskCompletionSource <bool>(); CloseStrategy.Execute(new[] { ActiveItem }, (canClose, items) => tcs.SetResult(canClose)); return(tcs.Task); }; }
public override void CanClose(Action <bool> callback) { var openedItems = Items.Where(x => x.IsScreenCreated); CloseStrategy.Execute(openedItems, (canClose, closable) => { closable.Apply(CloseItemCore); callback(canClose); }); }
/// <summary> /// Deactivates the specified item. /// </summary> /// <param name="item">The item to close.</param> /// <param name="close">Indicates whether or not to close the item after deactivating it.</param> /// <param name="cancellationToken">The cancellation token to cancel operation.</param> /// <returns>A task that represents the asynchronous operation.</returns> public override async Task DeactivateItemAsync(T item, bool close, CancellationToken cancellationToken) { if (item == null || !item.Equals(ActiveItem)) { return; } ICloseResult <T> closeResult = await CloseStrategy.ExecuteAsync(new[] { ActiveItem }, CancellationToken.None); if (closeResult.CloseCanOccur) { await ChangeActiveItemAsync(default, close, cancellationToken);
/// <summary> /// Called to check whether or not this instance can close. /// </summary> /// <param name="callback">The implementor calls this action with the result of the close check.</param> public override void CanClose(Action <bool> callback) { CloseStrategy.Execute(items, (canClose, closable) => { if (!canClose && closable.Any()) { closable.OfType <IDeactivate>().Apply(x => x.Deactivate(true)); items.RemoveRange(closable); } callback(canClose); }); }
public override void DeactivateItem(T item, bool close) { if (item == null || !item.Equals(ActiveItem)) { return; } CloseStrategy.Execute(new[] { ActiveItem }, (canClose, items) => { if (canClose) { ChangeActiveItem(default, close);
/// <summary> /// Deactivates the specified item. /// </summary> /// <param name="item">The item to close.</param> /// <param name="close">Indicates whether or not to close the item after deactivating it.</param> /// <param name="cancellationToken"></param> public override async Task DeactivateItem(T item, bool close, CancellationToken cancellationToken = default(CancellationToken)) { if (item == null || !item.Equals(ActiveItem)) { return; } var closeResult = await CloseStrategy.Execute(new[] { ActiveItem }); if (closeResult.CanClose) { await ChangeActiveItem(default(T), closeResult.CanClose, cancellationToken); } }
/// <summary> /// Deactivates the specified item. /// </summary> /// <param name="item">The item to close.</param> /// <param name="close">Indicates whether or not to close the item after deactivating it.</param> public override async void DeactivateItem(T item, bool close) { if (item == null || !ReferenceEquals(item, ActiveItem)) { return; } var result = await CloseStrategy.ExecuteAsync(new[] { ActiveItem }); if (result.Item1) { ChangeActiveItem(default(T), close); } }
/// <summary> /// Closes the specified item. /// </summary> /// <param name="item">The item to close.</param> public override void CloseItem(T item) { if (item == null) { return; } CloseStrategy.Execute(new[] { item }, (canClose, closable) => { if (canClose) { CloseItemCore(item); } }); }
/// <summary> /// Closes the specified item. /// </summary> /// <param name="item">The item to close.</param> public override void CloseItem(T item) { if (item == null || !item.Equals(ActiveItem)) { return; } CloseStrategy.Execute(new[] { ActiveItem }, (canClose, items) => { if (canClose) { ChangeActiveItem(default(T), true); } }); }
/// <summary> /// Called to check whether or not this instance can close. /// </summary> public override async Task <bool> CanClose() { var closeResult = await CloseStrategy.Execute(items.ToList()); if (!closeResult.CanClose && closeResult.Items.Length > 0) { // remove items that are already closed var closeables = closeResult.Items.OfType <IDeactivate>().ToArray(); var closeableResults = closeables.Select(c => c.Deactivate(true)); await Task.WhenAll(closeableResults); items.RemoveRange(closeables.Cast <T>()); } return(closeResult.CanClose); }
/// <summary> /// Called to check whether or not this instance can close. /// </summary> /// <param name="cancellationToken">The cancellation token to cancel operation.</param> /// <returns>A task that represents the asynchronous operation.</returns> public override async Task <bool> CanCloseAsync(CancellationToken cancellationToken) { var closeResult = await CloseStrategy.ExecuteAsync(_items.ToArray(), cancellationToken); if (!closeResult.CloseCanOccur && closeResult.Children.Any()) { foreach (var deactivate in closeResult.Children.OfType <IActivate>()) { await deactivate.DeactivateAsync(true, cancellationToken); } _items.RemoveRange(closeResult.Children); } return(closeResult.CloseCanOccur); }
/// <summary> /// Called to check whether or not this instance can close. /// </summary> /// <returns>A task containing the result of the close check.</returns> public override async Task <bool> CanCloseAsync() { var result = await CloseStrategy.ExecuteAsync(_items.ToArray()); var canClose = result.CanClose; var closeables = result.Closeables; if (!canClose && closeables.Any()) { foreach (var x in closeables.OfType <IDeactivate>()) { x.Deactivate(true); } _items.RemoveRange(closeables); } return(canClose); }
/// <inheritdoc /> public override async Task ActivateItemAsync(T item, CancellationToken cancellationToken) { if (item != null && item.Equals(ActiveItem)) { if (IsActive) { await ScreenExtensions.TryActivateAsync(item, cancellationToken); } return; } var closeResult = await CloseStrategy.ExecuteAsync(new[] { ActiveItem }, cancellationToken); if (closeResult.CloseCanOccur) { await ChangeActiveItemAsync(item, true, cancellationToken); } }
/// <summary> /// Initializes a new instance of the <see cref="Conductor<T>.Collection.AllActive"/> class. /// </summary> public AllActive() { items.CollectionChanged += (s, e) => { switch (e.Action) { case NotifyCollectionChangedAction.Add: e.NewItems.OfType <IChild>().Apply(x => x.Parent = this); break; case NotifyCollectionChangedAction.Remove: e.OldItems.OfType <IChild>().Apply(x => x.Parent = null); break; case NotifyCollectionChangedAction.Replace: e.NewItems.OfType <IChild>().Apply(x => x.Parent = this); e.OldItems.OfType <IChild>().Apply(x => x.Parent = null); break; case NotifyCollectionChangedAction.Reset: items.OfType <IChild>().Apply(x => x.Parent = this); break; } }; CloseGuard = () => { var tcs = new TaskCompletionSource <bool>(); CloseStrategy.Execute(items.ToList(), (canClose, closable) => { if (!canClose && closable.Any()) { closable.OfType <IDeactivate>().Apply(x => x.Deactivate(true)); items.RemoveRange(closable); } tcs.SetResult(canClose); }); return(tcs.Task); }; }
/// <summary> /// Deactivates the specified item. /// </summary> /// <param name="item">The item to close.</param> /// <param name="close">Indicates whether or not to close the item after deactivating it.</param> public override async void DeactivateItem(T item, bool close) { if (item == null) { return; } if (!close) { ScreenHelper.TryDeactivate(item, false); } else { var result = await CloseStrategy.ExecuteAsync(new[] { item }); if (result.CanClose) { CloseItemCore(item); } } }
/// <summary> /// Deactivates the specified item. /// </summary> /// <param name="item">The item to close.</param> /// <param name="close">Indicates whether or not to close the item after deactivating it.</param> /// <param name="cancellationToken"></param> public override async Task DeactivateItem(T item, bool close, CancellationToken cancellationToken = default(CancellationToken)) { if (item == null) { return; } if (!close) { await ScreenExtensions.TryDeactivate(item, false, cancellationToken); } else { var closeResult = await CloseStrategy.Execute(new[] { item }); if (closeResult.CanClose) { await CloseItemCore(item); } } }
/// <summary> /// Deactivates the specified item. /// </summary> /// <param name="item">The item to close.</param> /// <param name="close">Indicates whether or not to close the item after deactivating it.</param> public override void DeactivateItem(T item, bool close) { if (item == null) { return; } if (!close) { ScreenExtensions.TryDeactivate(item, false); } else { CloseStrategy.Execute(new[] { item }, (canClose, closable) => { if (canClose) { CloseItemCore(item); } }); } }
/// <summary> /// Deactivates the specified item. /// </summary> /// <param name="item">The item to close.</param> /// <param name="close">Indicates whether or not to close the item after deactivating it.</param> /// <param name="cancellationToken">The cancellation token to cancel operation.</param> /// <returns>A task that represents the asynchronous operation.</returns> public override async Task DeactivateItemAsync(T item, bool close, CancellationToken cancellationToken) { if (item == null) { return; } if (close) { var closeResult = await CloseStrategy.ExecuteAsync(new[] { item }, CancellationToken.None); if (closeResult.CloseCanOccur) { await CloseItemCoreAsync(item, cancellationToken); } } else { await ScreenExtensions.TryDeactivateAsync(item, false, cancellationToken); } }
/// <summary> /// Activates the specified item. /// </summary> /// <param name="item">The item to activate.</param> public override void ActivateItem(object item) { if (item != null && item.Equals(ActiveItem)) { if (IsActive) { ScreenExtensions.TryActivate(item); OnActivationProcessed(item, true); } return; } bool shouldClosePreviosly = true; var screen = ActiveItem as PersitableScreen; if (screen != null) { shouldClosePreviosly = screen.ShouldClose; } if (shouldClosePreviosly) { CloseStrategy.Execute(new[] { ActiveItem }, (canClose, items) => { if (canClose) { ChangeActiveItem(item, true); } else { OnActivationProcessed(item, false); } }); } else { ChangeActiveItem(item, false); } }
/// <summary> /// Called to check whether or not this instance can close. /// </summary> /// <param name="cancellationToken">The cancellation token to cancel operation.</param> /// <returns>A task that represents the asynchronous operation.</returns> public override async Task <bool> CanCloseAsync(CancellationToken cancellationToken = default) { var closeResult = await CloseStrategy.ExecuteAsync(_items.ToList(), cancellationToken); if (!closeResult.CloseCanOccur && closeResult.Children.Any()) { var closable = closeResult.Children; if (closable.Contains(ActiveItem)) { var list = _items.ToList(); var next = ActiveItem; do { var previous = next; next = DetermineNextItemToActivate(list, list.IndexOf(previous)); list.Remove(previous); } while (closable.Contains(next)); var previousActive = ActiveItem; await ChangeActiveItemAsync(next, true); _items.Remove(previousActive); var stillToClose = closable.ToList(); stillToClose.Remove(previousActive); closable = stillToClose; } foreach (var deactivate in closable.OfType <IDeactivate>()) { await deactivate.DeactivateAsync(true, cancellationToken); } _items.RemoveRange(closable); } return(closeResult.CloseCanOccur); }
/// <summary> /// Called to check whether or not this instance can close. /// </summary> /// <returns>A task containing the result of the close check.</returns> public override async Task <bool> CanCloseAsync() { var result = await CloseStrategy.ExecuteAsync(_items.ToArray()); var canClose = result.CanClose; var closables = result.Closeables; if (!canClose && closables.Any()) { if (closables.Contains(ActiveItem)) { var list = _items.ToList(); var next = ActiveItem; do { var previous = next; next = DetermineNextItemToActivate(list, list.IndexOf(previous)); list.Remove(previous); } while (closables.Contains(next)); var previousActive = ActiveItem; ChangeActiveItem(next, true); _items.Remove(previousActive); var stillToClose = closables.ToList(); stillToClose.Remove(previousActive); closables = stillToClose; } foreach (var x in closables.OfType <IDeactivate>()) { x.Deactivate(true); } _items.RemoveRange(closables); } return(canClose); }
/// <summary> /// Activates the specified item. /// </summary> /// <param name="item">The item to activate.</param> public override async void ActivateItem(T item) { if (item != null && ReferenceEquals(item, ActiveItem)) { if (IsActive) { ScreenHelper.TryActivate(item); OnActivationProcessed(item, true); } return; } var result = await CloseStrategy.ExecuteAsync(new[] { ActiveItem }); if (result.Item1) { ChangeActiveItem(item, true); } else { OnActivationProcessed(item, false); } }
/// <summary> /// Called to check whether or not this instance can close. /// </summary> public override async Task <bool> CanClose() { var closeResult = await CloseStrategy.Execute(items.ToList()); if (!closeResult.CanClose && closeResult.Items.Any()) { var closables = closeResult.Items; if (closables.Contains(ActiveItem)) { var list = items.ToList(); var next = ActiveItem; do { var previous = next; next = DetermineNextItemToActivate(list, list.IndexOf(previous)); list.Remove(previous); } while (closables.Contains(next)); var previousActive = ActiveItem; await ChangeActiveItem(next, true); items.Remove(previousActive); var stillToClose = closeResult.Items.ToList(); stillToClose.Remove(previousActive); closables = stillToClose.ToArray(); } var closeableItems = closeResult.Items.OfType <IDeactivate>().ToArray(); var closeableTasks = closeableItems.Select(d => d.Deactivate(true)); await Task.WhenAll(closeableTasks); items.RemoveRange((IEnumerable <T>)closeableItems); } return(closeResult.CanClose); }
/// <summary> /// Activates the specified item. /// </summary> /// <param name="item">The item to activate.</param> /// <param name="cancellationToken"></param> public override async Task ActivateItem(T item, CancellationToken cancellationToken = default(CancellationToken)) { if (item != null && item.Equals(ActiveItem)) { if (IsActive) { await ScreenExtensions.TryActivate(item, cancellationToken); OnActivationProcessed(item, true); } return; } var closeResult = await CloseStrategy.Execute(new[] { ActiveItem }); if (closeResult.CanClose) { await ChangeActiveItem(item, true, cancellationToken); } else { OnActivationProcessed(item, false); } }
/// <summary> /// Called to check whether or not this instance can close. /// </summary> /// <returns>A task containing the result of the close check.</returns> public override async Task <bool> CanCloseAsync() { var result = await CloseStrategy.ExecuteAsync(new[] { ActiveItem }); return(result.Item1); }
/// <summary> /// Called to check whether or not this instance can close. /// </summary> /// <param name="callback">The implementor calls this action with the result of the close check.</param> public override void CanClose(Action <bool> callback) { CloseStrategy.Execute(new[] { ActiveItem }, (canClose, items) => callback(canClose)); }
/// <summary> /// Called to check whether or not this instance can close. /// </summary> /// <param name="cancellationToken">The cancellation token to cancel operation.</param> /// <returns>A task that represents the asynchronous operation.</returns> public override async Task <bool> CanCloseAsync(CancellationToken cancellationToken) { var closeResult = await CloseStrategy.ExecuteAsync(new[] { ActiveItem }, cancellationToken); return(closeResult.CloseCanOccur); }