diff options
Diffstat (limited to 'Xamarin.Forms.ControlGallery.WP8/App.xaml.cs')
-rw-r--r-- | Xamarin.Forms.ControlGallery.WP8/App.xaml.cs | 234 |
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; + } + } + } +} |