C# Window.GetScreen方法代码示例

        private void OnLoaded(object sender, RoutedEventArgs e)
        {
            //Get references to window, screen, toastNotification and mainViewModel
            window = Window.GetWindow(this);
            screen = window.GetScreen();
            toastNotification = VisualAndLogicalTreeHelper.FindLogicalChildren<ToastNotification>(this).First();
            var mainViewModel = DataContext as MainViewModel;

            //Handle ToastNotification event
            mainViewModel.ToastNotification += (o, args) =>
            {
                SetSizeAndPosition();

                Title = args.Title;
                Content = args.Content;
                NotificationType = args.NotificationType;

                Action closePopup = () =>
                {
                    if (IsOpen)
                    {
                        IsOpen = false;
                        if (args.Callback != null)
                        {
                            args.Callback();
                        }
                    }
                };

                AnimateTarget(args.Content, toastNotification, closePopup);
                IsOpen = true;
            };
        }

        private void OnLoaded(object sender, RoutedEventArgs e)
        {
            //Get references to window, screen and mainViewModel
            window = Window.GetWindow(this);
            screen = window.GetScreen();
            var mainViewModel = DataContext as MainViewModel;

            //Listen for MagnifyPoint changes
            mainViewModel.OnPropertyChanges(vm => vm.MagnifyAtPoint).Subscribe(sourcePoint =>
            {
                if (sourcePoint != null)
                {
                    SetSizeAndPosition();

                    DisplayScaledScreenshot(sourcePoint.Value);

                    EventHandler<Point> pointSelectionHandler = null;
                    pointSelectionHandler = (pointSelectionSender, point) =>
                    {
                        mainViewModel.PointSelection -= pointSelectionHandler; //Only react to one PointSelection event
                        
                        Point? destinationPoint = TranslateMagnifiedSelectionPoint(point);
                        
                        IsOpen = false; //Close popup before clicking - destination point may be under the magnified image
                        
                        if (mainViewModel.MagnifiedPointSelectionAction != null)
                        {
                            mainViewModel.MagnifiedPointSelectionAction(destinationPoint);
                        }
                    };
                    mainViewModel.PointSelection += pointSelectionHandler;

                    IsOpen = true;
                }
            });
            
            //Subscribe to window location changes and re-evaluate the current screen and current position
            Observable.FromEventPattern<EventHandler, EventArgs>
                (h => window.LocationChanged += h,
                 h => window.LocationChanged -= h)
                .Throttle(TimeSpan.FromSeconds(0.1))
                .ObserveOnDispatcher()
                .Subscribe(_ =>
                {
                    Log.Debug("Window's LocationChanged event detected.");
                    screen = window.GetScreen();
                });
        }

        internal WindowManipulationService(
            Window window,
            Func<double> getOpacity,
            Func<WindowStates> getWindowState,
            Func<WindowStates> getPreviousWindowState,
            Func<Rect> getFloatingSizeAndPosition,
            Func<DockEdges> getDockPosition,
            Func<DockSizes> getDockSize,
            Func<double> getFullDockThicknessAsPercentageOfScreen,
            Func<double> getCollapsedDockThicknessAsPercentageOfFullDockThickness,
            Func<MinimisedEdges> getMinimisedPosition,
            Action<double> saveOpacity,
            Action<WindowStates> saveWindowState,
            Action<WindowStates> savePreviousWindowState,
            Action<Rect> saveFloatingSizeAndPosition,
            Action<DockEdges> saveDockPosition,
            Action<DockSizes> saveDockSize,
            Action<double> saveFullDockThicknessAsPercentageOfScreen,
            Action<double> saveCollapsedDockThicknessAsPercentageOfFullDockThickness)
        {
            this.window = window;
            this.getOpacity = getOpacity;
            this.getWindowState = getWindowState;
            this.getPreviousWindowState = getPreviousWindowState;
            this.getDockPosition = getDockPosition;
            this.getDockSize = getDockSize;
            this.getFullDockThicknessAsPercentageOfScreen = getFullDockThicknessAsPercentageOfScreen;
            this.getCollapsedDockThicknessAsPercentageOfFullDockThickness = getCollapsedDockThicknessAsPercentageOfFullDockThickness;
            this.getMinimisedPosition = getMinimisedPosition;
            this.getFloatingSizeAndPosition = getFloatingSizeAndPosition;
            this.saveOpacity = saveOpacity;
            this.saveWindowState = saveWindowState;
            this.savePreviousWindowState = savePreviousWindowState;
            this.saveFloatingSizeAndPosition = saveFloatingSizeAndPosition;
            this.saveDockPosition = saveDockPosition;
            this.saveDockSize = saveDockSize;
            this.saveFullDockThicknessAsPercentageOfScreen = saveFullDockThicknessAsPercentageOfScreen;
            this.saveCollapsedDockThicknessAsPercentageOfFullDockThickness = saveCollapsedDockThicknessAsPercentageOfFullDockThickness;

            windowHandle = new WindowInteropHelper(window).EnsureHandle();
            screen = window.GetScreen();
            screenBoundsInPx = new Rect(screen.Bounds.Left, screen.Bounds.Top, screen.Bounds.Width, screen.Bounds.Height);
            var screenBoundsTopLeftInDp = window.GetTransformFromDevice().Transform(screenBoundsInPx.TopLeft);
            var screenBoundsBottomRightInDp = window.GetTransformFromDevice().Transform(screenBoundsInPx.BottomRight);
            screenBoundsInDp = new Rect(screenBoundsTopLeftInDp.X, screenBoundsTopLeftInDp.Y,
                screenBoundsBottomRightInDp.X - screenBoundsTopLeftInDp.X,
                screenBoundsBottomRightInDp.Y - screenBoundsTopLeftInDp.Y);

            CoerceSavedStateAndApply();

            window.Closed += (_, __) => UnRegisterAppBar();
        }

        private void OnLoaded(object sender, RoutedEventArgs e)
        {
            //Apply and subscribe to cursor height setting changes
            Action applyCursorHeight = () =>
            {
                var cursorHeightInPx = Settings.Default.CursorHeightInPixels / Graphics.DipScalingFactorY;
                MaxHeight = MinHeight = Height = cursorHeightInPx;
                CalculatePosition();
            };
            Settings.Default.OnPropertyChanges(s => s.CursorHeightInPixels).Subscribe(_ => applyCursorHeight());
            applyCursorHeight();

            //Apply and subscribe to cursor width setting changes
            Action applyCursorWidth = () =>
            {
                var cursorWidthInPx = Settings.Default.CursorWidthInPixels / Graphics.DipScalingFactorX;
                MaxWidth = MinWidth = Width = cursorWidthInPx;
                CalculatePosition();
            };
            Settings.Default.OnPropertyChanges(s => s.CursorWidthInPixels).Subscribe(_ => applyCursorWidth());
            applyCursorWidth();

            //Get references to window, screen and mainViewModel
            window = Window.GetWindow(this);
            Screen = window.GetScreen();
            var mainViewModel = DataContext as MainViewModel;

            //IsOpen
            Action<bool> calculateIsOpen = showCursor => IsOpen = showCursor;
            mainViewModel.OnPropertyChanges(vm => vm.ShowCursor).Subscribe(calculateIsOpen);
            calculateIsOpen(mainViewModel.ShowCursor);

            //Calculate position based on CurrentPositionPoint
            mainViewModel.OnPropertyChanges(vm => vm.CurrentPositionPoint)
                .Where(cpp => cpp != null && SelectionProgress == 0) //Only set current Point if we are not within a selection/fixation
                .Subscribe(cpp => Point = cpp.Value);

            //Calculate selection progress and position based on PointSelectionProgress
            mainViewModel.OnPropertyChanges(vm => vm.PointSelectionProgress)
                .Subscribe(psp =>
                {
                    if (psp == null)
                    {
                        //Selection/fixation not in progress
                        SelectionProgress = 0;
                    }
                    else
                    {
                        //Selection/fixation in progress
                        Point = psp.Item1;
                        SelectionProgress = psp.Item2;
                    }
                });

            SelectionProgress = mainViewModel.PointSelectionProgress != null
                ? mainViewModel.PointSelectionProgress.Item2
                : 0;

            //Subscribe to window location changes and re-evaluate the current screen and current position
            Observable.FromEventPattern<EventHandler, EventArgs>
                (h => window.LocationChanged += h,
                 h => window.LocationChanged -= h)
                .Throttle(TimeSpan.FromSeconds(0.1))
                .ObserveOnDispatcher()
                .Subscribe(_ =>
                {
                    Log.Debug("Window's LocationChanged event detected.");
                    Screen = window.GetScreen();
                });
        }