public TransitionEvent(
[NotNull] object sender,
[CanBeNull] IStoryboardPageContext context = null)
{
Sender = sender ?? throw new ArgumentNullException(nameof(sender));
Context = context;
}
public TransitionRequest(
Guid destinationPageId,
[CanBeNull] IStoryboardPageContext destinationPageContext)
{
DestinationPageId = destinationPageId;
DestinationPageContext = destinationPageContext;
}
public void CreateStartPages(Dictionary <Guid, IStoryboardPageContext> startPageContexts = null)
{
if (IsStartPagesCreated)
{
throw new InvalidOperationException("Start pages have been alread created");
}
Invoker.Invoke(() =>
{
foreach (var storyboard in Storyboards)
{
var startPageInfo =
RegisteredPages.Keys.FirstOrDefault(x => x.IsStartPage && x.StoryboardId == storyboard.Key);
if (startPageInfo == null)
{
throw new InvalidOperationException(
$"Start page for storyboard {storyboard.Key} not registered");
}
var view = CreatePageView(startPageInfo);
storyboard.Value.ActivePage = view;
StartPagesOpenningStat[startPageInfo.PageUniqueId] = false;
IStoryboardPageContext context = null;
startPageContexts?.TryGetValue(startPageInfo.PageId, out context);
StartPageContexts[startPageInfo.PageUniqueId] = context;
PageContexts[startPageInfo.PageUniqueId] = context;
}
IsStartPagesCreated = true;
});
}
protected virtual async Task <TransitionResult> HandleViewModelTransitionsAsync(
object sender,
PageTransitionTrigger trigger,
IStoryboardPageContext context = null)
{
var tcs = new TaskCompletionSource <TransitionResult>();
await Invoker.InvokeAsync(async() =>
{
try
{
if (!(sender is IStoryboardPageViewModel viewModel))
{
throw new InvalidOperationException("Incorrect request of transition");
}
// todo is it correct? different behaviour of transition
var removingResult = await RemoveOpennedPageAsync()
.ConfigureAwait(true);
if (removingResult == null)
{
tcs.SetResult(TransitionResult.Unavailable);
return;
}
if (removingResult.Item2 != TransitionResult.Completed)
{
tcs.SetResult(removingResult.Item2);
return;
}
var storyboard = Storyboards.Values.FirstOrDefault(x => x.StoryboardId == viewModel.StoryboardId);
if (storyboard == null)
{
throw new InvalidOperationException("Storyboard not found");
}
var destinationPageId = storyboard.GetDestinationPage(viewModel.PageId, trigger);
var result = await GoToPageAsync(destinationPageId, storyboard.StoryboardId, context)
.ConfigureAwait(true);
tcs.SetResult(result);
}
catch (Exception e)
{
ExceptionOccured?.Invoke(this, e);
tcs.SetResult(TransitionResult.Failed);
}
}).ConfigureAwait(false);
return(await tcs.Task.ConfigureAwait(false));
}
public virtual async Task <TransitionResult> GoToPageAsync(
Guid pageId,
Guid?storyboardId = null,
IStoryboardPageContext pageContext = null)
{
var tcs = new TaskCompletionSource <TransitionResult>();
await Invoker.InvokeAsync(async() =>
{
try
{
var storyBoard = storyboardId.HasValue
? Storyboards.FirstOrDefault(x => x.Key == storyboardId.Value).Value
: ActiveStoryboard;
//first try to find desired page in current storyboard, then look up at all registered pages
var pageInfo = storyBoard != null
? RegisteredPages.Keys.FirstOrDefault(x =>
x.PageId == pageId && x.StoryboardId == storyBoard.StoryboardId)
: RegisteredPages.Keys.FirstOrDefault(x => x.PageId == pageId);
if (pageInfo == null)
{
pageInfo = RegisteredPages.Keys.FirstOrDefault(x => x.PageId == pageId);
if (pageInfo == null)
{
throw new InvalidOperationException("Page not found");
}
}
var result = await OpenPageAsync(pageInfo, pageContext)
.ConfigureAwait(true);
tcs.SetResult(result);
}
catch (Exception e)
{
ExceptionOccured?.Invoke(this, e);
tcs.SetResult(TransitionResult.Failed);
}
}).ConfigureAwait(false);
return(await tcs.Task
.ConfigureAwait(false));
}
public Task ReturnAsync(IStoryboardPageContext context)
{
return(Task.CompletedTask);
}
protected virtual async Task <TransitionResult> OpenPageAsync(
[NotNull] InnerStoryboardPageInfo pageInfo,
[CanBeNull] IStoryboardPageContext pageContext = null,
bool addToJournal = true)
{
if (!Storyboards.ContainsKey(pageInfo.StoryboardId))
{
throw new InvalidOperationException($"Storyboard {pageInfo.StoryboardId} does not registered");
}
var tcs = new TaskCompletionSource <TransitionResult>();
await Invoker.InvokeAsync(async() =>
{
try
{
var storyboard = Storyboards[pageInfo.StoryboardId];
if (ActiveStoryboard?.ActivePage != null)
{
var previousPage = ActiveStoryboard.ActivePage;
var viewModel = previousPage.ViewModel;
var canLeave = await viewModel.CanLeaveAsync().ConfigureAwait(true);
if (!canLeave)
{
tcs.SetResult(TransitionResult.CanceledByUser);
return;
}
await viewModel.LeaveAsync().ConfigureAwait(true);
}
var storyboardsWasChanged = ActiveStoryboard == null ||
ActiveStoryboard.StoryboardId != storyboard.StoryboardId;
ActiveInnerStoryboardPageInfo = pageInfo;
ActiveStoryboard = storyboard;
if (storyboardsWasChanged)
{
ActiveStoryboardChanged?.Invoke(this, pageInfo.StoryboardId);
}
if (CachedPages.ContainsKey(pageInfo.PageUniqueId))
{
var page = CachedPages[pageInfo.PageUniqueId];
storyboard.ActivePage = page;
PageContexts.TryGetValue(pageInfo.PageUniqueId, out var restoredPageContext);
StartPagesOpenningStat.TryGetValue(pageInfo.PageUniqueId, out var wasPageOpenned);
if (wasPageOpenned)
{
await page.ViewModel.ReturnAsync(pageContext ?? restoredPageContext).ConfigureAwait(true);
}
else
{
await page.ViewModel.OpenAsync(pageContext ?? restoredPageContext).ConfigureAwait(true);
StartPagesOpenningStat[pageInfo.PageUniqueId] = true;
}
}
else
{
var view = CreatePageView(pageInfo);
storyboard.ActivePage = view;
await view.ViewModel.OpenAsync(pageContext).ConfigureAwait(true);
PageContexts[pageInfo.PageUniqueId] = pageContext;
}
if (addToJournal)
{
Journal.AddLast(pageInfo);
}
tcs.SetResult(TransitionResult.Completed);
CanBackChanged?.Invoke(this, EventArgs.Empty);
}
catch (Exception e)
{
ExceptionOccured?.Invoke(this, e);
tcs.SetResult(TransitionResult.Failed);
}
}).ConfigureAwait(false);
return(await tcs.Task.ConfigureAwait(false));
}
