summaryrefslogtreecommitdiff
path: root/Xamarin.Forms.ControlGallery.WP8/App.xaml.cs
diff options
context:
space:
mode:
Diffstat (limited to 'Xamarin.Forms.ControlGallery.WP8/App.xaml.cs')
-rw-r--r--Xamarin.Forms.ControlGallery.WP8/App.xaml.cs234
1 files changed, 234 insertions, 0 deletions
diff --git a/Xamarin.Forms.ControlGallery.WP8/App.xaml.cs b/Xamarin.Forms.ControlGallery.WP8/App.xaml.cs
new file mode 100644
index 00000000..6b43e3b7
--- /dev/null
+++ b/Xamarin.Forms.ControlGallery.WP8/App.xaml.cs
@@ -0,0 +1,234 @@
+´╗┐using System;
+using System.Diagnostics;
+using System.Resources;
+using System.Windows;
+using System.Windows.Markup;
+using System.Windows.Navigation;
+using Microsoft.Phone.Controls;
+using Microsoft.Phone.Shell;
+using Xamarin.Forms.ControlGallery.WP8.Resources;
+
+using Application = Xamarin.Forms.Application;
+
+namespace Xamarin.Forms.ControlGallery.WP8
+{
+ public partial class App : System.Windows.Application
+ {
+ /// <summary>
+ /// Provides easy access to the root frame of the Phone Application.
+ /// </summary>
+ /// <returns>The root frame of the Phone Application.</returns>
+ public static PhoneApplicationFrame RootFrame { get; private set; }
+
+ /// <summary>
+ /// Constructor for the Application object.
+ /// </summary>
+ public App()
+ {
+ if (!Debugger.IsAttached)
+ Insights.Initialize (Controls.App.Secrets["InsightsApiKey"]);
+
+ FormsMaps.Init (Controls.App.Secrets["WP8AppId"], Controls.App.Secrets["WP8AuthToken"]);
+
+ // Global handler for uncaught exceptions.
+ UnhandledException += Application_UnhandledException;
+
+ // Standard XAML initialization
+ InitializeComponent();
+
+ // Phone-specific initialization
+ InitializePhoneApplication();
+
+ // Language display initialization
+ InitializeLanguage();
+
+ // Show graphics profiling information while debugging.
+ if (Debugger.IsAttached)
+ {
+ // Display the current frame rate counters.
+ Current.Host.Settings.EnableFrameRateCounter = true;
+
+ // Show the areas of the app that are being redrawn in each frame.
+ //Application.Current.Host.Settings.EnableRedrawRegions = true;
+
+ // Enable non-production analysis visualization mode,
+ // which shows areas of a page that are handed off to GPU with a colored overlay.
+ //Application.Current.Host.Settings.EnableCacheVisualization = true;
+
+ // Prevent the screen from turning off while under the debugger by disabling
+ // the application's idle detection.
+ // Caution:- Use this under debug mode only. Application that disables user idle detection will continue to run
+ // and consume battery power when the user is not using the phone.
+ PhoneApplicationService.Current.UserIdleDetectionMode = IdleDetectionMode.Disabled;
+ }
+
+ }
+
+ // Code to execute when the application is launching (eg, from Start)
+ // This code will not execute when the application is reactivated
+ void Application_Launching(object sender, LaunchingEventArgs e)
+ {
+ Debug.WriteLine ("Launching");
+ }
+
+ // Code to execute when the application is activated (brought to foreground)
+ // This code will not execute when the application is first launched
+ void Application_Activated(object sender, ActivatedEventArgs e)
+ {
+ Debug.WriteLine ("Closing");
+ }
+
+ // Code to execute when the application is deactivated (sent to background)
+ // This code will not execute when the application is closing
+ void Application_Deactivated(object sender, DeactivatedEventArgs e)
+ {
+ Debug.WriteLine ("Deactivated");
+ }
+
+ // Code to execute when the application is closing (eg, user hit Back)
+ // This code will not execute when the application is deactivated
+ void Application_Closing(object sender, ClosingEventArgs e)
+ {
+ Debug.WriteLine ("Closing");
+ }
+
+ // Code to execute if a navigation fails
+ void RootFrame_NavigationFailed(object sender, NavigationFailedEventArgs e)
+ {
+ if (Debugger.IsAttached)
+ {
+ // A navigation has failed; break into the debugger
+ Debugger.Break();
+ }
+ }
+
+ // Code to execute on Unhandled Exceptions
+ void Application_UnhandledException(object sender, ApplicationUnhandledExceptionEventArgs e)
+ {
+ if (Debugger.IsAttached)
+ {
+ // An unhandled exception has occurred; break into the debugger
+ Debugger.Break();
+ }
+ }
+
+ #region Phone application initialization
+
+ // Avoid double-initialization
+ bool _phoneApplicationInitialized = false;
+
+ // Do not add any additional code to this method
+ void InitializePhoneApplication()
+ {
+ if (_phoneApplicationInitialized)
+ return;
+
+ // Create the frame but don't set it as RootVisual yet; this allows the splash
+ // screen to remain active until the application is ready to render.
+ RootFrame = new PhoneApplicationFrame();
+ RootFrame.Navigated += CompleteInitializePhoneApplication;
+
+ // Handle navigation failures
+ RootFrame.NavigationFailed += RootFrame_NavigationFailed;
+
+ // Handle reset requests for clearing the backstack
+ RootFrame.Navigated += CheckForResetNavigation;
+
+ // Ensure we don't initialize again
+ _phoneApplicationInitialized = true;
+ }
+
+ // Do not add any additional code to this method
+ void CompleteInitializePhoneApplication(object sender, System.Windows.Navigation.NavigationEventArgs e)
+ {
+ // Set the root visual to allow the application to render
+ if (RootVisual != RootFrame)
+ RootVisual = RootFrame;
+
+ // Remove this handler since it is no longer needed
+ RootFrame.Navigated -= CompleteInitializePhoneApplication;
+ }
+
+ void CheckForResetNavigation(object sender, System.Windows.Navigation.NavigationEventArgs e)
+ {
+ // If the app has received a 'reset' navigation, then we need to check
+ // on the next navigation to see if the page stack should be reset
+ if (e.NavigationMode == NavigationMode.Reset)
+ RootFrame.Navigated += ClearBackStackAfterReset;
+ }
+
+ void ClearBackStackAfterReset(object sender, System.Windows.Navigation.NavigationEventArgs e)
+ {
+ // Unregister the event so it doesn't get called again
+ RootFrame.Navigated -= ClearBackStackAfterReset;
+
+ // Only clear the stack for 'new' (forward) and 'refresh' navigations
+ if (e.NavigationMode != NavigationMode.New && e.NavigationMode != NavigationMode.Refresh)
+ return;
+
+ // For UI consistency, clear the entire page stack
+ while (RootFrame.RemoveBackEntry() != null)
+ {
+ ; // do nothing
+ }
+ }
+
+ #endregion
+
+ // Initialize the app's font and flow direction as defined in its localized resource strings.
+ //
+ // To ensure that the font of your application is aligned with its supported languages and that the
+ // FlowDirection for each of those languages follows its traditional direction, ResourceLanguage
+ // and ResourceFlowDirection should be initialized in each resx file to match these values with that
+ // file's culture. For example:
+ //
+ // AppResources.es-ES.resx
+ // ResourceLanguage's value should be "es-ES"
+ // ResourceFlowDirection's value should be "LeftToRight"
+ //
+ // AppResources.ar-SA.resx
+ // ResourceLanguage's value should be "ar-SA"
+ // ResourceFlowDirection's value should be "RightToLeft"
+ //
+ // For more info on localizing Windows Phone apps see http://go.microsoft.com/fwlink/?LinkId=262072.
+ //
+ void InitializeLanguage()
+ {
+ try
+ {
+ // Set the font to match the display language defined by the
+ // ResourceLanguage resource string for each supported language.
+ //
+ // Fall back to the font of the neutral language if the Display
+ // language of the phone is not supported.
+ //
+ // If a compiler error is hit then ResourceLanguage is missing from
+ // the resource file.
+ RootFrame.Language = XmlLanguage.GetLanguage(AppResources.ResourceLanguage);
+
+ // Set the FlowDirection of all elements under the root frame based
+ // on the ResourceFlowDirection resource string for each
+ // supported language.
+ //
+ // If a compiler error is hit then ResourceFlowDirection is missing from
+ // the resource file.
+ FlowDirection flow = (FlowDirection)Enum.Parse(typeof(FlowDirection), AppResources.ResourceFlowDirection);
+ RootFrame.FlowDirection = flow;
+ }
+ catch
+ {
+ // If an exception is caught here it is most likely due to either
+ // ResourceLangauge not being correctly set to a supported language
+ // code or ResourceFlowDirection is set to a value other than LeftToRight
+ // or RightToLeft.
+
+ if (Debugger.IsAttached)
+ {
+ Debugger.Break();
+ }
+
+ throw;
+ }
+ }
+ }
+}