it-swarm.com.de

Wiederherstellen der Fenstergröße/-position mit mehreren Monitoren

Viele Beiträge rund um das Wiederherstellen einer Position und Größe von WinForm.

Beispiele:

Ich habe jedoch noch keinen Code dafür mit mehreren Monitoren gefunden.

Wenn ich also meine .NET Winform-App mit dem Fenster auf Monitor 2 schließe, möchte ich, dass die Fenstergröße, der Ort und der Zustand in den Anwendungseinstellungen gespeichert werden, so dass beim Neustart der App später Monitor 2 wiederhergestellt werden kann. Es wäre schön, wenn es, wie im obigen Codeprojekt-Beispiel, einige Überprüfungen der Sicherheit enthält, da der gespeicherte Speicherort meist außerhalb des Bildschirms liegt und "repariert" wird. Wenn sich der gespeicherte Standort auf einem Monitor befindet, der nicht mehr vorhanden ist (z. B. mein Laptop ist jetzt ohne meinen zweiten Monitor), verschiebt er ihn korrekt auf den Monitor 1.

Irgendwelche Gedanken?

Meine Umgebung: C #, .NET 3.5 oder niedriger, VS2008

31
Michael Sorens

Die Antwort des VVS war eine große Hilfe! Ich habe jedoch zwei kleinere Probleme gefunden, daher poste ich den Großteil seines Codes mit diesen Überarbeitungen neu:

(1) Wenn die Anwendung zum ersten Mal ausgeführt wird, wird das Formular im Status "Normal" geöffnet, jedoch so groß, dass es nur als Titelleiste erscheint. Ich habe im Konstruktor eine Bedingung hinzugefügt, um dies zu beheben.

(2) Wenn die Anwendung geschlossen wird, während sie minimiert oder maximiert ist, kann der Code in OnClosing die Abmessungen des Fensters im Normalzustand nicht speichern. (Die drei Codezeilen - die ich jetzt auskommentiert habe - scheinen vernünftig zu sein, funktionieren aber aus irgendeinem Grund einfach nicht.) Zum Glück hatte ich dieses Problem zuvor gelöst und diesen Code in eine neue Region am Ende des Codes eingefügt um den Fensterstatus während des Vorgangs zu verfolgen, anstatt auf das Schließen zu warten.


Mit diesen zwei Korrekturen habe ich Folgendes getestet:

A. Schließen im Normalzustand - stellt die gleiche Größe/Position und denselben Zustand wieder her

B. Schließen im minimierten Zustand - Stellt den Normalzustand mit der letzten normalen Größe/Position wieder her

C. Schließen im maximierten Zustand - Stellt den maximierten Zustand wieder her und merkt sich seine letzte Größe/Position, wenn sich der Normalzustand später ändert.

D. Schließen auf Monitor 2 - Wiederherstellen von Monitor 2.

E. Schließen des Monitors 2 und Trennen des Monitors 2 - Wiederherstellen der Position an Monitor 1

David: Ihr Code ermöglichte es mir, die Punkte D und E fast mühelos zu erreichen. Sie haben nicht nur eine Lösung für meine Frage bereitgestellt, Sie haben sie in einem vollständigen Programm bereitgestellt, so dass ich sie innerhalb von Sekunden nach dem Einfügen in Visual Studio in Betrieb nahm . Vielen Dank dafür!

public partial class MainForm : Form
{
    bool windowInitialized;

    public MainForm()
    {
        InitializeComponent();

        // this is the default
        this.WindowState = FormWindowState.Normal;
        this.StartPosition = FormStartPosition.WindowsDefaultBounds;

        // check if the saved bounds are nonzero and visible on any screen
        if (Settings.Default.WindowPosition != Rectangle.Empty &&
            IsVisibleOnAnyScreen(Settings.Default.WindowPosition))
        {
            // first set the bounds
            this.StartPosition = FormStartPosition.Manual;
            this.DesktopBounds = Settings.Default.WindowPosition;

            // afterwards set the window state to the saved value (which could be Maximized)
            this.WindowState = Settings.Default.WindowState;
        }
        else
        {
            // this resets the upper left corner of the window to windows standards
            this.StartPosition = FormStartPosition.WindowsDefaultLocation;

            // we can still apply the saved size
            // msorens: added gatekeeper, otherwise first time appears as just a title bar!
            if (Settings.Default.WindowPosition != Rectangle.Empty)
            {
                this.Size = Settings.Default.WindowPosition.Size;
            }
        }
        windowInitialized = true;
    }

    private bool IsVisibleOnAnyScreen(Rectangle rect)
    {
        foreach (Screen screen in Screen.AllScreens)
        {
            if (screen.WorkingArea.IntersectsWith(rect))
            {
                return true;
            }
        }

        return false;
    }

    protected override void OnClosed(EventArgs e)
    {
        base.OnClosed(e);

        // only save the WindowState if Normal or Maximized
        switch (this.WindowState)
        {
            case FormWindowState.Normal:
            case FormWindowState.Maximized:
                Settings.Default.WindowState = this.WindowState;
                break;

            default:
                Settings.Default.WindowState = FormWindowState.Normal;
                break;
        }

        # region msorens: this code does *not* handle minimized/maximized window.

        // reset window state to normal to get the correct bounds
        // also make the form invisible to prevent distracting the user
        //this.Visible = false;
        //this.WindowState = FormWindowState.Normal;
        //Settings.Default.WindowPosition = this.DesktopBounds;

        # endregion

        Settings.Default.Save();
    }

    # region window size/position
    // msorens: Added region to handle closing when window is minimized or maximized.

    protected override void OnResize(EventArgs e)
    {
        base.OnResize(e);
        TrackWindowState();
    }

    protected override void OnMove(EventArgs e)
    {
        base.OnMove(e);
        TrackWindowState();
    }

    // On a move or resize in Normal state, record the new values as they occur.
    // This solves the problem of closing the app when minimized or maximized.
    private void TrackWindowState()
    {
        // Don't record the window setup, otherwise we lose the persistent values!
        if (!windowInitialized) { return; }

        if (WindowState == FormWindowState.Normal)
        {
            Settings.Default.WindowPosition = this.DesktopBounds;
        }
    }

    # endregion window size/position
}
26
Michael Sorens

Versuchen Sie diesen Code. Sehenswürdigkeiten:

  • Überprüft, ob das Fenster im Arbeitsbereich eines Bildschirms (teilweise) sichtbar ist. Z.B. Wenn Sie es hinter die Taskleiste ziehen oder ganz aus dem Bildschirm verschieben, wird die Position auf Windows-Standard zurückgesetzt.
  • Speichert die korrekten Grenzen, auch wenn das Formular minimiert oder maximiert ist (allgemeiner Fehler)
  • Speichert den WindowState korrekt. Das Speichern von FormWindowState.Minimized ist von Entwurf deaktiviert.

Die Begrenzungen und der Zustand werden mit ihrem entsprechenden Typ in den Apps-Einstellungen gespeichert, sodass keine Zeichenfolgenanalyse erforderlich ist. Lassen Sie das Framework seine Serialisierungsmagie durchführen.

public partial class MainForm : Form
{
    public MainForm()
    {
        InitializeComponent();

        // this is the default
        this.WindowState = FormWindowState.Normal;
        this.StartPosition = FormStartPosition.WindowsDefaultBounds;

        // check if the saved bounds are nonzero and visible on any screen
        if (Settings.Default.WindowPosition != Rectangle.Empty &&
            IsVisibleOnAnyScreen(Settings.Default.WindowPosition))
        {
            // first set the bounds
            this.StartPosition = FormStartPosition.Manual;
            this.DesktopBounds = Settings.Default.WindowPosition;

            // afterwards set the window state to the saved value (which could be Maximized)
            this.WindowState = Settings.Default.WindowState;
        }
        else
        {
            // this resets the upper left corner of the window to windows standards
            this.StartPosition = FormStartPosition.WindowsDefaultLocation;

            // we can still apply the saved size
            this.Size = Settings.Default.WindowPosition.Size;
        }
    }

    private bool IsVisibleOnAnyScreen(Rectangle rect)
    {
        foreach (Screen screen in Screen.AllScreens)
        {
            if (screen.WorkingArea.IntersectsWith(rect))
            {
                return true;
            }
        }

        return false;
    }

    protected override void OnClosed(EventArgs e)
    {
        base.OnClosed(e);

        // only save the WindowState if Normal or Maximized
        switch (this.WindowState)
        {
            case FormWindowState.Normal:
            case FormWindowState.Maximized:
                Settings.Default.WindowState = this.WindowState;
                break;

            default:
                Settings.Default.WindowState = FormWindowState.Normal;
                break;
        }

        // reset window state to normal to get the correct bounds
        // also make the form invisible to prevent distracting the user
        this.Visible = false;
        this.WindowState = FormWindowState.Normal;

        Settings.Default.WindowPosition = this.DesktopBounds;
        Settings.Default.Save();
    }
}

Die Einstellungsdatei als Referenz:

<?xml version='1.0' encoding='utf-8'?>
<SettingsFile xmlns="http://schemas.Microsoft.com/VisualStudio/2004/01/settings" CurrentProfile="(Default)" GeneratedClassNamespace="ScreenTest" GeneratedClassName="Settings">
    <Profiles />
    <Settings>
        <Setting Name="WindowPosition" Type="System.Drawing.Rectangle" Scope="User">
            <Value Profile="(Default)">0, 0, 0, 0</Value>
        </Setting>
        <Setting Name="WindowState" Type="System.Windows.Forms.FormWindowState" Scope="User">
            <Value Profile="(Default)">Normal</Value>
        </Setting>
    </Settings>
</SettingsFile>
34
VVS

Bei den meisten anderen Lösungen muss die aktuelle Position jedes Monitors manuell ermittelt werden. Die Edge-Fälle sind extrem schwer zu verstehen und nur wenige Apps können es richtig zum Laufen bringen.

Die SetWindowPlacement-Funktion in Windows verarbeitet alle Edge-Fälle korrekt. Wenn das Fenster außerhalb eines sichtbaren Bildschirms positioniert würde, wird es entsprechend angepasst.

Das beste Beispiel, das ich in C # gesehen habe, ist auf David Rickards Blog. Es zeigt nicht nur, wie SetWindowPlacement verwendet wird, sondern auch, wie das gesamte Ergebnis serialisiert wird. http://blogs.msdn.com/b/davidrickard/archive/2010/03/09/saving -window-size-and-location-in-wpf-and-winforms.aspx

8
ShadowChaser

Ich denke, dies ist das perfekte, das auf Ihren Antworten und Kommentaren basiert.


Diese Lösung besteht in Speichern/Wiederherstellen von Formulargröße und -position mit Multi-Monitoren + Multi-Dokument , Multi-Formular oder Multi-Main form Unterstützung. Es ist nicht MDI form, sondern Microsoft Word wie ein Mehrfachdokument mit einer anderen Hauptformularinstanz.

Vielen Dank an VVS, msorens und Ian Goldby. Ich füge die Lösung aus VVS, msorens und MSDN Application.Run-Methode (ApplicationContext) zusammen, um die Multi-MainForm aber kein MDI zu erstellen.

Dieses Update enthält den Kommentar von Ian Goldby, der Form.RestoreBounds verwendet, um OnResize(), OnMove() und TrackWindowState() zu entfernen.

Ich behebe auch, den Monitor zu erinnern, wenn das Formular auf den anderen Monitor verschoben wird und vor dem Beenden maximiert wird, da ich OnResize und OnMove nicht aufspreche. Mit diesem Fix unterstützt diese Lösung Windows 7 Snap-Funktion welche Sie können die Titelleiste oder die Win + Pfeiltaste ziehen, um das Form-Fenster in eine beliebige Monitor-Kante zu schnappen oder es maximiert/normal sowie minimiert zu gestalten.

Diese Lösung wurde im Programm implementiert, jedoch nicht im Hauptformular, um das Multi-Hauptformular zu unterstützen. Sie können jedoch auch für ein Hauptformular verwenden.

using System;
using System.Collections.Generic;
using System.Windows.Forms;
using SimpleTestForm.Properties;
using System.Drawing;

namespace SimpleTestForm
{
    static class Program
    {
        static MultiMainFormAppContext appContext;

        /// <summary>
        /// The main entry point for the application.
        /// </summary>
        [STAThread]
        static void Main()
        {
            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);

            appContext = new MultiMainFormAppContext();
            Application.Run(appContext);
        }

        /// <summary>
        /// Create a new MainForm and restore the form size and position if necessary. This method can be called like from Menu File > New click event.
        /// </summary>
        /// <returns></returns>
        public static MainForm createNewMainForm()
        {
            return appContext.createNewMainForm();
        }

        /// <summary>
        /// Get the current active MainForm event if a dialog is opened. Useful to create Dictionary (MainForm, T) to store Form/document dependent field. Please set the Owner of child form to prevent null reference exception.
        /// </summary>
        /// <returns></returns>
        public static MainForm GetCurrentMainFormInstance()
        {
            Form mainForm = Form.ActiveForm;
            while (!(mainForm is MainForm) && mainForm.Owner != null)
                mainForm = mainForm.Owner;
            return mainForm as MainForm;
        }
    }

    class MultiMainFormAppContext : ApplicationContext
    {
        List<MainForm> mainForms = new List<MainForm>();
        Point newRestoredLocation = Point.Empty;

        internal MultiMainFormAppContext()
        {
            createNewMainForm();
        }

        internal MainForm createNewMainForm()
        {
            MainForm mainForm = new MainForm();
            mainForm.FormClosed += new FormClosedEventHandler(mainForm_FormClosed);
            mainForm.LocationChanged += new EventHandler(mainForm_LocationChanged);
            RestoreFormSizeNPosition(mainForm);
            PreventSameLocation(mainForm);
            mainForms.Add(mainForm);
            mainForm.Show();
            return mainForm;
        }

        private void PreventSameLocation(MainForm mainForm)
        {
            const int distance = 20;
            foreach (MainForm otherMainForm in mainForms)
            {
                if (Math.Abs(otherMainForm.Location.X - mainForm.Location.X) < distance &&
                    Math.Abs(otherMainForm.Location.Y - mainForm.Location.Y) < distance)
                    mainForm.Location = new Point(mainForm.Location.X + distance, mainForm.Location.Y + distance);
            }
        }

        /// <summary>
        /// Restore the form size and position with multi monitor support.
        /// </summary>
        private void RestoreFormSizeNPosition(MainForm mainForm)
        {
            // this is the default
            mainForm.WindowState = FormWindowState.Normal;
            mainForm.StartPosition = FormStartPosition.WindowsDefaultBounds;

            // check if the saved bounds are nonzero and visible on any screen
            if (Settings.Default.WindowPosition != Rectangle.Empty &&
                IsVisibleOnAnyScreen(Settings.Default.WindowPosition))
            {
                // first set the bounds
                mainForm.StartPosition = FormStartPosition.Manual;
                mainForm.DesktopBounds = Settings.Default.WindowPosition;

                // afterwards set the window state to the saved value (which could be Maximized)
                mainForm.WindowState = Settings.Default.WindowState;
            }
            else
            {
                // this resets the upper left corner of the window to windows standards
                mainForm.StartPosition = FormStartPosition.WindowsDefaultLocation;

                // we can still apply the saved size if not empty
                if (Settings.Default.WindowPosition != Rectangle.Empty)
                {
                    mainForm.Size = Settings.Default.WindowPosition.Size;
                }
            }
        }

        private void SaveFormSizeNPosition(MainForm mainForm)
        {
            // only save the WindowState as Normal or Maximized
            Settings.Default.WindowState = FormWindowState.Normal;
            if (mainForm.WindowState == FormWindowState.Normal || mainForm.WindowState == FormWindowState.Maximized)
                Settings.Default.WindowState = mainForm.WindowState;

            if (mainForm.WindowState == FormWindowState.Normal)
            {
                Settings.Default.WindowPosition = mainForm.DesktopBounds;
            }
            else
            {
                if (newRestoredLocation == Point.Empty)
                    Settings.Default.WindowPosition = mainForm.RestoreBounds;
                else
                    Settings.Default.WindowPosition = new Rectangle(newRestoredLocation, mainForm.RestoreBounds.Size);
            }

            Settings.Default.Save();
        }

        private bool IsVisibleOnAnyScreen(Rectangle rect)
        {
            foreach (Screen screen in Screen.AllScreens)
            {
                if (screen.WorkingArea.IntersectsWith(rect))
                    return true;
            }
            return false;
        }

        void mainForm_LocationChanged(object sender, EventArgs e)
        {
            MainForm mainForm = sender as MainForm;
            if (mainForm.WindowState == FormWindowState.Maximized)
            {
                // get the center location of the form incase like RibbonForm will be bigger and maximized Location wll be negative value that Screen.FromPoint(mainForm.Location) will going to the other monitor resides on the left or top of primary monitor.
                // Another thing, you might consider the form is in the monitor even if the location (top left corner) is on another monitor because majority area is on the monitor, so center point is the best way.
                Point centerFormMaximized = new Point (mainForm.DesktopBounds.Left + mainForm.DesktopBounds.Width/2, mainForm.DesktopBounds.Top + mainForm.DesktopBounds.Height/2);
                Point centerFormRestored = new Point(mainForm.RestoreBounds.Left + mainForm.RestoreBounds.Width / 2, mainForm.RestoreBounds.Top + mainForm.RestoreBounds.Height / 2);
                Screen screenMaximized = Screen.FromPoint(centerFormMaximized);
                Screen screenRestored = Screen.FromPoint(centerFormRestored);
                // we need to change the Location of mainForm.RestoreBounds to the new screen where the form currently maximized.
                // RestoreBounds does not update the Location if you change the screen but never restore to FormWindowState.Normal
                if (screenMaximized.DeviceName != screenRestored.DeviceName)
                {
                    newRestoredLocation = mainForm.RestoreBounds.Location;
                    int screenOffsetX = screenMaximized.Bounds.Location.X - screenRestored.Bounds.Location.X;
                    int screenOffsetY = screenMaximized.Bounds.Location.Y - screenRestored.Bounds.Location.Y;
                    newRestoredLocation.Offset(screenOffsetX, screenOffsetY);
                    return;
                }
            }
            newRestoredLocation = Point.Empty;
        }

        void mainForm_FormClosed(object sender, FormClosedEventArgs e)
        {
            MainForm mainForm = sender as MainForm;
            SaveFormSizeNPosition(mainForm);
            mainForm.FormClosed -= new FormClosedEventHandler(mainForm_FormClosed);
            mainForm.LocationChanged -= new EventHandler(mainForm_LocationChanged);
            mainForm.Dispose();
            mainForms.Remove(mainForm);
            if (mainForms.Count == 0) ExitThread();
        }
    }
}

Bearbeiten: PreventSameLocation-Methode hinzugefügt, um sicherzustellen, dass das 2. Formular nicht genau über dem 1. Formular geöffnet wurde und der Benutzer das neu geöffnete Formular erkennt.

3
CallMeLaNN

Wenn Sie über mehrere Monitore verfügen, glaube ich, dass die Abmessungen der Bildschirm-Benutzeroberfläche einfach größer sind. Der normale "1 Monitor" -Ansatz des Speicherns und Wiederherstellens des Standorts funktioniert also einfach. Ich habe es nicht versucht, weil ich nicht an meinem zweiten Monitor bin, aber es sollte nicht schwer sein, es zu testen. Sie haben die Frage so gestellt, als hätten Sie sie nicht getestet. 

Ihre zweite Anforderung bedeutet, dass Sie beim Wiederherstellen der App die maximalen Abmessungen prüfen müssen, um sie dann neu zu positionieren. Um dieses letzte Bit auszuführen, verwende ich diesen Code:

    private System.Drawing.Rectangle ConstrainToScreen(System.Drawing.Rectangle bounds)
    {
        Screen screen = Screen.FromRectangle(bounds);
        System.Drawing.Rectangle workingArea = screen.WorkingArea;
        int width = Math.Min(bounds.Width, workingArea.Width);
        int height = Math.Min(bounds.Height, workingArea.Height);
        // mmm....minimax            
        int left = Math.Min(workingArea.Right - width, Math.Max(bounds.Left, workingArea.Left));
        int top = Math.Min(workingArea.Bottom - height, Math.Max(bounds.Top, workingArea.Top));
        return new System.Drawing.Rectangle(left, top, width, height);
    }

Ich rufe diese Methode beim Wiederherstellen des Formulars auf. Ich speichere die Bildschirmgeometrie in der Registrierung beim Schließen des Formulars und lese dann die Geometrie beim Öffnen des Formulars. Ich bekomme die Grenzen, beschränke dann aber die wiederhergestellten Grenzen auf den aktuellen Bildschirm, indem ich die oben genannte Methode verwende. 

Sparen Sie beim Schließen: 

      // store the size of the form
      int w = 0, h = 0, left = 0, top = 0;
      if (this.Bounds.Width < this.MinimumSize.Width || this.Bounds.Height < this.MinimumSize.Height)
      {
          // The form is currently minimized.  
          // RestoreBounds is the size of the window prior to last minimize action.
          w = this.RestoreBounds.Width;
          h = this.RestoreBounds.Height;
          left = this.RestoreBounds.Location.X;
          top = this.RestoreBounds.Location.Y;
      }
      else
      {
          w = this.Bounds.Width;
          h = this.Bounds.Height;
          left = this.Location.X;
          top = this.Location.Y;
      }
      AppCuKey.SetValue(_rvn_Geometry,
        String.Format("{0},{1},{2},{3},{4}",
              left, top, w, h, (int)this.WindowState));

Wiederherstellen bei geöffnetem Formular: 

    // restore the geometry of the form
    string s = (string)AppCuKey.GetValue(_rvn_Geometry);
    if (!String.IsNullOrEmpty(s))
    {
        int[] p = Array.ConvertAll<string, int>(s.Split(','),
                         new Converter<string, int>((t) => { return Int32.Parse(t); }));
        if (p != null && p.Length == 5)
            this.Bounds = ConstrainToScreen(new System.Drawing.Rectangle(p[0], p[1], p[2], p[3]));
    }
1
Cheeso

Dies ist eine alte Frage, aber hier ist eine VB -Version basierend auf den vorherigen Antworten.

Ein Problem mit den von VVS und Michael Sorens vorgeschlagenen Antworten besteht darin, dass eine gespeicherte Position, die nur einige Pixel auf einem Bildschirm anzeigt, als sichtbar gilt. Diese Lösung erfordert einen Schnittpunkt von mindestens 50 x 50 Pixeln, bevor der vorherige Speicherort wiederhergestellt wird.

Die Einstellungen:

<Settings>
  <Setting Name="WindowState" Type="System.Windows.Forms.FormWindowState" Scope="User">
    <Value Profile="(Default)">Normal</Value>
  </Setting>
  <Setting Name="WindowBounds" Type="System.Drawing.Rectangle" Scope="User">
    <Value Profile="(Default)">10, 10, 800, 600</Value>
  </Setting>
</Settings>

Bilden:

Partial Public Class MainForm

    Private loadingComplete As Boolean = False

    Public Sub New()

        InitializeComponent()
        RestoreWindowLocation()

    End Sub

    Private Sub MainForm_Load(sender As System.Object, e As System.EventArgs) Handles MyBase.Load

        loadingComplete = True

    End Sub

    Private Sub MainForm_Resize(sender As System.Object, e As System.EventArgs) Handles MyBase.Resize

         TrackWindowLocation()

     End Sub

     Private Sub MainForm_Move(sender As System.Object, e As System.EventArgs) Handles MyBase.Move

         TrackWindowLocation()

     End Sub

    Private Sub MainForm_FormClosing(sender As System.Object, e As System.Windows.Forms.FormClosingEventArgs) Handles MyBase.FormClosing

        SaveWindowLocation()

     End Sub


    Private Sub RestoreWindowLocation()

        If IsRectangleVisible(My.Settings.WindowBounds) Then
            Me.StartPosition = FormStartPosition.Manual
            Me.DesktopBounds = My.Settings.WindowBounds
        End If

        If Not My.Settings.WindowState = FormWindowState.Minimized Then
            Me.WindowState = My.Settings.WindowState
        End If

    End Sub

    Private Sub TrackWindowLocation()

        If loadingComplete Then
            If Me.WindowState = FormWindowState.Normal Then
                My.Settings.WindowBounds = Me.DesktopBounds
                My.Settings.WindowState = Me.WindowState
            End If
        End If

    End Sub

    Private Sub SaveWindowLocation()

        If Not Me.WindowState = FormWindowState.Minimized Then
            My.Settings.WindowState = Me.WindowState
        End If

        If Me.WindowState = FormWindowState.Normal Then
            My.Settings.WindowBounds = Me.DesktopBounds
        End If

        My.Settings.Save()

    End Sub

    Private Function IsRectangleVisible(Rectangle As Rectangle) As Boolean

        For Each screen As Screen In screen.AllScreens
            Dim r As Rectangle = Rectangle.Intersect(Rectangle, screen.WorkingArea)
            If Not r.IsEmpty Then
                If r.Width > 50 And r.Height > 50 Then Return True
            End If
        Next

        Return False

    End Function

End Class
0
Judah Sali