Contrôle utilisateur WPF parent

Question

J'ai un contrôle utilisateur que je charge dans un MainWindow lors de l'exécution. Je ne peux pas obtenir un handle sur la fenêtre contenant à partir du UserControl. J'ai essayé this.Parent, mais c'est toujours null. Est-ce que quelqu'un sait comment obtenir un handle de la fenêtre contenant à partir d'un contrôle utilisateur dans WPF?

Voici comment le contrôle est chargé:

private void XMLLogViewer_MenuItem_Click(object sender, RoutedEventArgs e) 
{ 
    MenuItem application = sender as MenuItem; 
    string parameter = application.CommandParameter as string; 
    string controlName = parameter; 
    if (uxPanel.Children.Count == 0) 
    { 
     System.Runtime.Remoting.ObjectHandle instance = Activator.CreateInstance(Assembly.GetExecutingAssembly().FullName, controlName); 
     UserControl control = instance.Unwrap() as UserControl; 
     this.LoadControl(control); 
    } 
} 

private void LoadControl(UserControl control) 
{ 
    if (uxPanel.Children.Count > 0) 
    { 
     foreach (UIElement ctrl in uxPanel.Children) 
     { 
      if (ctrl.GetType() != control.GetType()) 
      { 
       this.SetControl(control); 
      } 
     } 
    } 
    else 
    { 
     this.SetControl(control); 
    } 
} 

private void SetControl(UserControl control) 
{ 
    control.Width = uxPanel.Width; 
    control.Height = uxPanel.Height; 
    uxPanel.Children.Add(control); 
} 

Answer 1

Essayez d'utiliser VisualTreeHelper.GetParent ou utiliser la fonction récursive ci-dessous pour trouver la fenêtre parent.

public static Window FindParentWindow(DependencyObject child) 
    { 
     DependencyObject parent= VisualTreeHelper.GetParent(child); 

     //CHeck if this is the end of the tree 
     if (parent == null) return null; 

     Window parentWindow = parent as Window; 
     if (parentWindow != null) 
     { 
      return parentWindow; 
     } 
     else 
     { 
      //use recursion until it reaches a Window 
      return FindParentWindow(parent); 
     } 
    } 

Answer 2

Essayez d'utiliser les éléments suivants

Window parentWindow = Window.GetWindow(userControlRefernce); 

La méthode GetWindow marcheront le VisualTree pour vous et localiser la fenêtre qui héberge votre contrôle.

Answer 3

J'ai découvert que le parent d'un contrôle UserControl est toujours null dans le constructeur, mais dans tous les gestionnaires d'événements, le parent est défini correctement. Je suppose que cela doit avoir quelque chose à voir avec la façon dont l'arbre de contrôle est chargé. Donc, pour contourner cela, vous pouvez simplement obtenir le parent dans l'événement Controls Loaded.

Pour une caisse exemple cette question WPF User Control's DataContext is Null

Answer 4

je devais utiliser la méthode Window.GetWindow (ce) dans gestionnaire d'événements Loaded. En d'autres termes, j'ai utilisé la réponse de Ian Oakes en combinaison avec la réponse d'Alex pour obtenir le parent d'un contrôle utilisateur.

public MainView() 
{ 
    InitializeComponent(); 

    this.Loaded += new RoutedEventHandler(MainView_Loaded); 
} 

void MainView_Loaded(object sender, RoutedEventArgs e) 
{ 
    Window parentWindow = Window.GetWindow(this); 

    ... 
} 

Answer 5

Je vais ajouter mon expérience. Bien que l'utilisation de l'événement Loaded puisse faire le travail, je pense qu'il peut être plus approprié de remplacer la méthode OnInitialized. Chargé se produit après la première fenêtre est affichée. OnInitialized vous donne la possibilité d'apporter des modifications, par exemple, ajouter des contrôles à la fenêtre avant qu'il ne soit rendu.

Answer 6

Que diriez-vous ceci:

DependencyObject parent = ExVisualTreeHelper.FindVisualParent<UserControl>(this); 

public static class ExVisualTreeHelper 
{ 
    /// <summary> 
    /// Finds the visual parent. 
    /// </summary> 
    /// <typeparam name="T"></typeparam> 
    /// <param name="sender">The sender.</param> 
    /// <returns></returns> 
    public static T FindVisualParent<T>(DependencyObject sender) where T : DependencyObject 
    { 
     if (sender == null) 
     { 
      return (null); 
     } 
     else if (VisualTreeHelper.GetParent(sender) is T) 
     { 
      return (VisualTreeHelper.GetParent(sender) as T); 
     } 
     else 
     { 
      DependencyObject parent = VisualTreeHelper.GetParent(sender); 
      return (FindVisualParent<T>(parent)); 
     } 
    } 
} 

Answer 7

DependencyObject parent = ExVisualTreeHelper.FindVisualParent<UserControl>(this); 

Answer 8

Cette approche a fonctionné pour moi, mais ce n'est pas aussi précis que votre question:

App.Current.MainWindow 

Answer 9

DependencyObject GetTopParent(DependencyObject current) 
{ 
    while (VisualTreeHelper.GetParent(current) != null) 
    { 
     current = VisualTreeHelper.GetParent(current); 
    } 
    return current; 
} 

DependencyObject parent = GetTopParent(thisUserControl); 

Answer 10

Une autre façon:

var main = App.Current.MainWindow as MainWindow; 

Answer 11

Il travaille pour moi:

DependencyObject GetTopLevelControl(DependencyObject control) 
{ 
    DependencyObject tmp = control; 
    DependencyObject parent = null; 
    while((tmp = VisualTreeHelper.GetParent(tmp)) != null) 
    { 
     parent = tmp; 
    } 
    return parent; 
} 

Answer 12

Si vous trouvez cette question et la VisualTreeHelper ne fonctionne pas pour vous ou travailler de façon sporadique, vous devrez peut-être inclure LogicalTreeHelper dans votre algorithme.

Voici ce que je suis en utilisant:

public static T TryFindParent<T>(DependencyObject current) where T : class 
{ 
    DependencyObject parent = VisualTreeHelper.GetParent(current); 
    if(parent == null) 
     parent = LogicalTreeHelper.GetParent(current); 
    if(parent == null) 
     return null; 

    if(parent is T) 
     return parent as T; 
    else 
     return TryFindParent<T>(parent); 
} 

Answer 13

Cela ne fonctionne pas pour moi, car il est allé trop loin dans l'arbre, et a la fenêtre racine absolue pour l'ensemble de l'application:

Window parentWindow = Window.GetWindow(userControlReference); 

Cependant, cela a fonctionné pour obtenir la fenêtre immédiate:

DependencyObject parent = uiElement; 
int avoidInfiniteLoop = 0; 
while ((parent is Window)==false) 
{ 
    parent = VisualTreeHelper.GetParent(parent); 
    avoidInfiniteLoop++; 
    if (avoidInfiniteLoop == 1000) 
    { 
     // Something is wrong - we could not find the parent window. 
     break; 
    } 
} 
Window window = parent as Window; 
window.DragMove(); 

Answer 14

plaqué or édition de ce qui précède (je besoin d'un fu générique nction qui peut déduire un Window dans le cadre d'un MarkupExtension: -

public sealed class MyExtension : MarkupExtension 
{ 
    public override object ProvideValue(IServiceProvider serviceProvider) => 
     new MyWrapper(ResolveRootObject(serviceProvider)); 
    object ResolveRootObject(IServiceProvider serviceProvider) => 
     GetService<IRootObjectProvider>(serviceProvider).RootObject; 
} 

class MyWrapper 
{ 
    object _rootObject; 

    Window OwnerWindow() => WindowFromRootObject(_rootObject); 

    static Window WindowFromRootObject(object root) => 
     (root as Window) ?? VisualParent<Window>((DependencyObject)root); 
    static T VisualParent<T>(DependencyObject node) where T : class 
    { 
     if (node == null) 
      throw new InvalidOperationException("Could not locate a parent " + typeof(T).Name); 
     var target = node as T; 
     if (target != null) 
      return target; 
     return VisualParent<T>(VisualTreeHelper.GetParent(node)); 
    } 
} 

MyWrapper.Owner() sera correctement déduire une fenêtre sur la base suivante:

• la racine Window en marchant l'arbre visuel (si elle est utilisée le contexte d'un UserControl)
• la fenêtre dans laquelle il est utilisé (si elle est utilisée dans le contexte d'un balisage de » Window)