/// <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);
}
