private static async Task CreateNewWindowAsync(string id, Type page, object par)
{
await CoreApplication.MainView.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, async() =>
{
//if (Data.TmpData.OpenedWindows.TryGetValue(id, out int value))
//{
// await ApplicationViewSwitcher.TryShowAsStandaloneAsync(value);
//}
//else
{
int newViewId = -1;
CoreApplicationView newView = CoreApplication.CreateNewView();
await newView.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
var newWindow = Window.Current;
var newAppView = ApplicationView.GetForCurrentView();
var sysnm = Windows.UI.Core.SystemNavigationManager.GetForCurrentView();
var frame = new Frame();
frame.Navigated += (s, e) =>
{
if (frame.Content is IBackable)
{
sysnm.AppViewBackButtonVisibility = AppViewBackButtonVisibility.Visible;
}
else
{
sysnm.AppViewBackButtonVisibility = AppViewBackButtonVisibility.Collapsed;
}
};
sysnm.BackRequested += (s, e) =>
{
if (frame.Content is IBackable iba)
{
if (!iba.GoBack())
{
var a = Window.Current.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
Window.Current.Close();
});
}
else
{
e.Handled = true;
}
}
};
newWindow.Closed += async(s, e) =>
{
Window.Current.Content = null;
await CoreApplication.MainView.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
Data.TmpData.OpenedWindows.Remove(id);
});
};
frame.Navigate(page, par);
newWindow.Content = frame;
newWindow.Activate();
newViewId = newAppView.Id;
});
Data.TmpData.OpenedWindows[id] = newViewId;
var viewShown = await ApplicationViewSwitcher.TryShowAsStandaloneAsync(newViewId);
}
});
/// <summary>
/// Invoked when the application is launched normally by the end user. Other entry points
/// will be used such as when the application is launched to open a specific file.
/// </summary>
/// <param name="e">Details about the launch request and process.</param>
protected override async void OnLaunched(LaunchActivatedEventArgs e)
{
Frame rootFrame = Window.Current.Content as Frame;
// Do not repeat app initialization when the Window already has content,
// just ensure that the window is active
if (rootFrame == null)
{
// Create a Frame to act as the navigation context and navigate to the first page
rootFrame = new Frame();
rootFrame.NavigationFailed += OnNavigationFailed;
if (e.PreviousExecutionState == ApplicationExecutionState.Terminated)
{
//TODO: Load state from previously suspended application
}
// Place the frame in the current Window
Window.Current.Content = rootFrame;
}
if (e.PrelaunchActivated == false)
{
if (rootFrame.Content == null)
{
// When the navigation stack isn't restored navigate to the first page,
// configuring the new page by passing required information as a navigation
// parameter
rootFrame.Navigate(typeof(MainPage), e.Arguments);
}
// Ensure the current window is active
Window.Current.Activate();
}
// Create 2 secondary views
if (_viewIds.Count < 2)
{
CoreApplicationView newView = CoreApplication.CreateNewView();
int newViewId = 0;
await newView.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
Frame frame = new Frame();
Window.Current.Content = frame;
Window.Current.Activate();
ApplicationView appView = ApplicationView.GetForCurrentView();
newViewId = appView.Id;
appView.Title = newViewId.ToString();
_viewIds.Add(newViewId);
});
bool viewShown = await ApplicationViewSwitcher.TryShowAsStandaloneAsync(newViewId);
}
else
{
// Switch to first secondary view, BUT focuses on last secondary view :/
Debug.WriteLine("Switching to secondary view with id: " + _viewIds[0]);
await ApplicationViewSwitcher.SwitchAsync(_viewIds[0]);
}
}
private async void BtnNext1_Click(object sender, RoutedEventArgs e)
{
if (filename.Visibility == Visibility.Collapsed)
{
try
{
if (!String.IsNullOrWhiteSpace(userCreate.Text))
{
// Add User's Name to Local Settings
settings.Values["Name"] = userCreate.Text;
//Add Back Up Credentials to local settings and check if valid password
if (backupPassword.IsEnabled && !String.IsNullOrWhiteSpace(backupPassword.Password) && checkValidPassword(backupPassword.Password))
{
settings.Values["Backup"] = backupPassword.Password;
}
else if (backupPassword.IsEnabled && (String.IsNullOrWhiteSpace(backupPassword.Password) || !checkValidPassword(backupPassword.Password)))
{
// Getting fancy with custom exceptions
throw new InvalidPasswordException("Invalid Password");
}
}
else
{
throw new InvalidNameException("Invalid Name");
}
if (lockCheck.IsChecked == true)
{
settings.Values["Lock"] = "true";
}
else
{
settings.Values["Lock"] = "false";
}
filename.Visibility = Visibility.Visible;
fileselect.Visibility = Visibility.Visible;
preview.Visibility = Visibility.Visible;
backupPassword.Visibility = Visibility.Collapsed;
userCreate.Visibility = Visibility.Collapsed;
lockCheck.Visibility = Visibility.Collapsed;
Title.Text = "Let's Pick a Picture";
}
catch (Exception ex)
{
if (ex is InvalidPasswordException)
{
retrieveMsgDialog("Please enter a valid backup password", ex.Message);
}
else if (ex is InvalidNameException)
{
retrieveMsgDialog("Please enter a valid name", ex.Message);
}
}
}
else
{
// Navigating to the next page, Password Creation
CoreApplicationView view = CoreApplication.CreateNewView();
int newViewId = 0;
await view.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
{
// C# Lambda Expression
Frame frame = new Frame();
frame.Navigate(typeof(Password));
Window.Current.Content = frame;
Window.Current.Activate();
newViewId = ApplicationView.GetForCurrentView().Id;
});
await ApplicationViewSwitcher.SwitchAsync(newViewId);
}
}
private async void OnUnlockClick(object sender, Windows.UI.Xaml.RoutedEventArgs e)
{
var context = ServiceLocator.Current.GetService <IContextService>();
await ApplicationViewSwitcher.SwitchAsync(context.MainViewID);
}
/// <summary>
/// Call this method in Unity App Thread can switch to Plan View, create and show a new XAML View.
/// </summary>
/// <typeparam name="TReturnValue"></typeparam>
/// <param name="xamlPageName"></param>
/// <param name="callback"></param>
/// <returns></returns>
public IEnumerator OnLaunchXamlView <TReturnValue>(string xamlPageName, Action <TReturnValue> callback, object pageNavigateParameter = null)
{
bool isCompleted = false;
#if !UNITY_EDITOR && UNITY_WSA && !(ENABLE_IL2CPP && NET_STANDARD_2_0)
object returnValue = null;
CoreApplicationView newView = CoreApplication.CreateNewView();
int newViewId = 0;
var dispt = newView.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
//This happens when User switch view back to Main App manually
//void CoreWindow_VisibilityChanged(CoreWindow sender, VisibilityChangedEventArgs args)
//{
// if (args.Visible == false)
// {
// CallbackReturnValue(null);
// }
//}
//newView.CoreWindow.VisibilityChanged += CoreWindow_VisibilityChanged;
//Frame frame = new Frame();
//var pageType = Type.GetType(Windows.UI.Xaml.Application.Current.GetType().AssemblyQualifiedName.Replace(".App,", $".{xamlPageName},"));
//var appv = ApplicationView.GetForCurrentView();
//newViewId = appv.Id;
//var cb = new Action<object>(rval =>
//{
// returnValue = rval;
// isCompleted = true;
//});
//frame.Navigate(pageType,pageNavigateParameter);
//CallbackDictionary[newViewId] = cb;
//Window.Current.Content = frame;
//Window.Current.Activate();
}).AsTask();
yield return(new WaitUntil(() => dispt.IsCompleted || dispt.IsCanceled || dispt.IsFaulted));
Task viewShownTask = null;
UnityEngine.WSA.Application.InvokeOnUIThread(
() =>
{
viewShownTask = ApplicationViewSwitcher.TryShowAsStandaloneAsync(newViewId).AsTask();
},
true);
yield return(new WaitUntil(() => viewShownTask.IsCompleted || viewShownTask.IsCanceled || viewShownTask.IsFaulted));
yield return(new WaitUntil(() => isCompleted));
try
{
if (returnValue is TReturnValue)
{
callback?.Invoke((TReturnValue)returnValue);
}
else
{
callback?.Invoke(default(TReturnValue));
}
}
catch (Exception ex)
{
Debug.LogError(ex);
}
#else
isCompleted = true;
yield return(new WaitUntil(() => isCompleted));
#endif
}
public static async Task OpenPropertiesWindowAsync(object item, IShellPage associatedInstance)
{
if (item == null)
{
return;
}
if (ApiInformation.IsApiContractPresent("Windows.Foundation.UniversalApiContract", 8))
{
if (WindowDecorationsHelper.IsWindowDecorationsAllowed)
{
AppWindow appWindow = await AppWindow.TryCreateAsync();
Frame frame = new Frame();
frame.RequestedTheme = ThemeHelper.RootTheme;
frame.Navigate(typeof(Properties), new PropertiesPageNavigationArguments()
{
Item = item,
AppInstanceArgument = associatedInstance
}, new SuppressNavigationTransitionInfo());
ElementCompositionPreview.SetAppWindowContent(appWindow, frame);
(frame.Content as Properties).appWindow = appWindow;
appWindow.TitleBar.ExtendsContentIntoTitleBar = true;
appWindow.Title = "PropertiesTitle".GetLocalized();
appWindow.PersistedStateId = "Properties";
WindowManagementPreview.SetPreferredMinSize(appWindow, new Size(460, 550));
bool windowShown = await appWindow.TryShowAsync();
if (windowShown)
{
// Set window size again here as sometimes it's not resized in the page Loaded event
appWindow.RequestSize(new Size(460, 550));
DisplayRegion displayRegion = ApplicationView.GetForCurrentView().GetDisplayRegions()[0];
Point pointerPosition = CoreWindow.GetForCurrentThread().PointerPosition;
appWindow.RequestMoveRelativeToDisplayRegion(displayRegion,
new Point(pointerPosition.X - displayRegion.WorkAreaOffset.X, pointerPosition.Y - displayRegion.WorkAreaOffset.Y));
}
}
else
{
CoreApplicationView newWindow = CoreApplication.CreateNewView();
ApplicationView newView = null;
await newWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, async() =>
{
Frame frame = new Frame();
frame.RequestedTheme = ThemeHelper.RootTheme;
frame.Navigate(typeof(Properties), new PropertiesPageNavigationArguments()
{
Item = item,
AppInstanceArgument = associatedInstance
}, new SuppressNavigationTransitionInfo());
Window.Current.Content = frame;
Window.Current.Activate();
newView = ApplicationView.GetForCurrentView();
newWindow.TitleBar.ExtendViewIntoTitleBar = true;
newView.Title = "PropertiesTitle".GetLocalized();
newView.PersistedStateId = "Properties";
newView.SetPreferredMinSize(new Size(460, 550));
bool viewShown = await ApplicationViewSwitcher.TryShowAsStandaloneAsync(newView.Id);
if (viewShown && newView != null)
{
// Set window size again here as sometimes it's not resized in the page Loaded event
newView.TryResizeView(new Size(460, 550));
}
});
}
}
else
{
var propertiesDialog = new PropertiesDialog();
propertiesDialog.propertiesFrame.Tag = propertiesDialog;
propertiesDialog.propertiesFrame.Navigate(typeof(Properties), new PropertiesPageNavigationArguments()
{
Item = item,
AppInstanceArgument = associatedInstance
}, new SuppressNavigationTransitionInfo());
await propertiesDialog.ShowAsync(ContentDialogPlacement.Popup);
}
}
private async Task CreateNewTerminalWindow(string startupDirectory)
{
var id = await CreateSecondaryView <MainViewModel>(typeof(MainPage), true, startupDirectory).ConfigureAwait(true);
await ApplicationViewSwitcher.TryShowAsStandaloneAsync(id);
}
private async void OpenMainWindow()
{
await ApplicationViewSwitcher.TryShowAsStandaloneAsync(ApplicationView.GetApplicationViewIdForWindow(CoreApplication.MainView.CoreWindow));
}
public async Task GoBackToMainViewAsync()
{
await ApplicationViewSwitcher.TryShowAsStandaloneAsync(mainViewId);
}
public async Task <ViewLifetimeControl> OpenAsync(Type page, object parameter = null, string title = null,
ViewSizePreference size = ViewSizePreference.UseHalf, int session = 0, string id = "0")
{
Logger.Info($"Page: {page}, Parameter: {parameter}, Title: {title}, Size: {size}");
var currentView = ApplicationView.GetForCurrentView();
title ??= currentView.Title;
if (parameter != null && _windows.TryGetValue(parameter, out IDispatcherContext value))
{
var newControl = await value.DispatchAsync(async() =>
{
var control = ViewLifetimeControl.GetForCurrentView();
var newAppView = ApplicationView.GetForCurrentView();
await ApplicationViewSwitcher
.SwitchAsync(newAppView.Id, currentView.Id, ApplicationViewSwitchingOptions.Default);
return(control);
}).ConfigureAwait(false);
return(newControl);
}
else
{
//if (ApiInformation.IsPropertyPresent("Windows.UI.ViewManagement.ApplicationView", "PersistedStateId"))
//{
// try
// {
// ApplicationView.ClearPersistedState("Calls");
// }
// catch { }
//}
var newView = CoreApplication.CreateNewView();
var dispatcher = new DispatcherContext(newView.DispatcherQueue);
if (parameter != null)
{
_windows[parameter] = dispatcher;
}
var bounds = Window.Current.Bounds;
var newControl = await dispatcher.DispatchAsync(async() =>
{
var newWindow = Window.Current;
var newAppView = ApplicationView.GetForCurrentView();
newAppView.Title = title;
if (ApiInformation.IsPropertyPresent("Windows.UI.ViewManagement.ApplicationView", "PersistedStateId"))
{
newAppView.PersistedStateId = "Floating";
}
var control = ViewLifetimeControl.GetForCurrentView();
control.Released += (s, args) =>
{
if (parameter != null)
{
_windows.TryRemove(parameter, out IDispatcherContext _);
}
//newWindow.Close();
};
var nav = BootStrapper.Current.NavigationServiceFactory(BootStrapper.BackButton.Ignore, BootStrapper.ExistingContent.Exclude, session, id, false);
nav.Navigate(page, parameter);
newWindow.Content = BootStrapper.Current.CreateRootElement(nav);
newWindow.Activate();
await ApplicationViewSwitcher
.TryShowAsStandaloneAsync(newAppView.Id, ViewSizePreference.Default, currentView.Id, size);
//newAppView.TryResizeView(new Windows.Foundation.Size(360, bounds.Height));
newAppView.TryResizeView(new Size(360, 640));
return(control);
}).ConfigureAwait(false);
return(newControl);
}
}
public async Task <ViewLifetimeControl> OpenAsync(Func <ViewLifetimeControl, UIElement> content, object parameter, double width, double height, ApplicationViewMode viewMode)
{
if (_windows.TryGetValue(parameter, out IDispatcherContext value))
{
var newControl = await value.DispatchAsync(async() =>
{
var control = ViewLifetimeControl.GetForCurrentView();
var newAppView = ApplicationView.GetForCurrentView();
var preferences = ViewModePreferences.CreateDefault(viewMode);
preferences.CustomSize = new Size(width, height);
await ApplicationViewSwitcher
.TryShowAsViewModeAsync(newAppView.Id, viewMode, preferences);
return(control);
}).ConfigureAwait(false);
return(newControl);
}
else
{
var newView = CoreApplication.CreateNewView();
var dispatcher = new DispatcherContext(newView.Dispatcher);
_windows[parameter] = dispatcher;
var newControl = await dispatcher.DispatchAsync(async() =>
{
var newWindow = Window.Current;
newWindow.Closed += (s, args) =>
{
_windows.TryRemove(parameter, out _);
};
newWindow.CoreWindow.Closed += (s, args) =>
{
_windows.TryRemove(parameter, out _);
};
var newAppView = ApplicationView.GetForCurrentView();
newAppView.Consolidated += (s, args) =>
{
_windows.TryRemove(parameter, out _);
newWindow.Close();
};
if (ApiInformation.IsPropertyPresent("Windows.UI.ViewManagement.ApplicationView", "PersistedStateId"))
{
newAppView.PersistedStateId = "Calls";
}
var control = ViewLifetimeControl.GetForCurrentView();
control.Released += (s, args) =>
{
_windows.TryRemove(parameter, out _);
newWindow.Close();
};
newWindow.Content = content(control);
newWindow.Activate();
var preferences = ViewModePreferences.CreateDefault(viewMode);
preferences.CustomSize = new Size(width, height);
await ApplicationViewSwitcher.TryShowAsViewModeAsync(newAppView.Id, viewMode, preferences);
return(control);
}).ConfigureAwait(false);
return(newControl);
}
}
public async Task SwitchToMainViewAsync()
{
await ApplicationViewSwitcher.SwitchAsync(this.MainViewId);
}
public async Task ShowNew()
{
var id = await CreateNewWindow(typeof(MainPage), true);
bool viewShown = await ApplicationViewSwitcher.TryShowAsStandaloneAsync(id);
}
public static async void ShowMainView()
{
bool viewShown = await ApplicationViewSwitcher.TryShowAsStandaloneAsync(MainView.Id);
}
private async Task SwitchViewCommandExecute()
{
await ApplicationViewSwitcher.SwitchAsync(App.MainViewId);
}
private void OnAppLaunch(IActivatedEventArgs args, string argument)
{
// Uncomment the following lines to display frame-rate and per-frame CPU usage info.
//#if _DEBUG
// if (IsDebuggerPresent())
// {
// DebugSettings->EnableFrameRateCounter = true;
// }
//#endif
args.SplashScreen.Dismissed += DismissedEventHandler;
var rootFrame = (Window.Current.Content as Frame);
WeakReference weak = new WeakReference(this);
float minWindowWidth = (float)((double)Resources[ApplicationResourceKeys.Globals.AppMinWindowWidth]);
float minWindowHeight = (float)((double)Resources[ApplicationResourceKeys.Globals.AppMinWindowHeight]);
Size minWindowSize = SizeHelper.FromDimensions(minWindowWidth, minWindowHeight);
ApplicationView appView = ApplicationView.GetForCurrentView();
ApplicationDataContainer localSettings = ApplicationData.Current.LocalSettings;
// For very first launch, set the size of the calc as size of the default standard mode
if (!localSettings.Values.ContainsKey("VeryFirstLaunch"))
{
localSettings.Values["VeryFirstLaunch"] = false;
appView.SetPreferredMinSize(minWindowSize);
appView.TryResizeView(minWindowSize);
}
else
{
ApplicationView.PreferredLaunchWindowingMode = ApplicationViewWindowingMode.Auto;
}
// Do not repeat app initialization when the Window already has content,
// just ensure that the window is active
if (rootFrame == null)
{
if (!Windows.Foundation.Metadata.ApiInformation.IsTypePresent("Windows.Phone.UI.Input.HardwareButtons")) // PC Family
{
// Disable the system view activation policy during the first launch of the app
// only for PC family devices and not for phone family devices
try
{
ApplicationViewSwitcher.DisableSystemViewActivationPolicy();
}
catch (Exception)
{
// Log that DisableSystemViewActionPolicy didn't work
}
}
// Create a Frame to act as the navigation context
rootFrame = App.CreateFrame();
// When the navigation stack isn't restored navigate to the first page,
// configuring the new page by passing required information as a navigation
// parameter
if (!rootFrame.Navigate(typeof(MainPage), argument))
{
// We couldn't navigate to the main page, kill the app so we have a good
// stack to debug
throw new SystemException();
}
SetMinWindowSizeAndThemeAndActivate(rootFrame, minWindowSize);
m_mainViewId = ApplicationView.GetForCurrentView().Id;
AddWindowToMap(WindowFrameService.CreateNewWindowFrameService(rootFrame, false, weak));
}
else
{
// For first launch, LaunchStart is logged in constructor, this is for subsequent launches.
// !Phone check is required because even in continuum mode user interaction mode is Mouse not Touch
if ((UIViewSettings.GetForCurrentView().UserInteractionMode == UserInteractionMode.Mouse) &&
(!Windows.Foundation.Metadata.ApiInformation.IsTypePresent("Windows.Phone.UI.Input.HardwareButtons")))
{
// If the pre-launch hasn't happened then allow for the new window/view creation
if (!m_preLaunched)
{
var newCoreAppView = CoreApplication.CreateNewView();
_ = newCoreAppView.Dispatcher.RunAsync(
CoreDispatcherPriority.Normal, async() =>
{
if (weak.Target is App that)
{
var newRootFrame = App.CreateFrame();
SetMinWindowSizeAndThemeAndActivate(newRootFrame, minWindowSize);
if (!newRootFrame.Navigate(typeof(MainPage), argument))
{
// We couldn't navigate to the main page, kill the app so we have a good
// stack to debug
throw new SystemException();
}
var frameService = WindowFrameService.CreateNewWindowFrameService(newRootFrame, true, weak);
that.AddWindowToMap(frameService);
var dispatcher = CoreWindow.GetForCurrentThread().Dispatcher;
// CSHARP_MIGRATION_ANNOTATION:
// class SafeFrameWindowCreation is being interpreted into a IDisposable class
// in order to enhance its RAII capability that was written in C++/CX
using (var safeFrameServiceCreation = new SafeFrameWindowCreation(frameService, that))
{
int newWindowId = ApplicationView.GetApplicationViewIdForWindow(CoreWindow.GetForCurrentThread());
ActivationViewSwitcher activationViewSwitcher = null;
var activateEventArgs = (args as IViewSwitcherProvider);
if (activateEventArgs != null)
{
activationViewSwitcher = activateEventArgs.ViewSwitcher;
}
if (activationViewSwitcher != null)
{
_ = activationViewSwitcher.ShowAsStandaloneAsync(newWindowId, ViewSizePreference.Default);
safeFrameServiceCreation.SetOperationSuccess(true);
}
else
{
var activatedEventArgs = (args as IApplicationViewActivatedEventArgs);
if ((activatedEventArgs != null) && (activatedEventArgs.CurrentlyShownApplicationViewId != 0))
{
// CSHARP_MIGRATION_ANNOTATION:
// here we don't use ContinueWith() to interpret origin code because we would like to
// pursue the design of class SafeFrameWindowCreate whichi was using RAII to ensure
// some states get handled properly when its instance is being destructed.
//
// To achieve that, SafeFrameWindowCreate has been reinterpreted using IDisposable
// pattern, which forces we use below way to keep async works being controlled within
// a same code block.
var viewShown = await ApplicationViewSwitcher.TryShowAsStandaloneAsync(
frameService.GetViewId(),
ViewSizePreference.Default,
activatedEventArgs.CurrentlyShownApplicationViewId,
ViewSizePreference.Default);
// SafeFrameServiceCreation is used to automatically remove the frame
// from the list of frames if something goes bad.
safeFrameServiceCreation.SetOperationSuccess(viewShown);
}
}
}
}
});
private async Task HideViewCommandExecute()
{
await ApplicationViewSwitcher.SwitchAsync(App.MainViewId,
ApplicationView.GetForCurrentView().Id,
ApplicationViewSwitchingOptions.ConsolidateViews);
}
private async void Button_Click(object sender, RoutedEventArgs e)
{
await ApplicationViewSwitcher.TryShowAsStandaloneAsync(_MainViewId);
}
public static async Task <List <int> > OpenFilesAndCreateNewTabsFiles(int IDList, StorageListTypes type)
{
var list_ids = new List <int>();
switch (type)
{
case StorageListTypes.LocalStorage:
var opener = new FileOpenPicker();
opener.ViewMode = PickerViewMode.Thumbnail;
opener.SuggestedStartLocation = PickerLocationId.ComputerFolder;
opener.FileTypeFilter.Add("*");
IReadOnlyList <StorageFile> files = await opener.PickMultipleFilesAsync();
foreach (StorageFile file in files)
{
await Task.Run(() =>
{
if (file != null)
{
StorageApplicationPermissions.FutureAccessList.Add(file);
var tab = new InfosTab {
TabName = file.Name, TabStorageMode = type, TabContentType = ContentType.File, CanBeDeleted = true, CanBeModified = true, TabOriginalPathContent = file.Path, TabInvisibleByDefault = false, TabType = LanguagesHelper.GetLanguageType(file.Name)
};
int id_tab = Task.Run(async() => { return(await TabsWriteManager.CreateTabAsync(tab, IDList, false)); }).Result;
if (Task.Run(async() => { return(await new StorageRouter(TabsAccessManager.GetTabViaID(new TabID {
ID_Tab = id_tab, ID_TabsList = IDList
}), IDList).ReadFile(true)); }).Result)
{
Messenger.Default.Send(new STSNotification {
Type = TypeUpdateTab.NewTab, ID = new TabID {
ID_Tab = id_tab, ID_TabsList = IDList
}
});
}
list_ids.Add(id_tab);
}
});
}
break;
case StorageListTypes.OneDrive:
var currentAV = ApplicationView.GetForCurrentView(); var newAV = CoreApplication.CreateNewView();
await newAV.Dispatcher.RunAsync(
CoreDispatcherPriority.Normal,
async() =>
{
var newWindow = Window.Current;
var newAppView = ApplicationView.GetForCurrentView();
newAppView.Title = "OneDrive explorer";
var frame = new Frame();
frame.Navigate(typeof(OnedriveExplorer), new Tuple <OnedriveExplorerMode, TabID>(OnedriveExplorerMode.SelectFile, new TabID {
ID_TabsList = IDList
}));
newWindow.Content = frame;
newWindow.Activate();
await ApplicationViewSwitcher.TryShowAsStandaloneAsync(
newAppView.Id,
ViewSizePreference.UseHalf,
currentAV.Id,
ViewSizePreference.UseHalf);
});
break;
}
return(list_ids);
}
public async Task <ViewLifetimeControl> OpenAsync(Type page, object parameter = null, string title = null,
ViewSizePreference size = ViewSizePreference.UseHalf, int session = 0, string id = "0")
{
WriteLine($"Page: {page}, Parameter: {parameter}, Title: {title}, Size: {size}");
var currentView = ApplicationView.GetForCurrentView();
title = title ?? currentView.Title;
if (parameter != null && _windows.TryGetValue(parameter, out DispatcherWrapper value))
{
var newControl = await value.Dispatch(async() =>
{
var control = ViewLifetimeControl.GetForCurrentView();
var newAppView = ApplicationView.GetForCurrentView();
var preferences = ViewModePreferences.CreateDefault(ApplicationViewMode.Default);
preferences.CustomSize = new Windows.Foundation.Size(360, 640);
await ApplicationViewSwitcher
.SwitchAsync(newAppView.Id, currentView.Id, ApplicationViewSwitchingOptions.Default);
return(control);
}).ConfigureAwait(false);
return(newControl);
}
else
{
var newView = CoreApplication.CreateNewView();
var dispatcher = new DispatcherWrapper(newView.Dispatcher);
if (parameter != null)
{
_windows[parameter] = dispatcher;
}
var bounds = Window.Current.Bounds;
var newControl = await dispatcher.Dispatch(async() =>
{
var newWindow = Window.Current;
var newAppView = ApplicationView.GetForCurrentView();
newAppView.Title = title;
var control = ViewLifetimeControl.GetForCurrentView();
control.Released += (s, args) =>
{
if (parameter != null)
{
_windows.TryRemove(parameter, out DispatcherWrapper ciccio);
}
newWindow.Close();
};
var nav = BootStrapper.Current.NavigationServiceFactory(BootStrapper.BackButton.Ignore, BootStrapper.ExistingContent.Exclude, session, id, false);
control.NavigationService = nav;
nav.Navigate(page, parameter);
newWindow.Content = BootStrapper.Current.CreateRootElement(nav);
newWindow.Activate();
await ApplicationViewSwitcher
.TryShowAsStandaloneAsync(newAppView.Id, ViewSizePreference.Default, currentView.Id, size);
//newAppView.TryResizeView(new Windows.Foundation.Size(360, bounds.Height));
newAppView.TryResizeView(new Windows.Foundation.Size(360, 640));
return(control);
}).ConfigureAwait(false);
return(newControl);
}
}
public async void NavigateToWallet(string address = null)
{
Type page;
if (_protoService.Options.WalletPublicKey != null)
{
try
{
var vault = new PasswordVault();
var credential = vault.Retrieve($"{_protoService.SessionId}", _protoService.Options.WalletPublicKey);
}
catch
{
// Credentials for this account wallet don't exist anymore.
_protoService.Options.WalletPublicKey = null;
}
}
if (_protoService.Options.WalletPublicKey != null)
{
if (address == null)
{
page = typeof(WalletPage);
}
else
{
page = typeof(WalletSendPage);
}
}
else
{
page = typeof(WalletCreatePage);
}
//page = typeof(WalletCreatePage);
//Navigate(page, address);
//return;
if (_walletLifetime == null)
{
_walletLifetime = await OpenAsync(page, address);
_walletLifetime.Released += (s, args) =>
{
_walletLifetime = null;
};
if (_walletLifetime.NavigationService is NavigationService service)
{
service.SerializationService = TLSerializationService.Current;
}
}
else
{
await _walletLifetime.CoreDispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
_walletLifetime.NavigationService.Navigate(page, address);
});
await ApplicationViewSwitcher.TryShowAsStandaloneAsync(_walletLifetime.Id, ViewSizePreference.Default, ApplicationView.GetApplicationViewIdForWindow(Window.Current.CoreWindow), ViewSizePreference.UseHalf);
}
}
public async Task <ViewLifetimeControl> OpenAsync(Func <UIElement> content, object parameter, double width, double height)
{
if (_windows.TryGetValue(parameter, out DispatcherWrapper value))
{
var newControl = await value.Dispatch(async() =>
{
var control = ViewLifetimeControl.GetForCurrentView();
var newAppView = ApplicationView.GetForCurrentView();
var preferences = ViewModePreferences.CreateDefault(ApplicationViewMode.CompactOverlay);
preferences.CustomSize = new Size(width, height);
await ApplicationViewSwitcher
.TryShowAsViewModeAsync(newAppView.Id, ApplicationViewMode.CompactOverlay, preferences);
return(control);
}).ConfigureAwait(false);
return(newControl);
}
else
{
var newView = CoreApplication.CreateNewView();
var dispatcher = new DispatcherWrapper(newView.Dispatcher);
_windows[parameter] = dispatcher;
var bounds = Window.Current.Bounds;
var newControl = await dispatcher.Dispatch(async() =>
{
var newWindow = Window.Current;
newWindow.Closed += (s, args) =>
{
_windows.TryRemove(parameter, out DispatcherWrapper ciccio);
};
newWindow.CoreWindow.Closed += (s, args) =>
{
_windows.TryRemove(parameter, out DispatcherWrapper ciccio);
};
var newAppView = ApplicationView.GetForCurrentView();
newAppView.Consolidated += (s, args) =>
{
_windows.TryRemove(parameter, out DispatcherWrapper ciccio);
newWindow.Close();
};
var control = ViewLifetimeControl.GetForCurrentView();
control.Released += (s, args) =>
{
_windows.TryRemove(parameter, out DispatcherWrapper ciccio);
newWindow.Close();
};
newWindow.Content = content();
newWindow.Activate();
var preferences = ViewModePreferences.CreateDefault(ApplicationViewMode.CompactOverlay);
preferences.CustomSize = new Size(width, height);
await ApplicationViewSwitcher
.TryShowAsViewModeAsync(newAppView.Id, ApplicationViewMode.CompactOverlay, preferences);
return(control);
}).ConfigureAwait(false);
return(newControl);
}
}
protected override async void OnFileActivated(FileActivatedEventArgs args)
{
// TODO: Handle file activation
// The number of files received is args.Files.Size
// The first file is args.Files[0].Name
Frame rootFrame = Window.Current.Content as Frame;
// Do not repeat app initialization when the Window already has content,
// just ensure that the window is active
if (rootFrame == null)
{
ApplicationView.GetForCurrentView().SetPreferredMinSize(new Size(320, 320));
// Create a Frame to act as the navigation context and navigate to the first page
rootFrame = new Frame();
NavigationManager = SystemNavigationManager.GetForCurrentView();
NavigationManager.BackRequested += (a, b) => OnBackRequested(a, b);
// Place the frame in the current Window
Window.Current.Content = rootFrame;
}
if (rootFrame.Content == null)
{
// When the navigation stack isn't restored navigate to the first page,
// configuring the new page by passing required information as a navigation
// parameter
rootFrame.Navigate(typeof(MainPage), args.Files[0]);
ApplicationView.GetForCurrentView().Title = args.Files[0].Name.Substring(0, args.Files[0].Name.Length - 4);
NavigationManager = SystemNavigationManager.GetForCurrentView();
NavigationManager.BackRequested += OnBackRequested;
}
else
{
if (!ApiInformation.IsTypePresent("Windows.Phone.UI.Input.HardwareButtons"))
{
var selectedView = await createMainPageAsync(args.Files[0].Name.Substring(0, args.Files[0].Name.Length - 4));
if (null != selectedView)
{
selectedView.StartViewInUse();
var viewShown = await ApplicationViewSwitcher.TryShowAsStandaloneAsync(
selectedView.Id,
ViewSizePreference.Default,
ApplicationView.GetForCurrentView().Id,
ViewSizePreference.Default
);
await selectedView.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
((Frame)Window.Current.Content).Navigate(typeof(MainPage), args.Files[0]);
Window.Current.Activate();
});
selectedView.StopViewInUse();
}
NavigationManager = SystemNavigationManager.GetForCurrentView();
NavigationManager.BackRequested += OnBackRequested;
}
}
Window.Current.Activate();
}
private async void AnimatedSwitch_Click(object sender, RoutedEventArgs e)
{
// The sample demonstrates a general strategy for doing custom animations when switching view
// It's technically only possible to animate the contents of a particular view. But, it is possible
// to animate the outgoing view to some common visual (like a blank background), have the incoming
// view draw that same visual, switch in the incoming window (which will be imperceptible to the
// user since both windows will be showing the same thing), then animate the contents of the incoming
// view in from the common visual.
var selectedItem = ViewChooser.SelectedItem as ViewLifetimeControl;
if (selectedItem != null)
{
try
{
// Prevent the view from being closed while switching to it
selectedItem.StartViewInUse();
// Signal that the window is about to be switched to
// If the view is already shown to the user, then the app
// shouldn't run any extra animations
var currentId = ApplicationView.GetForCurrentView().Id;
bool isViewVisible = await ApplicationViewSwitcher.PrepareForCustomAnimatedSwitchAsync(
selectedItem.Id,
currentId,
ApplicationViewSwitchingOptions.SkipAnimation);
// The view may already be on screen, in which case there's no need to animate its
// contents (or animate out the contents of the current window)
if (!isViewVisible)
{
// The view isn't visible, so animate it on screen
lastFadeOutTime = DateTime.Now;
// Make the current view totally blank. The incoming view is also
// going to be totally blank when the two windows switch
await FadeOutContents();
// Once the current view is blank, switch in the other window
await selectedItem.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
var currentPage = (SecondaryViewPage)((Frame)Window.Current.Content).Content;
// More details are in SecondaryViewPage.xaml.cs
// This function makes the view totally blank, swaps the two view (which
// is not apparent to the user since both windows are blank), then animates
// in the content of newly visible view
currentPage.SwitchAndAnimate(currentId);
});
}
selectedItem.StopViewInUse();
}
catch (InvalidOperationException)
{
// The view could be in the process of closing, and
// this thread just hasn't updated. As part of being closed,
// this thread will be informed to clean up its list of
// views (see SecondaryViewPage.xaml.cs)
}
catch (TaskCanceledException)
{
rootPage.NotifyUser("The animation was canceled. It may have timed out", NotifyType.ErrorMessage);
}
}
else
{
rootPage.NotifyUser("Select a window to see a switch animation. You can create a window in scenario 1", NotifyType.ErrorMessage);
}
}
private async Task <PlayerViewManager> GetEnsureSecondaryView()
{
if (IsMainView && SecondaryCoreAppView == null)
{
var playerView = CoreApplication.CreateNewView();
HohoemaSecondaryViewFrameViewModel vm = null;
int id = 0;
ApplicationView view = null;
INavigationService ns = null;
await playerView.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, async() =>
{
// SecondaryViewのスケジューラをセットアップ
SecondaryViewScheduler = new CoreDispatcherScheduler(playerView.Dispatcher);
playerView.TitleBar.ExtendViewIntoTitleBar = true;
var content = new Views.HohoemaSecondaryViewFrame();
ns = NavigationService.Create(content.Frame, playerView.CoreWindow);
vm = content.DataContext as HohoemaSecondaryViewFrameViewModel;
Window.Current.Content = content;
id = ApplicationView.GetApplicationViewIdForWindow(playerView.CoreWindow);
view = ApplicationView.GetForCurrentView();
view.TitleBar.ButtonBackgroundColor = Windows.UI.Colors.Transparent;
view.TitleBar.ButtonInactiveBackgroundColor = Windows.UI.Colors.Transparent;
Window.Current.Activate();
await ApplicationViewSwitcher.TryShowAsStandaloneAsync(id, ViewSizePreference.UseHalf, MainViewId, ViewSizePreference.UseHalf);
// ウィンドウサイズの保存と復元
if (Services.Helpers.DeviceTypeHelper.IsDesktop)
{
var localObjectStorageHelper = App.Current.Container.Resolve <Microsoft.Toolkit.Uwp.Helpers.LocalObjectStorageHelper>();
if (localObjectStorageHelper.KeyExists(secondary_view_size))
{
view.TryResizeView(localObjectStorageHelper.Read <Size>(secondary_view_size));
}
view.VisibleBoundsChanged += View_VisibleBoundsChanged;
}
view.Consolidated += SecondaryAppView_Consolidated;
});
SecondaryAppView = view;
_SecondaryViewVM = vm;
SecondaryCoreAppView = playerView;
SecondaryViewPlayerNavigationService = ns;
App.Current.Container.GetContainer().RegisterInstance(SECONDARY_VIEW_PLAYER_NAVIGATION_SERVICE, SecondaryViewPlayerNavigationService);
}
return(this);
}
public async Task ActivateAsync(object activationArgs)
{
if (IsActivation(activationArgs))
{
// Initialize things like registering background task before the app is loaded
await InitializeAsync();
// We spawn a separate Window for files.
if (activationArgs is FileActivatedEventArgs fileArgs)
{
bool mainView = Window.Current.Content == null;
void CreateView()
{
FontMapView map = new FontMapView
{
IsStandalone = true,
};
_ = map.ViewModel.LoadFromFileArgsAsync(fileArgs);
// You have to activate the window in order to show it later.
Window.Current.Content = map;
Window.Current.Activate();
}
var view = await WindowService.CreateViewAsync(CreateView, false);
await WindowService.TrySwitchToWindowAsync(view, mainView);
return;
}
// Do not repeat app initialization when the Window already has content,
// just ensure that the window is active
if (WindowService.MainWindow == null)
{
void CreateMainView()
{
// Create a Frame to act as the navigation context and navigate to the first page
Window.Current.Content = new Frame();
NavigationService.Frame.NavigationFailed += (sender, e) => throw new Exception("Failed to load Page " + e.SourcePageType.FullName);
NavigationService.Frame.Navigated += OnFrameNavigated;
if (SystemNavigationManager.GetForCurrentView() != null)
{
SystemNavigationManager.GetForCurrentView().BackRequested += OnAppViewBackButtonRequested;
}
}
var view = await WindowService.CreateViewAsync(CreateMainView, true);
await WindowService.TrySwitchToWindowAsync(view, true);
}
else
{
/* Main Window exists, make it show */
_ = ApplicationViewSwitcher.TryShowAsStandaloneAsync(WindowService.MainWindow.View.Id);
WindowService.MainWindow.CoreView.CoreWindow.Activate();
}
}
try
{
var activationHandler = GetActivationHandlers()?.FirstOrDefault(h => h.CanHandle(activationArgs));
if (activationHandler != null)
{
await activationHandler.HandleAsync(activationArgs);
}
}
catch
{
}
if (IsActivation(activationArgs))
{
var defaultHandler = new DefaultLaunchActivationHandler(_defaultNavItem);
if (defaultHandler.CanHandle(activationArgs))
{
await defaultHandler.HandleAsync(activationArgs);
}
DispatcherHelper.Initialize();
// Ensure the current window is active
Window.Current.Activate();
ApplicationView.PreferredLaunchWindowingMode = ApplicationViewWindowingMode.Auto;
// Tasks after activation
await StartupAsync();
}
}
public async void CreateTool()
{
var num = CoreApplication.Views.Count();
//if (localSettings.Values["newViewId"] != null)
// ApplicationViewSwitcher.SwitchAsync(Convert.ToInt32(localSettings.Values["newViewId"])).Close();
if (localSettings.Values["ItemCount"] == null)
{
localSettings.Values["ItemCount"] = 0;
}
int count = (int)localSettings.Values["ItemCount"];
List <DataTemple> datalist = new List <DataTemple>();
var allData = conn.Query <DataTemple>("select *from DataTemple");
switch (count)
{
case 1:
string a1 = localSettings.Values["DesktopKey0"].ToString();
foreach (var item in allData)
{
if (item.Schedule_name == a1)
{
datalist.Add(item);
}
}
break;
case 2:
string b1 = localSettings.Values["DesktopKey0"].ToString();
string b2 = localSettings.Values["DesktopKey1"].ToString();
foreach (var item in allData)
{
if (item.Schedule_name == b1 || item.Schedule_name == b2)
{
datalist.Add(item);
}
}
break;
case 3:
string c1 = localSettings.Values["DesktopKey0"].ToString();
string c2 = localSettings.Values["DesktopKey1"].ToString();
string c3 = localSettings.Values["DesktopKey2"].ToString();
foreach (var item in allData)
{
if (item.Schedule_name == c1 || item.Schedule_name == c2 || item.Schedule_name == c3)
{
datalist.Add(item);
}
}
break;
default:
return;
}
//var num = CoreApplication.Views.Count();
//coreWindow.Activate();
//CoreApplication.GetCurrentView();
CoreApplicationView newView = CoreApplication.CreateNewView();
int newViewId = 0;
await newView.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
Frame frame = new Frame();
frame.Navigate(typeof(DesktopTool), datalist, new SuppressNavigationTransitionInfo());
Window.Current.Content = frame;
Window.Current.Activate();
newViewId = ApplicationView.GetForCurrentView().Id;
localSettings.Values["newViewId"] = newViewId;
});
bool viewShown = await ApplicationViewSwitcher.TryShowAsStandaloneAsync(newViewId);
localSettings.Values["DesktopPin"] = false;
}
private async void OnRequestReceived(AppServiceConnection sender, AppServiceRequestReceivedEventArgs args)
{
var deferral = args.GetDeferral();
var message = args.Request.Message;
try
{
if (message.ContainsKey("caption") && message.ContainsKey("request"))
{
var caption = message["caption"] as string;
var buffer = message["request"] as string;
var req = TLSerializationService.Current.Deserialize(buffer);
if (caption.Equals("voip.getUser") && req is TLPeerUser userPeer)
{
var user = InMemoryCacheService.Current.GetUser(userPeer.UserId);
if (user != null)
{
await args.Request.SendResponseAsync(new ValueSet { { "result", TLSerializationService.Current.Serialize(user) } });
}
else
{
await args.Request.SendResponseAsync(new ValueSet { { "error", TLSerializationService.Current.Serialize(new TLRPCError {
ErrorMessage = "USER_NOT_FOUND", ErrorCode = 404
}) } });
}
}
else if (caption.Equals("voip.getConfig"))
{
var config = InMemoryCacheService.Current.GetConfig();
await args.Request.SendResponseAsync(new ValueSet { { "result", TLSerializationService.Current.Serialize(config) } });
}
else if (caption.Equals("voip.callInfo") && req is byte[] data)
{
using (var from = new TLBinaryReader(data))
{
var tupleBase = new TLTuple <int, TLPhoneCallBase, TLUserBase, string>(from);
var tuple = new TLTuple <TLPhoneCallState, TLPhoneCallBase, TLUserBase, string>((TLPhoneCallState)tupleBase.Item1, tupleBase.Item2, tupleBase.Item3, tupleBase.Item4);
if (tuple.Item2 is TLPhoneCallDiscarded)
{
if (_phoneView != null)
{
var newView = _phoneView;
_phoneViewExists = false;
_phoneView = null;
await newView.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
newView.SetCall(tuple);
newView.Dispose();
Window.Current.Close();
});
}
return;
}
if (_phoneViewExists == false)
{
VoIPCallTask.Log("Creating VoIP UI", "Creating VoIP UI");
_phoneViewExists = true;
PhoneCallPage newPlayer = null;
CoreApplicationView newView = CoreApplication.CreateNewView();
var newViewId = 0;
await newView.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
newPlayer = new PhoneCallPage();
Window.Current.Content = newPlayer;
Window.Current.Activate();
newViewId = ApplicationView.GetForCurrentView().Id;
newPlayer.SetCall(tuple);
_phoneView = newPlayer;
});
await CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, async() =>
{
if (ApiInformation.IsMethodPresent("Windows.UI.ViewManagement.ApplicationView", "IsViewModeSupported") && ApplicationView.GetForCurrentView().IsViewModeSupported(ApplicationViewMode.CompactOverlay))
{
var preferences = ViewModePreferences.CreateDefault(ApplicationViewMode.CompactOverlay);
preferences.CustomSize = new Size(340, 200);
var viewShown = await ApplicationViewSwitcher.TryShowAsViewModeAsync(newViewId, ApplicationViewMode.CompactOverlay, preferences);
}
else
{
//await ApplicationViewSwitcher.SwitchAsync(newViewId);
await ApplicationViewSwitcher.TryShowAsStandaloneAsync(newViewId);
}
});
}
else if (_phoneView != null)
{
VoIPCallTask.Log("VoIP UI already exists", "VoIP UI already exists");
await _phoneView.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
_phoneView.SetCall(tuple);
});
}
}
}
else if (caption.Equals("voip.setCallRating") && req is TLInputPhoneCall peer)
{
Execute.BeginOnUIThread(async() =>
{
var dialog = new PhoneCallRatingView();
var confirm = await dialog.ShowQueuedAsync();
if (confirm == ContentDialogResult.Primary)
{
await MTProtoService.Current.SetCallRatingAsync(peer, dialog.Rating, dialog.Rating >= 0 && dialog.Rating <= 3 ? dialog.Comment : null);
}
});
}
else
{
var response = await MTProtoService.Current.SendRequestAsync <object>(caption, req as TLObject);
if (response.IsSucceeded)
{
await args.Request.SendResponseAsync(new ValueSet { { "result", TLSerializationService.Current.Serialize(response.Result) } });
}
else
{
await args.Request.SendResponseAsync(new ValueSet { { "error", TLSerializationService.Current.Serialize(response.Error) } });
}
}
}
}
finally
{
deferral.Complete();
}
}
public async Task CloseViewAsync()
{
int currentId = ApplicationView.GetForCurrentView().Id;
await ApplicationViewSwitcher.SwitchAsync(MainViewId, currentId, ApplicationViewSwitchingOptions.ConsolidateViews);
}
public override void Run()
{
UIElement main;
try
{
string layoutString = layoutSetting.XamlString.Value;
layoutFactory = () => (LayoutRoot)XamlReader.Load(layoutString);
var layout = layoutFactory();
main = new MainView {
MainContent = layout.MainWindow.LoadContent()
};
viewIds = layout.SubWindows.Select(x => x.Id).Append("Settings").ToArray();
}
catch
{
layoutFactory = () =>
{
var l = new LayoutRoot();
Application.LoadComponent(l, new Uri("ms-appx:///Layout/Default.xaml"));
return(l);
};
var layout = layoutFactory();
main = new MainView {
MainContent = layout.MainWindow.LoadContent()
};
viewIds = layout.SubWindows.Select(x => x.Id).Append("Settings").ToArray();
}
InitWindow();
new UISettings().ColorValuesChanged += async(sender, _) =>
{
foreach (var view in CoreApplication.Views)
{
await view.Dispatcher.RunAsync(CoreDispatcherPriority.High, () =>
ApplicationView.GetForCurrentView().TitleBar.ButtonForegroundColor = sender.GetColorValue(UIColorType.Foreground));
}
};
var style = new Style
{
TargetType = typeof(ViewPresenter),
};
style.Setters.Add(new Setter(ViewPresenter.ViewSourceProperty, Views));
Application.Current.Resources[typeof(ViewPresenter)] = style;
Application.Current.Resources[ViewSwitcher.SwitchActionKey] = new Action <string>(async viewId =>
{
if (applicationViewIds.TryGetValue(viewId, out int id))
{
await ApplicationViewSwitcher.SwitchAsync(id);
return;
}
if (viewIds.Contains(viewId))
{
var coreView = CoreApplication.CreateNewView();
await coreView.Dispatcher.RunAsync(CoreDispatcherPriority.High, () =>
{
CoreApplication.GetCurrentView().Properties["Id"] = viewId;
var view = ApplicationView.GetForCurrentView();
applicationViewIds[viewId] = view.Id;
InitWindow();
if (viewId == "Settings")
{
Window.Current.Content = new SettingsView(CreateSettingViews(), localizationService);
}
else
{
Window.Current.Content = new SubView {
ActualContent = layoutFactory()[viewId].LoadContent()
}
};
view.Consolidated += (s, e) =>
{
Window.Current.Content = null;
applicationViewIds.TryRemove(viewId, out _);
};
Window.Current.Activate();
});
await ApplicationViewSwitcher.TryShowAsStandaloneAsync(applicationViewIds[viewId]);
}
});
Window.Current.Content = main;
gameProvider.Enabled = true;
}
