Dans WPF, comment puis-je déterminer si un contrôle est visible pour l'utilisateur?

public static bool IsUserVisible(this UIElement element)
{
    if (!element.IsVisible)
        return false;
    var container = VisualTreeHelper.GetParent(element) as FrameworkElement;
    if (container == null) throw new ArgumentNullException("container");

    Rect bounds = element.TransformToAncestor(container).TransformBounds(new Rect(0.0, 0.0, element.RenderSize.Width, element.RenderSize.Height));
    Rect rect = new Rect(0.0, 0.0, container.ActualWidth, container.ActualHeight);
    return rect.IntersectsWith(bounds);
}

La accepté de répondre (et les autres réponses sur cette page) résoudre le problème spécifique que l'affiche originale a mais ils ne donnent pas une réponse adéquate à la question écrite dans le titre, c'est à dire, Comment faire pour déterminer si un contrôle est visible à l'utilisateur. Le problème est que Un contrôle qui est couvert par d'autres contrôles n'est pas visible même si elle peut être rendue et il est à l'intérieur des frontières de son conteneur, qui est ce que les autres réponses sont des problèmes pour les.

Pour déterminer si un contrôle est visible à l'utilisateur que vous avez parfois à être en mesure de déterminer si un WPF UIElement est Cliquable (ou de la souris accessible sur PC) par l'utilisateur

J'ai rencontré ce problème quand j'ai essayé de vérifier si un bouton de la souris cliqué par l'utilisateur. Un spécial scénario, ce qui m'énerve c'était qu'un bouton peut être réellement visible pour l'utilisateur, mais couvert avec quelques transparent ou semi transparent ou non transparente à tous) de la couche de prévenir les clics de souris. Dans de tels cas, un contrôle peut être visible pour l'utilisateur, mais pas accessible à l'utilisateur qui est en quelque sorte comme il n'est pas visible à tous.

J'ai donc dû venir avec ma propre solution.

MODIFIER - Mon premier post avait une autre solution utilisée InputHitTest méthode. Toutefois, il ne fonctionne pas dans de nombreux cas, et j'ai eu à le redessiner. Cette solution est beaucoup plus robuste et semble fonctionner très bien, sans faux-négatifs ou positifs.

Solution:

1. Obtenir l'objet de la position absolue par rapport à la Fenêtre Principale de l'Application
2. Appel VisualTreeHelper.HitTest sur tous ses angles (en Haut à gauche, en bas à gauche, en haut à droite, en bas à droite)
3. Nous appelons un objet Entièrement Cliquable si l'objet obtenu à partir de VisualTreeHelper.HitTest l'égalité de l'objet d'origine ou un visuel parent pour tous ses coins, et Partiellement Cliquable pour un ou plusieurs angles.

Veuillez prendre note #1: La définition de Entièrement Cliquable ou Partiellement
Cliquable ne sont pas exactes, nous avons juste la vérification de tous les quatre coins d'un
objet sont cliquables. Si, par exemple, un bouton a 4 cliquable coins, mais c'est
centre de a un point qui n'est pas cliquable, nous allons encore le considérer comme
Entièrement Cliquable. Pour vérifier tous les points d'un objet donné serait trop
le gaspillage.

Veuillez prendre note #2: il est parfois nécessaire de définir un objet IsHitTestVisible
propriété à vrai (cependant, c'est la valeur par défaut pour de nombreux
contrôles) si nous voulons VisualTreeHelper.HitTest trouver

    private bool isElementClickable<T>(UIElement container, UIElement element, out bool isPartiallyClickable)
{
isPartiallyClickable = false;
Rect pos = GetAbsolutePlacement((FrameworkElement)container, (FrameworkElement)element);
bool isTopLeftClickable = GetIsPointClickable<T>(container, element, new Point(pos.TopLeft.X + 1,pos.TopLeft.Y+1));
bool isBottomLeftClickable = GetIsPointClickable<T>(container, element, new Point(pos.BottomLeft.X + 1, pos.BottomLeft.Y - 1));
bool isTopRightClickable = GetIsPointClickable<T>(container, element, new Point(pos.TopRight.X - 1, pos.TopRight.Y + 1));
bool isBottomRightClickable = GetIsPointClickable<T>(container, element, new Point(pos.BottomRight.X - 1, pos.BottomRight.Y - 1));
if (isTopLeftClickable || isBottomLeftClickable || isTopRightClickable || isBottomRightClickable)
{
isPartiallyClickable = true;
}
return isTopLeftClickable && isBottomLeftClickable && isTopRightClickable && isBottomRightClickable; //return if element is fully clickable
}
private bool GetIsPointClickable<T>(UIElement container, UIElement element, Point p) 
{
DependencyObject hitTestResult = HitTest< T>(p, container);
if (null != hitTestResult)
{
return isElementChildOfElement(element, hitTestResult);
}
return false;
}               
private DependencyObject HitTest<T>(Point p, UIElement container)
{                       
PointHitTestParameters parameter = new PointHitTestParameters(p);
DependencyObject hitTestResult = null;
HitTestResultCallback resultCallback = (result) =>
{
UIElement elemCandidateResult = result.VisualHit as UIElement;
//result can be collapsed! Even though documentation indicates otherwise
if (null != elemCandidateResult && elemCandidateResult.Visibility == Visibility.Visible) 
{
hitTestResult = result.VisualHit;
return HitTestResultBehavior.Stop;
}
return HitTestResultBehavior.Continue;
};
HitTestFilterCallback filterCallBack = (potentialHitTestTarget) =>
{
if (potentialHitTestTarget is T)
{
hitTestResult = potentialHitTestTarget;
return HitTestFilterBehavior.Stop;
}
return HitTestFilterBehavior.Continue;
};
VisualTreeHelper.HitTest(container, filterCallBack, resultCallback, parameter);
return hitTestResult;
}         
private bool isElementChildOfElement(DependencyObject child, DependencyObject parent)
{
if (child.GetHashCode() == parent.GetHashCode())
return true;
IEnumerable<DependencyObject> elemList = FindVisualChildren<DependencyObject>((DependencyObject)parent);
foreach (DependencyObject obj in elemList)
{
if (obj.GetHashCode() == child.GetHashCode())
return true;
}
return false;
}
private IEnumerable<T> FindVisualChildren<T>(DependencyObject depObj) where T : DependencyObject
{
if (depObj != null)
{
for (int i = 0; i < VisualTreeHelper.GetChildrenCount(depObj); i++)
{
DependencyObject child = VisualTreeHelper.GetChild(depObj, i);
if (child != null && child is T)
{
yield return (T)child;
}
foreach (T childOfChild in FindVisualChildren<T>(child))
{
yield return childOfChild;
}
}
}
}
private Rect GetAbsolutePlacement(FrameworkElement container, FrameworkElement element, bool relativeToScreen = false)
{
var absolutePos = element.PointToScreen(new System.Windows.Point(0, 0));
if (relativeToScreen)
{
return new Rect(absolutePos.X, absolutePos.Y, element.ActualWidth, element.ActualHeight);
}
var posMW = container.PointToScreen(new System.Windows.Point(0, 0));
absolutePos = new System.Windows.Point(absolutePos.X - posMW.X, absolutePos.Y - posMW.Y);
return new Rect(absolutePos.X, absolutePos.Y, element.ActualWidth, element.ActualHeight);
}

Puis tout ce qui est nécessaire pour savoir si un bouton (par exemple) est cliquable est l'appel de:

 if (isElementClickable<Button>(Application.Current.MainWindow, myButton, out isPartiallyClickable))
{
//Whatever
}