public static INavigationService Create(Frame frame, CoreWindow window, params Gestures[] gestures)
        {
            frame = frame ?? new Frame();
            var gesture_service    = GestureService.GetForCurrentView(window);
            var navigation_service = new NavigationService(frame);

            foreach (var gesture in gestures)
            {
                switch (gesture)
                {
                case Gestures.Back:
                    gesture_service.BackRequested += async(s, e) => await navigation_service.GoBackAsync();

                    break;

                case Gestures.Forward:
                    gesture_service.ForwardRequested += async(s, e) => await navigation_service.GoForwardAsync();

                    break;

                case Gestures.Refresh:
                    gesture_service.RefreshRequested += async(s, e) => await navigation_service.RefreshAsync();

                    break;
                }
            }
            return(navigation_service);
        }
Example #2
0
        public static INavigationService AttachGestures(this INavigationService service, Window window, params Gesture[] gestures)
        {
            INavigationService2 service2        = service as INavigationService2;
            IGestureService     gesture_service = GestureService.GetForCurrentView(window.CoreWindow);

            foreach (Gesture gesture in gestures)
            {
                switch (gesture)
                {
                case Gesture.Back:
                    AddOnlyOne(gesture_service.BackRequestedCallbacks, service2.FrameFacade.Id, async() => await service.GoBackAsync());
                    break;

                case Gesture.Forward:
                    AddOnlyOne(gesture_service.ForwardRequestedCallbacks, service2.FrameFacade.Id, async() => await service.GoForwardAsync());
                    break;

                case Gesture.Refresh:
                    AddOnlyOne(gesture_service.RefreshRequestedCallbacks, service2.FrameFacade.Id, async() => await service.RefreshAsync());
                    break;
                }
            }
            return(service);

            void AddOnlyOne(Dictionary <string, Action> dictionary, string id, Action action)
            {
                dictionary.Remove(id);
                dictionary.Add(id, action);
            }
        }
Example #3
0
        public ShellPage(IDialogService dialogService, IDataService dataService, IEventAggregator eventAggregator)
        {
            InitializeComponent();

            if (win.ApplicationModel.DesignMode.DesignModeEnabled)
            {
                return;
            }

            _dialogService = dialogService;
            _dataService   = dataService;

            _gestureService = GestureService.GetForCurrentView();
            _gestureService.MenuRequested   += (s, e) => ShellView.IsPaneOpen = true;
            _gestureService.SearchRequested += (s, e) =>
            {
                ShellView.IsPaneOpen = true;
                ShellView.AutoSuggestBox?.Focus(FocusState.Programmatic);
            };

            _eventAggregator = eventAggregator;
            _eventAggregator.GetEvent <Messages.ShowEditorMessage>().Subscribe(item =>
            {
                EditSplitView.IsPaneOpen = true;
                SideEditView.DataContext = item;
            });

            ShellView.Initialize();
        }
Example #4
0
 public override void RegisterTypes(IContainerRegistry container)
 {
     container.Register <IDataService, DataService>();
     container.Register <IJumpListService, JumpListService>();
     container.RegisterInstance(new Lazy <IGestureService>(() => GestureService.GetForCurrentView()));
     container.RegisterForNavigation <MainPage, MainPageViewModel>(nameof(MainPage));
     container.RegisterForNavigation <ItemPage, ItemPageViewModel>(nameof(ItemPage));
 }
Example #5
0
        public ShellPage(IDialogService dialogService, IDataService dataService)
        {
            InitializeComponent();

            if (win.ApplicationModel.DesignMode.DesignModeEnabled)
            {
                return;
            }

            _gestureService = GestureService.GetForCurrentView();
            _dialogService  = dialogService;
            _dataService    = dataService;

            ShellView.Initialize();
            ShellView.Loaded += (s, e) =>
            {
                SetupGestures();
            };
        }
Example #6
0
        private void SetupBackButton()
        {
            var children = XamlUtilities.RecurseChildren(this);
            var grids    = children.OfType <Grid>();
            var grid     = grids.Single(x => x.Name == "TogglePaneTopPadding");

            grid.Visibility = Visibility.Collapsed;

            grid = grids.Single(x => x.Name == "ContentPaneTopPadding");
            grid.RegisterPropertyChangedCallback(HeightProperty, (s, args) =>
            {
                if (grid.Height != 44d)
                {
                    grid.Height = 44d;
                }
            });
            grid.Height = 44d;

            var child_buttons = children.OfType <Button>();

            _togglePaneButton = child_buttons.Single(x => x.Name == "TogglePaneButton");
            _togglePaneButton.RegisterPropertyChangedCallback(MarginProperty, (s, args) =>
            {
                if (_togglePaneButton.Margin.Top != 0)
                {
                    _togglePaneButton.Margin = new Thickness(0, 0, 0, 32);
                }
            });
            _togglePaneButton.Margin = new Thickness(0, 0, 0, 32);
            _togglePaneButton.Focus(FocusState.Programmatic);

            var parent_grid = _togglePaneButton.Parent as Grid;

            parent_grid.Width = double.NaN;
            parent_grid.ColumnDefinitions.Add(new ColumnDefinition {
                Width = new GridLength(48)
            });
            parent_grid.ColumnDefinitions.Add(new ColumnDefinition {
            });
            parent_grid.RowDefinitions[0].Height = GridLength.Auto;
            parent_grid.RowDefinitions[1].Height = GridLength.Auto;

            _paneTitleTextBlock = new TextBlock
            {
                Name              = "PaneTitleTextBlock",
                Margin            = new Thickness(8, 18, 0, 0),
                FontSize          = 15,
                FontFamily        = new FontFamily("Segoe UI Bold"),
                TextWrapping      = TextWrapping.NoWrap,
                Foreground        = Resources["SystemControlForegroundBaseHighBrush"] as Brush,
                VerticalAlignment = VerticalAlignment.Top,
                IsHitTestVisible  = false,
                Text              = "Jerry Nixon",
            };
            _paneTitleTextBlock.SetValue(Grid.ColumnProperty, 1);
            _paneTitleTextBlock.SetValue(Grid.RowProperty, 1);
            _paneTitleTextBlock.SetValue(Canvas.ZIndexProperty, 100);
            // parent_grid.Children.Add(_paneTitleTextBlock);

            _backButton = new Button
            {
                Name    = "BackButton",
                Content = new SymbolIcon
                {
                    Symbol           = Symbol.Back,
                    IsHitTestVisible = false
                },
                Style = Resources["PaneToggleButtonStyle"] as Style,
            };
            _backButton.SetValue(Canvas.ZIndexProperty, 100);
            parent_grid.Children.Insert(1, _backButton);

            NavigationService.CanGoBackChanged += (s, args) =>
            {
                _backButton.IsEnabled = NavigationService.CanGoBack();
            };

            _backButton.Click += (s, args) =>
            {
                var gesture_service = GestureService.GetForCurrentView();
                gesture_service.RaiseBackRequested();
            };
        }
Example #7
0
        private void ToggleFullScreenWhenApplicationViewShowWithStandalone()
        {
            CurrentViewScheduler.Schedule(() =>
            {
                if (_backGestureBarrier != null)
                {
                    _backGestureBarrier.Complete();
                    _backGestureBarrier = null;
                }

                if (IsPlayingWithPrimaryView && !IsPlayerSmallWindowModeEnabled)
                {
                    var gestureService         = GestureService.GetForCurrentView();
                    _backGestureBarrier        = gestureService.CreateBarrier(Gesture.Back);
                    _backGestureBarrier.Event += (_, e) => IsPlayerSmallWindowModeEnabled = false;
                }

                ApplicationView currentView = Windows.UI.ViewManagement.ApplicationView.GetForCurrentView();

                if (Services.Helpers.DeviceTypeHelper.IsMobile || Services.Helpers.DeviceTypeHelper.IsDesktop)
                {
                    if (NowPlaying)
                    {
                        if (IsPlayerSmallWindowModeEnabled)
                        {
                            if (currentView.IsFullScreenMode)
                            {
                                currentView.ExitFullScreenMode();
                            }
                        }
                        else if (currentView.AdjacentToLeftDisplayEdge && currentView.AdjacentToRightDisplayEdge)
                        {
                            currentView.TryEnterFullScreenMode();
                        }
                    }
                    else
                    {
                        // プレイヤーを閉じた時にCompactOverlayも解除する
                        if (ApiInformation.IsApiContractPresent("Windows.Foundation.UniversalApiContract", 4))
                        {
                            if (currentView.IsViewModeSupported(ApplicationViewMode.CompactOverlay) &&
                                currentView.ViewMode == ApplicationViewMode.CompactOverlay)
                            {
                                _ = currentView.TryEnterViewModeAsync(ApplicationViewMode.Default);
                            }
                        }

                        if (!IsPlayerSmallWindowModeEnabled)
                        {
                            if (IsPlayerShowWithPrimaryView && IsMainView)
                            {
                                if (ApplicationView.PreferredLaunchWindowingMode != ApplicationViewWindowingMode.FullScreen)
                                {
                                    currentView.ExitFullScreenMode();
                                }
                            }
                        }
                    }
                }
            });
        }