C# Forms.Screen类代码示例

        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;
            };
        }

 /// <summary>
 /// Sizes to screen.
 /// </summary>
 /// <param name="screen">
 /// The screen.
 /// </param>
 public void SizeToScreen(Screen screen)
 {
     this.Left = screen.WorkingArea.Left;
     this.Top = screen.WorkingArea.Top;
     this.Width = screen.WorkingArea.Width;
     this.Height = screen.WorkingArea.Height;
 }

        private void AddPanel(Screen screen)
        {
            switch (screen)
            {
                case Screen.Product:
                    if (_UC_PRODUCT == null) _UC_PRODUCT = new UcDataProduct();
                    _USER_CONTROL = _UC_PRODUCT;
                    break;
                case Screen.Claim:
                    if (_UC_CLAIM == null) _UC_CLAIM = new UcClaim();
                    _USER_CONTROL = _UC_CLAIM;
                    break;
                case Screen.StockMonitor:
                    if (_UC_STOCK_MONITOR == null) _UC_STOCK_MONITOR = new UcStockMonitor();
                    _USER_CONTROL = _UC_STOCK_MONITOR;
                    break;
                case Screen.Report:
                    if (_UC_REPORT == null) _UC_REPORT = new UcReport();
                    _USER_CONTROL = _UC_REPORT;
                    break;
                case Screen.Member:
                    if (_UC_MEMBER == null) _UC_MEMBER = new UcMember();
                    _USER_CONTROL = _UC_MEMBER;
                    break;
            }

            if (!pnlMain.Contains(_USER_CONTROL))
            {
                pnlMain.Controls.Clear();
                _USER_CONTROL.Dock = DockStyle.Fill;
                pnlMain.Controls.Add(_USER_CONTROL);
            }
        }

        /// <summary>
        /// Takes a screenshot of the specified screens (and any screens between them)
        /// </summary>
        /// <param name="screens">The screens to take a screenshot of</param>
        /// <returns>A Image of the screenshot</returns>
        public static Image Grab(Screen[] screens)
        {
            if( screens == null )
                throw new ArgumentNullException("screens");

            if( screens.Length == 0 )
                throw new ArgumentException("Empty array", "screens");

            var start = new Point(0, 0);
            var end = new Point(0, 0);

            //get bounds of total screen space
            foreach( var tempScreen in screens )
            {
                if( tempScreen.Bounds.X < start.X )
                    start.X = tempScreen.Bounds.X;

                if( tempScreen.Bounds.Y < start.Y )
                    start.Y = tempScreen.Bounds.Y;

                if( tempScreen.Bounds.X + tempScreen.Bounds.Width > end.X )
                    end.X = tempScreen.Bounds.X + tempScreen.Bounds.Width;

                if( tempScreen.Bounds.Y + tempScreen.Bounds.Height > end.Y )
                    end.Y = tempScreen.Bounds.Y + tempScreen.Bounds.Height;
            }

            return Grab(start, end);
        }

 public double GetDpiX(Screen screen)
 {
     uint dpiX;
       uint dpiY;
       screen.GetDpi(DpiType.Effective, out dpiX, out dpiY);
       return Convert.ToDouble(dpiX);
 }

 private static Bitmap TakeScreenshot(Screen screen)
 {
     Bitmap bitmap = new Bitmap(screen.Bounds.Width, screen.Bounds.Height, PixelFormat.Format32bppArgb);
     Graphics graphics = Graphics.FromImage(bitmap);
     graphics.CopyFromScreen(screen.Bounds.X, screen.Bounds.Y, 0, 0, screen.Bounds.Size, CopyPixelOperation.SourceCopy);
     return bitmap;
 }

        void CreateControl(Screen current)
        {
            Type type = current.Type;

            // create new instance on gui thread
            if (MainControl.InvokeRequired)
            {
                MainControl.Invoke((MethodInvoker) delegate
                {
                    current.Control = (MyUserControl) Activator.CreateInstance(type);
                });
            }
            else
            {
                try
                {
                    current.Control = (MyUserControl) Activator.CreateInstance(type);
                }
                catch
                {
                    try
                    {
                        current.Control = (MyUserControl) Activator.CreateInstance(type);
                    }
                    catch
                    {
                    }
                }
            }

            // set the next new instance as not visible
            current.Control.Visible = false;
        }

		/// ------------------------------------------------------------------------------------
		/// <summary>
		/// Determines whether or not the specified screen is a virtual device. Virtual displays
		/// can usually be ignored.
		/// </summary>
		/// <param name="scrn">Screen to test.</param>
		/// <returns>True if screen is virtual. Otherwise, guess</returns>
		/// ------------------------------------------------------------------------------------
		public static bool ScreenIsVirtual(Screen scrn)
		{
			// We're really looking for a string containing DISPLAYV, but something is *goofy*
			// in the DeviceName string. It will not compare correctly despite all common sense.
			// Best we can do is test for "ISPLAYV".
			return (scrn.DeviceName.ToUpper().IndexOf("ISPLAYV") >= 0);
		}

        public static Size SizeDialog(IDeviceContext dc, string mainInstruction, string content, Screen screen, Font mainInstructionFallbackFont, Font contentFallbackFont, int horizontalSpacing, int verticalSpacing, int minimumWidth, int textMinimumHeight)
        {
            int width = minimumWidth - horizontalSpacing;
            int height = GetTextHeight(dc, mainInstruction, content, mainInstructionFallbackFont, contentFallbackFont, width);

            while( height > width )
            {
                int area = height * width;
                width = (int)(Math.Sqrt(area) * 1.1);
                height = GetTextHeight(dc, mainInstruction, content, mainInstructionFallbackFont, contentFallbackFont, width);
            }

            if( height < textMinimumHeight )
                height = textMinimumHeight;

            int newWidth = width + horizontalSpacing;
            int newHeight = height + verticalSpacing;

            Rectangle workingArea = screen.WorkingArea;
            if( newHeight > 0.9 * workingArea.Height )
            {
                int area = height * width;
                newHeight = (int)(0.9 * workingArea.Height);
                height = newHeight - verticalSpacing;
                width = area / height;
                newWidth = width + horizontalSpacing;
            }

            // If this happens the text won't display correctly, but even at 800x600 you need
            // to put so much text in the input box for this to happen that I don't care.
            if( newWidth > 0.9 * workingArea.Width )
                newWidth = (int)(0.9 * workingArea.Width);

            return new Size(newWidth, newHeight);
        }

        public CalibrationWpf(Screen current)
        {
            InitializeComponent();
            screen = current;

            // Create the calibration target
            calibrationPointWpf = new CalibrationPointWpf(new Size(screen.Bounds.Width, screen.Bounds.Height));
            CalibrationCanvas.Children.Add(calibrationPointWpf);

            Opacity = 0;
            IsAborted = false;

            // Create the animation-out object and close form when completed
            animateOut = new DoubleAnimation(0, TimeSpan.FromSeconds(FADE_OUT_TIME))
            {
                From = 1.0,
                To = 0.0,
                AutoReverse = false
            };

            animateOut.Completed += delegate
            {
                Close();
            };
        }

 public CursorControl(Screen screen, bool enabled, bool smooth)
 {
     GazeManager.Instance.AddGazeListener(this);
     ActiveScreen = screen;
     Enabled = enabled;
     Smooth = smooth;
 }

		/// ------------------------------------------------------------------------------------
		/// <summary>
		/// Shows the splash screen
		/// </summary>
		/// ------------------------------------------------------------------------------------
		public void Show(Screen display)
		{
#if !__MonoCS__
			if (m_thread != null)
				return;
#endif

			m_displayToUse = display;
			m_waitHandle = new EventWaitHandle(false, EventResetMode.AutoReset);

#if __MonoCS__
			// mono winforms can't create items not on main thread.
			StartSplashScreen(); // Create Modeless dialog on Main GUI thread
#else
			m_thread = new Thread(StartSplashScreen);
			m_thread.IsBackground = true;
			m_thread.SetApartmentState(ApartmentState.STA);
			m_thread.Name = "SplashScreen";
			// Copy the UI culture from the main thread to the splash screen thread.
			m_thread.CurrentUICulture = Thread.CurrentThread.CurrentUICulture;
			m_thread.Start();
			m_waitHandle.WaitOne();
#endif

			Debug.Assert(m_splashScreen != null);
			Message = string.Empty;
		}

        public DXGIScreen FindAdapter(Screen wscreen, bool refresh = false)
        {
            if (refresh) { this.Refresh(); }

            foreach (DXGIScreen screen in this.screens)
            {
                if (screen.Monitor.Description.Name.EndsWith(wscreen.DeviceName))
                {
                    return screen;
                }
            }

            //If not found force a refresh and try again
            if (!refresh) { this.Refresh(); }

            foreach (DXGIScreen screen in this.screens)
            {
                if (screen.Monitor.Description.Name.EndsWith(wscreen.DeviceName))
                {
                    return screen;
                }
            }

            //Blank object if not found
            return new DXGIScreen();
        }

        static Rectangle GetVisibleRectangle(WindowInfo wi, Screen s)
        {
            Rectangle resultWindowRect = new Rectangle(
                wi.rcWindow.left,
                wi.rcWindow.top,
                wi.rcWindow.right - wi.rcWindow.left,
                wi.rcWindow.bottom - wi.rcWindow.top
            );

            WindowBorderOnScreenFlags flags = new WindowBorderOnScreenFlags(wi, s);

            if(!flags.leftBorderOnScreen)
                resultWindowRect.X = s.WorkingArea.X;
            else {
                resultWindowRect.X = !flags.rightBorderOnScreen ?
                    s.WorkingArea.Right - wi.rcWindow.right + wi.rcWindow.left :
                    wi.rcWindow.left;
            }

            if(!flags.topBorderOnScreen)
                resultWindowRect.Y = s.WorkingArea.Y;
            else {
                resultWindowRect.Y = !flags.bottomBorderOnScreen ?
                    s.WorkingArea.Bottom - wi.rcWindow.bottom + wi.rcWindow.top :
                    wi.rcWindow.top;
            }

            return resultWindowRect;
        }

        private void AddPanel(Screen screen)
        {
            switch (screen)
            {
                case Screen.Sale:
                    if (_UC_SALE == null) _UC_SALE = new UcSale();
                    _USER_CONTROL = _UC_SALE;
                    break;
                case Screen.ReceiveProduct:
                    if (_UC_RECEIVE_PRODUCT == null) _UC_RECEIVE_PRODUCT = new UcReceiveProduct();
                    _USER_CONTROL = _UC_RECEIVE_PRODUCT;
                    break;
                case Screen.Stock:
                    if (_UC_STOCK == null) _UC_STOCK = new UcStock();
                    _USER_CONTROL = _UC_STOCK;
                    break;
            }

            if (!panelMain.Contains(_USER_CONTROL))
            {
                panelMain.Controls.Clear();
                _USER_CONTROL.Dock = DockStyle.Fill;
                panelMain.Controls.Add(_USER_CONTROL);
            }
        }