private void Page_SizeChanged(object sender, SizeChangedEventArgs e)
        {
            ViewState = ApplicationView.Value;
            if (ViewState == ApplicationViewState.Snapped)
            {
                if (Page.TopAppBar != null)
                {
                    topBar = Page.TopAppBar;
                    Page.TopAppBar = null;
                }
                if (Page.BottomAppBar != null)
                {
                    bottomBar = Page.BottomAppBar;
                    Page.BottomAppBar = null;
                }
            }
            else if (topBar != null || bottomBar != null)
            {
                Page.TopAppBar = topBar;
                Page.BottomAppBar = bottomBar;

                topBar = null;
                bottomBar = null;
            }

            OnApplicationViewStateChanged();
        }

        private static void WindowSizeChanged(object sender, Windows.UI.Core.WindowSizeChangedEventArgs e)
        {

            CurrentViewState = ApplicationView.Value;

            if (CurrentViewState == ApplicationViewState.Filled)
            {
                System.Diagnostics.Debug.WriteLine("viewState is Filled");
            }
            else if (CurrentViewState == ApplicationViewState.FullScreenLandscape)
            {
                System.Diagnostics.Debug.WriteLine("viewState is FullScreenLandscape");
            }
            else if (CurrentViewState == ApplicationViewState.Snapped)
            {
                System.Diagnostics.Debug.WriteLine("viewState is Snapped");
            }
            else if (CurrentViewState == ApplicationViewState.FullScreenPortrait)
            {
                System.Diagnostics.Debug.WriteLine("viewState is FullScreenPortrait");
            }
            else
            {
                System.Diagnostics.Debug.WriteLine("viewState is something unexpected");
            }


            if (OnWindowLayoutRaised != null) OnWindowLayoutRaised(null, new WindowLayoutEventArgs() { ViewState = CurrentViewState, Size = e.Size });

        }

        /// <summary>
        /// Invoked to determine the name of the visual state that corresponds to an application
        /// view state.
        /// </summary>
        /// <param name="viewState">The view state for which the question is being posed.</param>
        /// <returns>The name of the desired visual state.  This is the same as the name of the
        /// view state except when there is a selected item in portrait and snapped views where
        /// this additional logical page is represented by adding a suffix of _Detail.</returns>
        protected override string DetermineVisualState(ApplicationViewState viewState)
        {
            // Update the back button's enabled state when the view state changes
            //TODO-Removing thiss
            var logicalPageBack = this.UsingLogicalPageNavigation(viewState);// && this.itemListView.SelectedItem != null;
            var physicalPageBack = this.Frame != null && this.Frame.CanGoBack;
            this.DefaultViewModel["CanGoBack"] = logicalPageBack || physicalPageBack;

            // Determine visual states for landscape layouts based not on the view state, but
            // on the width of the window.  This page has one layout that is appropriate for
            // 1366 virtual pixels or wider, and another for narrower displays or when a snapped
            // application reduces the horizontal space available to less than 1366.
            if (viewState == ApplicationViewState.Filled ||
                viewState == ApplicationViewState.FullScreenLandscape)
            {
                var windowWidth = Window.Current.Bounds.Width;
                if (windowWidth >= 1366) return "FullScreenLandscapeOrWide";
                return "FilledOrNarrow";
            }

            // When in portrait or snapped start with the default visual state name, then add a
            // suffix when viewing details instead of the list
            var defaultStateName = base.DetermineVisualState(viewState);
            return logicalPageBack ? defaultStateName + "_Detail" : defaultStateName;
        }

 public void SetLayout(ApplicationViewState viewState)
 {
     SnappedView.Visibility = viewState == ApplicationViewState.Snapped
         ? Windows.UI.Xaml.Visibility.Visible
         : Windows.UI.Xaml.Visibility.Collapsed;
     FullView.Visibility = viewState == ApplicationViewState.Snapped
         ? Windows.UI.Xaml.Visibility.Collapsed
         : Windows.UI.Xaml.Visibility.Visible;
 }

 public void SetLayout(ApplicationViewState viewState)
 {
     FullItemGridView.Visibility = viewState == ApplicationViewState.Snapped
         ? Visibility.Collapsed
         : Visibility.Visible;
     SnappedItemGridView.Visibility = viewState == ApplicationViewState.Snapped
         ? Visibility.Visible
         : Visibility.Collapsed;
 }

 public override void SetLayout(ApplicationViewState viewState)
 {
     SnappedView.Visibility = viewState == ApplicationViewState.Snapped
         ? Visibility.Visible
         : Visibility.Collapsed;
     FullView.Visibility = viewState == ApplicationViewState.Snapped
         ? Visibility.Collapsed
         : Visibility.Visible;
 }

        /// <summary>
        /// Invoked to determine the name of the visual state that corresponds to an application
        /// view state.
        /// </summary>
        /// <param name="viewState">The view state for which the question is being posed.</param>
        /// <returns>The name of the desired visual state.  This is the same as the name of the
        /// view state except when there is a selected item in portrait and snapped views where
        /// this additional logical page is represented by adding a suffix of _Detail.</returns>
        protected override string DetermineVisualState(ApplicationViewState viewState)
        {
            // Update the back button's enabled state when the view state changes
            var logicalPageBack = this.UsingLogicalPageNavigation(viewState) && this.itemListView.SelectedItem != null;
            var physicalPageBack = this.Frame != null && this.Frame.CanGoBack;
            this.DefaultViewModel["CanGoBack"] = logicalPageBack || physicalPageBack;

            // Start with the default visual state name, and add a suffix when logical page
            // navigation is in effect and we need to display details instead of the list
            var defaultStateName = base.DetermineVisualState(viewState);
            return logicalPageBack ? defaultStateName + "_Detail" : defaultStateName;
        }

        public override void SetLayout(ApplicationViewState viewState)
        {
            Visibility snappedVisibility = viewState == ApplicationViewState.Snapped
                ? Windows.UI.Xaml.Visibility.Visible
                : Windows.UI.Xaml.Visibility.Collapsed;
            Visibility fullVisibility = viewState != ApplicationViewState.Snapped
                ? Windows.UI.Xaml.Visibility.Visible
                : Windows.UI.Xaml.Visibility.Collapsed;

            SnappedAppBar.Visibility = snappedVisibility;
            SnappedHeader.Visibility = snappedVisibility;
            FullAppBar.Visibility = fullVisibility;
            FullHeader.Visibility = fullVisibility;
        }

        void handleChangeEvents(Size size, ApplicationViewState orientation, bool snapped)
        {
            if (ResponsiveMethods == null)
                return;

            foreach (var method in ResponsiveMethods)
            {
                method.HandleChange(size,
                                    orientation,
                                    snapped,
                                    this.Resources.MergedDictionaries);
            }

        }

        void determineStyle(ApplicationViewState newOrientation, IList<ResourceDictionary> resources)
        {
            //no orientation change has occurred, ignore
            if (newOrientation == ApplicationViewState.Filled)
                return;

            var lastOrientation = state;
            state = newOrientation;

            //some flags to simplify detecting an orientation change
            var wasBlank = (lastOrientation == null);
            var wasPortrait = (lastOrientation == ApplicationViewState.FullScreenPortrait ||
                               lastOrientation == ApplicationViewState.Snapped);
            var wasLandscape = (lastOrientation == ApplicationViewState.FullScreenLandscape);
            var isPortrait = (newOrientation == ApplicationViewState.FullScreenPortrait ||
                              newOrientation == ApplicationViewState.Snapped);
            var isLandscape = (newOrientation == ApplicationViewState.FullScreenLandscape);


            //STYLE SWITCHING

            //only switch on orientation change
            if (isLandscape && (wasBlank || wasPortrait))
            {
                //clear existing responsive styles if any
                removeExistingStyles(resources);

                //add compact style xaml to resources
                if (this.LandscapeStyles != null)
                {
                    foreach (var style in this.LandscapeStyles)
                        resources.Add(style);
                }

            }
            else if (isPortrait && (wasBlank || wasLandscape))
            {
                //clear existing responsive styles if any
                removeExistingStyles(resources);

                //add regular style xaml to resources
                if (this.PortraitStyles != null)
                {
                    foreach (var style in this.PortraitStyles)
                        resources.Add(style);
                }

            }
        }

 protected override string DetermineVisualState(ApplicationViewState viewState)
 {
     // 基于窗口的宽度(而非视图状态)来确定横向布局的
     // 可视状态。此页具有一个适用于
     // 1366 个虚拟像素或更宽的显示屏的布局，还具有一个适用于较窄的显示屏(或对齐的
     // 应用程序将可用水平空间减小为小于 1366 个像素的情况)的布局。
     if (viewState == ApplicationViewState.Filled ||
         viewState == ApplicationViewState.FullScreenLandscape)
     {
         var windowWidth = Window.Current.Bounds.Width;
         if (windowWidth >= 1366) return "FullScreenLandscape";
         return "Filled";
     }
     return base.DetermineVisualState(viewState);
 }

        protected override string DetermineVisualState(ApplicationViewState viewState)
        {
            var logicalPageBack = UsingLogicalPageNavigation(viewState);// && this.itemListView.SelectedItem != null;
            var physicalPageBack = Frame != null && Frame.CanGoBack;
            DefaultViewModel["CanGoBack"] = logicalPageBack || physicalPageBack;

            if (viewState == ApplicationViewState.Filled || viewState == ApplicationViewState.FullScreenLandscape)
            {
                var windowWidth = Window.Current.Bounds.Width;
                if (windowWidth >= 1366)
                    return "FullScreenLandscapeOrWide";
                return "FilledOrNarrow";
            }

            var defaultStateName = base.DetermineVisualState(viewState);
            return defaultStateName;
            return logicalPageBack ? defaultStateName + "_Detail" : defaultStateName;
        }

        /// <summary>
        /// Richiamato per determinare lo stato di visualizzazione corrispondente a quello di
        /// un'applicazione.
        /// </summary>
        /// <param name="viewState">Stato di visualizzazione in merito a cui viene posta la domanda.</param>
        /// <returns>Nome dello stato di visualizzazione desiderato. È lo stesso nome utilizzato per lo
        /// stato di visualizzazione, eccetto quando un elemento è selezionato nelle visualizzazioni Portrait e Snapped, nei cui casi
        /// questa pagina logica aggiuntiva viene rappresentata aggiungendo un suffisso _Detail.</returns>
        protected override string DetermineVisualState(ApplicationViewState viewState)
        {
            // Aggiorna lo stato abilitato del pulsante Indietro quando viene modificato lo stato di visualizzazione
            var logicalPageBack = this.UsingLogicalPageNavigation(viewState) && this.itemListView.SelectedItem != null;
            var physicalPageBack = this.Frame != null && this.Frame.CanGoBack;
            this.DefaultViewModel["CanGoBack"] = logicalPageBack || physicalPageBack;

            // Determinare gli stati di visualizzazione per i layout orizzontali basati non sullo stato di visualizzazione, ma
            // sulla larghezza della finestra. Questa pagina presenta un layout appropriato per
            // almeno 1366 pixel virtuali e un altro per display più stretti o quando un'applicazione ancorata
            // riduce lo spazio orizzontale disponibile a meno di 1366.
            if (viewState == ApplicationViewState.Filled ||
                viewState == ApplicationViewState.FullScreenLandscape)
            {
                var windowWidth = Window.Current.Bounds.Width;
                if (windowWidth >= 1366) return "FullScreenLandscapeOrWide";
                return "FilledOrNarrow";
            }

            // In caso di layout verticale o snapped iniziare con il nome di uno stato di visualizzazione predefinito, quindi aggiungere un
            // suffisso per la visualizzazione dei dettagli anziché l'elenco
            var defaultStateName = base.DetermineVisualState(viewState);
            return logicalPageBack ? defaultStateName + "_Detail" : defaultStateName;
        }

        /// <summary>
        /// Invoked to determine the name of the visual state that corresponds to an application
        /// view state.
        /// </summary>
        /// <param name="viewState">The view state for which the question is being posed.</param>
        /// <returns>The name of the desired visual state.  This is the same as the name of the
        /// view state except when there is a selected item in portrait and snapped views where
        /// this additional logical page is represented by adding a suffix of _Detail.</returns>
        protected override string DetermineVisualState(ApplicationViewState viewState)
        {
            SplitViewModel viewModel = ((SplitViewModel)DataContext);

            viewModel.UsingLogicalPageNavigation = viewState == ApplicationViewState.FullScreenPortrait || viewState == ApplicationViewState.Snapped;
            bool logicalItemView = viewModel.UsingLogicalPageNavigation && viewModel.SelectedItem != null;

            // Determine visual states for landscape layouts based not on the view state, but
            // on the width of the window.  This page has one layout that is appropriate for
            // 1366 virtual pixels or wider, and another for narrower displays or when a snapped
            // application reduces the horizontal space available to less than 1366.
            if (viewState == ApplicationViewState.Filled ||
                viewState == ApplicationViewState.FullScreenLandscape)
            {
                var windowWidth = Window.Current.Bounds.Width;
                if (windowWidth >= 1366) return "FullScreenLandscapeOrWide";
                return "FilledOrNarrow";
            }

            // When in portrait or snapped start with the default visual state name, then add a
            // suffix when viewing details instead of the list
            var defaultStateName = base.DetermineVisualState(viewState);
            return logicalItemView ? defaultStateName + "_Detail" : defaultStateName;
        }

        // Visual state management typically reflects the four application view states directly
        // (full screen landscape and portrait plus snapped and filled views.)  The split page is
        // designed so that the snapped and portrait view states each have two distinct sub-states:
        // either the item list or the details are displayed, but not both at the same time.
        //
        // This is all implemented with a single physical page that can represent two logical
        // pages.  The code below achieves this goal without making the user aware of the
        // distinction.

        /// <summary>
        /// Invoked to determine whether the page should act as one logical page or two.
        /// </summary>
        /// <param name="viewState">The view state for which the question is being posed, or null
        /// for the current view state.  This parameter is optional with null as the default
        /// value.</param>
        /// <returns>True when the view state in question is portrait or snapped, false
        /// otherwise.</returns>
        private bool UsingLogicalPageNavigation(ApplicationViewState? viewState = null)
        {
            if (viewState == null) viewState = ApplicationView.Value;
            return viewState == ApplicationViewState.FullScreenPortrait ||
                viewState == ApplicationViewState.Snapped;
        }

 /// <summary>
 /// Translates <see cref="ApplicationViewState"/> values into strings for visual state
 /// management within the page.  The default implementation uses the names of enum values.
 /// Subclasses may override this method to control the mapping scheme used.
 /// </summary>
 /// <param name="viewState">View state for which a visual state is desired.</param>
 /// <returns>Visual state name used to drive the
 /// <see cref="VisualStateManager"/></returns>
 /// <seealso cref="InvalidateVisualState"/>
 protected virtual string DetermineVisualState(ApplicationViewState viewState)
 {
     return viewState.ToString();
 }

 /// <summary>
 /// Translates <see cref="ApplicationViewState"/> values into strings for visual state
 /// management within the page.  The default implementation uses the names of enum values.
 /// Subclasses may override this method to control the mapping scheme used.
 /// </summary>
 /// <param name="viewState">View state for which a visual state is desired.</param>
 /// <returns>Visual state name used to drive the
 /// <see cref="VisualStateManager"/></returns>
 /// <seealso cref="InvalidateVisualState"/>
 private static string DetermineVisualState(ApplicationViewState viewState)
 {
     return viewState.ToString();
 }

        /// <summary>
        /// アプリケーションのビューステートに対応する表示状態の名前を確認するために
        /// 呼び出されます。
        /// </summary>
        /// <param name="viewState">問題が発生しているビューステートです。</param>
        /// <returns>目的の表示状態の名前。これは、縦向きビューおよびスナップ 
        /// ビューでアイテムが選択され、_Detail というサフィックスが追加されたこの追加の論理ページが
        /// 存在している場合を除き、ビューステートの名前と同じです。</returns>
        protected override string DetermineVisualState(ApplicationViewState viewState)
        {
            // ビューステートが変更されたときに [戻る] が有効にされている状態を更新します
            var logicalPageBack = this.UsingLogicalPageNavigation(viewState);
            var physicalPageBack = this.Frame != null && this.Frame.CanGoBack;
            this.DefaultViewModel["CanGoBack"] = logicalPageBack || physicalPageBack;

            // ビューステートではなくウィンドウの幅を基にして横向きレイアウトの表示状態を
            // 決定します。このページの 1 つのレイアウトは 1366 仮想ピクセル以上に適しており、
            // 別のレイアウトはより幅が狭いディスプレイや、スナップされたアプリケーションによって
            // 表示可能な横のスペースが 1366 未満に狭められている場合に適しています。
            if (viewState == ApplicationViewState.Filled ||
                viewState == ApplicationViewState.FullScreenLandscape)
            {
                var windowWidth = Window.Current.Bounds.Width;
                if (windowWidth >= 1366) return "FullScreenLandscapeOrWide";
                return "FilledOrNarrow";
            }

            // 既定の表示状態の名前で縦向きまたはスナップで開始される場合には、
            // リストではなく詳細を表示するときにサフィックスを追加します
            var defaultStateName = base.DetermineVisualState(viewState);
            return logicalPageBack ? defaultStateName + "_Detail" : defaultStateName;
        }

 protected void SetState(ApplicationViewState state)
 {
     SetState(state.ToString());
 }

        void OnApplicationViewChanged(object sender, ViewStateChangedEventArgs e)
        {
            ApplicationViewState = e.ViewState;

            // Update the world viewport based on the view state
            if (ApplicationViewState == ApplicationViewState.FullScreenLandscape)
            {
                WorldViewport.Width = 1600;
                WorldViewport.Height = 900;
            }
            if (ApplicationViewState == ApplicationViewState.FullScreenPortrait)
            {
                WorldViewport.Width = 900;
                WorldViewport.Height = 1600;
            }
            if (ApplicationViewState == ApplicationViewState.Snapped)
            {
                WorldViewport.Width = GraphicsManager.ScreenViewport.Width;
                WorldViewport.Height = GraphicsManager.ScreenViewport.Height;
            }
            if (ApplicationViewState == ApplicationViewState.Filled)
            {
                WorldViewport.Width = 1600;
                WorldViewport.Height = 1200;
            }

            // Show the windows mouse if the game is snapped (to make it easier to change back to a supported state)
            IsMouseVisible = ApplicationViewState == ApplicationViewState.Snapped ? true : false;
        }