C# winform check si el control es físicamente visible

Question

¿Es posible determinar si se puede ver al menos un píxel de control (por una propiedad o tal vez mediante la notificación de eventos).

NB: No estoy buscando la propiedad Visible que puede devolver un cierto incluso si otra ventana oculta el control de

Answer 1

Puede invalidar el control y luego llamar al GetUpdateRect (función API de Win32) para averiguarlo. Sin embargo, tiene el efecto secundario de causar un repintado.

Answer 2

Si un control es visible el evento Paint se llamará (varias veces).

Normalmente, para controles no visibles, no se llamará a este evento.

Answer 3

Una solución pragmática es utilizar el método GetChildAtPoint() del formulario, pasando las 4 esquinas del control. Si uno de ellos devuelve verdadero, entonces el control es definitivamente visible. No es 100% confiable, las 4 esquinas pueden estar superpuestas por otro control pero aún así dejan parte del interior visible. No me preocuparía por eso, demasiado extraño.

public bool ChildReallyVisible(Control child) { 
    var pos = this.PointToClient(child.PointToScreen(Point.Empty)); 

    //Test the top left 
    if (this.GetChildAtPoint(pos) == child) return true; 

    //Test the top right 
    if (this.GetChildAtPoint(new Point(pos.X + child.Width - 1, pos.Y)) == child) return true; 

    //Test the bottom left 
    if (this.GetChildAtPoint(new Point(pos.X, pos.Y + child.Height -1)) == child) return true; 

    //Test the bottom right 
    if (this.GetChildAtPoint(new Point(pos.X + child.Width - 1, pos.Y + child.Height -1)) == child) return true; 

    return false; 
} 

Answer 4

Para facilitar una pregunta anterior answer a su pregunta.

Aquí está el código fuente que necesitará para trabajar con la función GetUpdateRect como jdv-Jan de Vaan respondida.

[System.Runtime.InteropServices.StructLayout(System.Runtime.InteropServices.LayoutKind.Sequential)] 
internal struct RECT 
{ 
    public int Left; 
    public int Top; 
    public int Right; 
    public int Bottom; 
    public int Width { get { return this.Right - this.Left; } } 
    public int Height { get { return this.Bottom - this.Top; } } 
} 
[System.Runtime.InteropServices.DllImport("user32.dll")] 
internal static extern bool GetUpdateRect(IntPtr hWnd, ref RECT rect, bool bErase); 
public static bool IsControlVisibleToUser(Control control) 
{ 
    control.Invalidate(); 
    Rectangle bounds = control.Bounds; 
    RECT rect = new RECT { Left = bounds.Left, Right = bounds.Right, Top = bounds.Top, Bottom = bounds.Bottom }; 
    return GetUpdateRect(control.Handle, ref rect, false); 
} 

Cuando es necesario comprobar si un determinado es visible justo hacer algo como lo siguiente:

if (IsControlVisibleToUser(controlName) == true) 
{ 
    // The Specified Control is visible. 
    // ... do something 
} 
else 
{ 
    // Control is not visible. 
    // ... do something else 
} 

Buena suerte.

Answer 5

Inspirado por la respuesta de Hans, he implementado este comportamiento de esta manera;

[DllImport("user32.dll")] 
    static extern IntPtr WindowFromPoint(POINT Point); 

    [StructLayout(LayoutKind.Sequential)] 
    public struct POINT 
    { 
     public int X; 
     public int Y; 

     public POINT(int x, int y) 
     { 
      this.X = x; 
      this.Y = y; 
     } 

     public static implicit operator System.Drawing.Point(POINT p) 
     { 
      return new System.Drawing.Point(p.X, p.Y); 
     } 

     public static implicit operator POINT(System.Drawing.Point p) 
     { 
      return new POINT(p.X, p.Y); 
     } 
    } 

    public static bool IsControlVisibleToUser(this Control control) 
    { 
     var pos = control.PointToScreen(control.Location); 
     var pointsToCheck = new POINT[] 
           { 
            pos, 
            new Point(pos.X + control.Width - 1, pos.Y), 
            new Point(pos.X, pos.Y + control.Height - 1), 
            new Point(pos.X + control.Width - 1, pos.Y + control.Height - 1), 
            new Point(pos.X + control.Width/2, pos.Y + control.Height/2) 
           }; 

     foreach (var p in pointsToCheck) 
     { 
      var hwnd = WindowFromPoint(p); 
      var other = Control.FromChildHandle(hwnd); 
      if (other == null) 
       continue; 

      if (control == other || control.Contains(other)) 
       return true; 
     } 

     return false; 
    } 

Answer 6

Puede usar el evento de controles Layout. se activa cuando el control llega a la pantalla e intenta diseñar sus controles secundarios.

Por ejemplo, digamos que hay GroupBox dentro de una TabPage.
Cuando hace clic en la pestaña correspondiente, evento layout se activará para primera TabPage a continuación para GroupBox
Es posible utilizarlo combinado con propiedad de visibilidad

Answer 7

Puede comprobar la visibilidad de control primario.

protected override void OnParentVisibleChanged(EventArgs e) 
    { 
     base.OnParentVisibleChanged(e); 
     isVisible = true; 
    } 

Answer 8

I algo terminó la respuesta de Hans Passant. La función siguiente prueba las cuatro esquinas del formulario.

 /// <summary> 
    /// determines if a form is on top and really visible. 
    /// a problem you ran into is that form.invalidate returns true, even if another form is on top of it. 
    /// this function avoids that situation 
    /// code and discussion: 
    /// https://stackoverflow.com/questions/4747935/c-sharp-winform-check-if-control-is-physicaly-visible 
    /// </summary> 
    /// <param name="child"></param> 
    /// <returns></returns> 
    public bool ChildReallyVisible(Control child) 
    { 
     bool result = false; 

     var pos = this.PointToClient(child.PointToScreen(Point.Empty)); 

     result = this.GetChildAtPoint(pos) == child; 
     //this 'if's cause the condition only to be checked if the result is true, otherwise it will stay false to the end 
     if(result) 
     { 
      result = (this.GetChildAtPoint(new Point(pos.X + child.Width - 1, pos.Y)) == child); 
     } 
     if(result) 
     { 
      result = (this.GetChildAtPoint(new Point(pos.X, pos.Y + child.Height - 1)) == child); 
     } 
     if(result) 
     { 
      result = (this.GetChildAtPoint(new Point(pos.X + child.Width - 1, pos.Y + child.Height - 1)) == child) ; 
     } 
     return result; 
    }