protected VisualTreeItem(object target, VisualTreeItem parent) { this.target = target; this.parent = parent; if (parent != null) this.depth = parent.depth + 1; }
public static VisualTreeItem Construct(object target, VisualTreeItem parent) { VisualTreeItem visualTreeItem; if (target is Visual) { visualTreeItem = new VisualItem((Visual)target, parent); } else if (target is ResourceDictionary) { visualTreeItem = new ResourceDictionaryItem((ResourceDictionary)target, parent); } else if (target is Application) { visualTreeItem = new ApplicationTreeItem((Application)target, parent); } else { visualTreeItem = new VisualTreeItem(target, parent); } visualTreeItem.Reload(); return(visualTreeItem); }
private void HandlePreProcessInput(object sender, PreProcessInputEventArgs e) { this.OnPropertyChanged("CurrentFocus"); ModifierKeys currentModifiers = InputManager.Current.PrimaryKeyboardDevice.Modifiers; if (!((currentModifiers & ModifierKeys.Control) != 0 && (currentModifiers & ModifierKeys.Shift) != 0)) { return; } //ModifierKeys currentModifiers = InputManager.Current.PrimaryKeyboardDevice.Modifiers; if ((currentModifiers & ModifierKeys.Alt) != 0) { return; } Visual directlyOver = Mouse.PrimaryDevice.DirectlyOver as Visual; if ((directlyOver == null) || directlyOver.IsDescendantOf(this)) { return; } VisualTreeItem node = this.FindItem(directlyOver); if (node != null) { this.CurrentSelection = node; } }
public static VisualTreeItem Construct(object target, VisualTreeItem parent) { VisualTreeItem visualTreeItem; if (target is IReflectionHelperInterfaceWrapper) { visualTreeItem = new VisualItem(((IReflectionHelperInterfaceWrapper)target).Source, parent); } else if (target.Wrap <IFrameworkRenderElementContext>() != null) { visualTreeItem = new VisualItem(target, parent); } else if (target is Visual) { visualTreeItem = new VisualItem((Visual)target, parent); } else if (target is ResourceDictionary) { visualTreeItem = new ResourceDictionaryItem((ResourceDictionary)target, parent); } else if (target is Application) { visualTreeItem = new ApplicationTreeItem((Application)target, parent); } else { visualTreeItem = new DumbVisualTreeItem(target, parent); } //visualTreeItem = new VisualTreeItem(target, parent); visualTreeItem.Reload(); return(visualTreeItem); }
private void HandleRefresh(object sender, ExecutedRoutedEventArgs e) { Cursor saveCursor = Mouse.OverrideCursor; Mouse.OverrideCursor = Cursors.Wait; try { object currentTarget = this.CurrentSelection != null ? this.CurrentSelection.Target : null; this.visualTreeItems.Clear(); this.Root = VisualTreeItem.Construct(this.root, null); if (currentTarget != null) { VisualTreeItem visualItem = this.FindItem(currentTarget); if (visualItem != null) { this.CurrentSelection = visualItem; } } this.SetFilter(this.filter); } finally { Mouse.OverrideCursor = saveCursor; } }
protected override void Reload(List <VisualTreeItem> toBeRemoved) { // having the call to base.Reload here ... puts the application resources at the very top of the tree view base.Reload(toBeRemoved); foreach (Window window in this.application.Windows) { if (window.IsInitialized == false || window.CheckAccess() == false) { continue; } // windows which have an owner are added as child items in VisualItem, so we have to skip them here if (window.Owner != null) { continue; } // don't recreate existing items but reload them instead var existingItem = toBeRemoved.FirstOrDefault(x => ReferenceEquals(x.Target, window)); if (existingItem != null) { toBeRemoved.Remove(existingItem); existingItem.Reload(); continue; } this.Children.Add(VisualTreeItem.Construct(window, this)); } }
public void Next() { if (!IsFiltering) { return; } var lFilter = Filter.ToLower(); VisualTreeItem current = null; while (ItemsEnumerator.MoveNext()) { current = ItemsEnumerator.Current; if (current.MatchesFilter(lFilter) && current != Root) { break; } current = null; } if (current != null) { SelectElement(current); } else { if (reloading) { return; } reloading = true; PrepareNewFilter(); Next(); reloading = false; } }
public static void AddEditedProperty(Dispatcher dispatcher, VisualTreeItem propertyOwner, PropertyInformation propInfo) { lock (_lock) { List <PropertyValueInfo> propInfoList = null; Dictionary <VisualTreeItem, List <PropertyValueInfo> > dispatcherList = null; // first get the dictionary we're using for the given dispatcher if (!_itemsWithEditedProperties.TryGetValue(dispatcher, out dispatcherList)) { dispatcherList = new Dictionary <VisualTreeItem, List <PropertyValueInfo> >(); _itemsWithEditedProperties.Add(dispatcher, dispatcherList); } // now get the property info list for the owning object if (!dispatcherList.TryGetValue(propertyOwner, out propInfoList)) { propInfoList = new List <PropertyValueInfo>(); dispatcherList.Add(propertyOwner, propInfoList); } // if we already have a property of that name on this object, remove it var existingPropInfo = propInfoList.FirstOrDefault(l => l.PropertyName == propInfo.DisplayName); if (existingPropInfo != null) { propInfoList.Remove(existingPropInfo); } // finally add the edited property info propInfoList.Add(new PropertyValueInfo { PropertyName = propInfo.DisplayName, PropertyValue = propInfo.Value }); } }
public VisualTreeItem FindNode(object target) { // it might be faster to have a map for the lookup // check into this at some point if (this.Target == target) { if (DXMethods.IsChrome(Target) && target is IInputElement) { var root = DXMethods.GetRoot(Target); if (root != null) { var child = RenderTreeHelper.HitTest(root, System.Windows.Input.Mouse.GetPosition((IInputElement)target)); var node = FindNode(child); if (node != null) { return(node); } } } return(this); } foreach (VisualTreeItem child in this.Children) { VisualTreeItem node = child.FindNode(target); if (node != null) { return(node); } } return(null); }
protected override void Reload(List <VisualTreeItem> toBeRemoved) { // having the call to base.Reload here ... puts the application resources at the very top of the tree view base.Reload(toBeRemoved); // what happens in the case where the application's main window is invisible? // in this case, the application will only have one visual item underneath it: the collapsed/hidden window. // however, you are still able to ctrl-shift mouse over the visuals in the visible window. // when you do this, snoop reloads the visual tree with the visible window as the root (versus the application). if (this.application.MainWindow != null) { bool foundMainWindow = false; foreach (VisualTreeItem item in toBeRemoved) { if (item.Target == this.application.MainWindow) { toBeRemoved.Remove(item); item.Reload(); foundMainWindow = true; break; } } if (!foundMainWindow) { this.Children.Add(VisualTreeItem.Construct(this.application.MainWindow, this)); } } }
protected override void Reload(List <VisualTreeItem> toBeRemoved) { base.Reload(toBeRemoved); ResourceDictionary resources = this.ResourceDictionary; if (resources != null && resources.Count != 0) { bool foundItem = false; foreach (VisualTreeItem item in toBeRemoved) { if (item.Target == resources) { toBeRemoved.Remove(item); item.Reload(); foundItem = true; break; } } if (!foundItem) { this.Children.Add(VisualTreeItem.Construct(resources, this)); } } }
public static VisualTreeItem Construct(object target, VisualTreeItem parent) { VisualTreeItem visualTreeItem; if (DXMethods.IsFrameworkRenderElementContext(target)) { visualTreeItem = new VisualItem(target, parent); } else if (target is Visual) { visualTreeItem = new VisualItem((Visual)target, parent); } else if (target is ResourceDictionary) { visualTreeItem = new ResourceDictionaryItem((ResourceDictionary)target, parent); } else if (target is Application) { visualTreeItem = new ApplicationTreeItem((Application)target, parent); } else { visualTreeItem = new VisualTreeItem(target, parent); } visualTreeItem.Reload(); return(visualTreeItem); }
protected VisualTreeItem(object target, VisualTreeItem parent) { if (target == null) throw new ArgumentNullException("target"); this.target = target; this.parent = parent; if (parent != null) this.depth = parent.depth + 1; }
void Load(object root) { this.root = root; Root = VisualTreeItem.Construct(root, null); CurrentSelection = rootVisualTreeItem; OnPropertyChanged("Root"); }
void RaiseEndUpdate(VisualTreeItem element) { if (Parent != null) { Parent.RaiseEndUpdate(element); return; } EndUpdate?.Invoke(element, EventArgs.Empty); }
public VisualItem(object visual, VisualTreeItem parent) : base(visual, parent) { Visual = visual; if (visual is Visual) { var vVisual = (Visual)visual; VisualDiagnostics.VisualTreeChanged += VisualDiagnostics_VisualTreeChanged; } }
protected VisualTreeItem(object target, VisualTreeItem parent) { this.target = target; this.parent = parent; if (parent != null) { this.depth = parent.depth + 1; } }
private void HandleTreeSelectedItemChanged(object sender, EventArgs e) { VisualTreeItem item = this.Tree.SelectedItem as VisualTreeItem; if (item != null) { this.CurrentSelection = item; } }
/// <summary> /// Loop through the properties in the current PropertyGrid and save away any properties /// that have been changed by the user. /// </summary> /// <param name="owningObject">currently selected object that owns the properties in the grid (before changing selection to the new object)</param> private void SaveEditedProperties(VisualTreeItem owningObject) { foreach (PropertyInformation property in PropertyGrid.PropertyGrid.Properties) { if (property.IsValueChangedByUser) { EditedPropertiesHelper.AddEditedProperty(Dispatcher, owningObject, property); } } }
private void SelectItem(DependencyObject item) { if (item != null) { VisualTreeItem node = this.FindItem(item); if (node != null) { this.CurrentSelection = node; } } }
private void Load(object root) { this.root = root; this.visualTreeItems.Clear(); this.Root = VisualTreeItem.Construct(root, null); this.CurrentSelection = this.rootVisualTreeItem; this.SetFilter(this.filter); this.OnPropertyChanged("Root"); }
void OnChildExpanded(VisualTreeItem child) { if (Parent != null) { Parent.OnChildExpanded(child); return; } if (child == null || ChildExpandedChanged == null) { return; } ChildExpandedChanged(child, EventArgs.Empty); }
protected VisualTreeItem(object target, VisualTreeItem parent) { if (target == null) { throw new ArgumentNullException("target"); } this.target = target; this.parent = parent; if (parent != null) { this.depth = parent.depth + 1; } }
private void FilterTree(VisualTreeItem node, string filter) { foreach (VisualTreeItem child in node.Children) { if (child.Filter(filter)) { this.visualTreeItems.Add(child); } else { FilterTree(child, filter); } } }
private void FilterBindings(VisualTreeItem node) { foreach (VisualTreeItem child in node.Children) { if (child.HasBindingError) { this.visualTreeItems.Add(child); } else { FilterBindings(child); } } }
public bool ApplyReduceDepthFilterIfNeeded(ProperTreeViewItem curNode) { if (_pendingRoot != null) { OnRootLoaded(); } if (_maxDepth == 0) { return(false); } VisualTreeItem rootItem = (VisualTreeItem)_rootItem.Target; if (rootItem == null) { return(false); } if (_snoopUI == null) { _snoopUI = VisualTreeHelper2.GetAncestor <SnoopUI>(this); if (_snoopUI == null) { return(false); } } VisualTreeItem item = (VisualTreeItem)curNode.DataContext; VisualTreeItem selectedItem = _snoopUI.CurrentSelection; if (selectedItem != null && item.Depth < selectedItem.Depth) { item = selectedItem; } if ((item.Depth - rootItem.Depth) <= _maxDepth) { return(false); } for (int i = 0; i < _maxDepth; ++i) { item = item.Parent; } _snoopUI.ApplyReduceDepthFilter(item); return(true); }
public static VisualTreeItem Construct(object target, VisualTreeItem parent) { VisualTreeItem visualTreeItem; if (target is Visual) visualTreeItem = new VisualItem((Visual)target, parent); else if (target is ResourceDictionary) visualTreeItem = new ResourceDictionaryItem((ResourceDictionary)target, parent); else if (target is Application) visualTreeItem = new ApplicationTreeItem((Application)target, parent); else visualTreeItem = new VisualTreeItem(target, parent); visualTreeItem.Reload(); return visualTreeItem; }
private void HandleInspect(object sender, ExecutedRoutedEventArgs e) { Visual visual = e.Parameter as Visual; if (visual != null) { VisualTreeItem node = this.FindItem(visual); if (node != null) { this.CurrentSelection = node; } } else if (e.Parameter != null) { this.PropertyGrid.SetTarget(e.Parameter); } }
protected override void Reload(List <VisualTreeItem> toBeRemoved) { // having the call to base.Reload here ... puts the application resources at the very top of the tree view. // this used to be at the bottom. putting it here makes it consistent (and easier to use) with ApplicationTreeItem base.Reload(toBeRemoved); // remove items that are no longer in tree, add new ones. for (int i = 0; i < CommonTreeHelper.GetChildrenCount(this.Visual); i++) { object child = CommonTreeHelper.GetChild(this.Visual, i); if (child != null) { bool foundItem = false; foreach (VisualTreeItem item in toBeRemoved) { if (item.Target == child) { toBeRemoved.Remove(item); item.Reload(); foundItem = true; break; } } if (!foundItem) { this.Children.Add(VisualTreeItem.Construct(child, this)); } } } Grid grid = this.Visual as Grid; if (grid != null) { foreach (RowDefinition row in grid.RowDefinitions) { this.Children.Add(VisualTreeItem.Construct(row, this)); } foreach (ColumnDefinition column in grid.ColumnDefinitions) { this.Children.Add(VisualTreeItem.Construct(column, this)); } } }
/// <summary> /// Find the VisualTreeItem for the specified visual. /// If the item is not found and is not part of the Snoop UI, /// the tree will be adjusted to include the window the item is in. /// </summary> private VisualTreeItem FindItem(object target) { if (this.rootVisualTreeItem == null) { return(null); } VisualTreeItem node = this.rootVisualTreeItem.FindNode(target); Visual rootVisual = this.rootVisualTreeItem.MainVisual; if (node == null) { Visual visual = target as Visual; if (visual != null && rootVisual != null) { // If target is a part of the SnoopUI, let's get out of here. if (visual.IsDescendantOf(this)) { return(null); } // If not in the root tree, make the root be the tree the visual is in. if (!visual.IsDescendantOf(rootVisual)) { var presentationSource = PresentationSource.FromVisual(visual); if (presentationSource == null) { return(null); // Something went wrong. At least we will not crash with null ref here. } this.Root = new VisualItem(presentationSource.RootVisual, null); } } this.rootVisualTreeItem.Reload(); node = this.rootVisualTreeItem.FindNode(target); this.SetFilter(this.filter); } return(node); }
public VisualTreeItem FindNode(object target) { // it might be faster to have a map for the lookup // check into this at some point if (this.Target == target) { return(this); } foreach (VisualTreeItem child in this.Children) { VisualTreeItem node = child.FindNode(target); if (node != null) { return(node); } } return(null); }
public void ApplyReduceDepthFilter(VisualTreeItem newRoot) { if (m_reducedDepthRoot != newRoot) { if (m_reducedDepthRoot == null) { Dispatcher.BeginInvoke ( DispatcherPriority.Background, (function) delegate { this.visualTreeItems.Clear(); this.visualTreeItems.Add(m_reducedDepthRoot); m_reducedDepthRoot = null; } ); } m_reducedDepthRoot = newRoot; } }
VisualTreeItem GetItemAtImpl(ref int index) { if (index == 0) { return(this); } index--; VisualTreeItem result = null; if (!isExpanded) { return(null); } foreach (var child in Children) { if (result != null) { return(result); } result = child.GetItemAtImpl(ref index); } return(result); }
public static void AddEditedProperty( Dispatcher dispatcher, VisualTreeItem propertyOwner, PropertyInformation propInfo) { lock ( _lock ) { List<PropertyValueInfo> propInfoList = null; Dictionary<VisualTreeItem, List<PropertyValueInfo>> dispatcherList = null; // first get the dictionary we're using for the given dispatcher if ( !_itemsWithEditedProperties.TryGetValue( dispatcher, out dispatcherList ) ) { dispatcherList = new Dictionary<VisualTreeItem, List<PropertyValueInfo>>(); _itemsWithEditedProperties.Add( dispatcher, dispatcherList ); } // now get the property info list for the owning object if ( !dispatcherList.TryGetValue( propertyOwner, out propInfoList ) ) { propInfoList = new List<PropertyValueInfo>(); dispatcherList.Add( propertyOwner, propInfoList ); } // if we already have a property of that name on this object, remove it var existingPropInfo = propInfoList.FirstOrDefault( l => l.PropertyName == propInfo.DisplayName ); if ( existingPropInfo != null ) { propInfoList.Remove( existingPropInfo ); } // finally add the edited property info propInfoList.Add( new PropertyValueInfo { PropertyName = propInfo.DisplayName, PropertyValue = propInfo.Value, } ); } }
public ResourceItem(object target, object key, VisualTreeItem parent) : base(target, parent) { this.key = key; }
public ApplicationTreeItem(Application application, VisualTreeItem parent) : base(application, parent) { this.application = application; }
private void DumpItem(VisualTreeItem item) { // Base indent StringBuilder sb = new StringBuilder(); for (int i = 0; i <= item.Depth; i++) { sb.Append(" "); } String baseIndent = sb.ToString(); // Write node element Writer.Write(baseIndent); Writer.Write("<node"); String nodeName = item.Name; if (string.IsNullOrEmpty(nodeName)) { nodeName = item.ToString(); } Writer.Write(" name=\""); Writer.Write(EscapeXML(nodeName)); Writer.Write("\""); Writer.WriteLine(">"); foreach (PropertyInformation propInfo in PropertyInformation.GetProperties(item.Target)) { if (!"Children".Equals(propInfo.DisplayName) && !"Parent".Equals(propInfo.DisplayName)) { Writer.Write(baseIndent); WriteProperty(propInfo.DisplayName, propInfo.Value); } propInfo.Teardown(); } FrameworkElement elem = item.Target as FrameworkElement; if (elem != null) { if (RootVisual == null) { RootVisual = elem; } try { Rect bounds = elem.TransformToAncestor(RootVisual).TransformBounds(VisualTreeHelper.GetDescendantBounds(elem)); if (!bounds.IsEmpty) { Writer.Write(baseIndent); WriteProperty("x-BoundsInClientArea", bounds.ToString()); //bounds.Offset(new Vector(0, SystemParameters.WindowCaptionHeight)); //Writer.Write(baseIndent); //WriteProperty("x-BoundsInWindow", bounds.ToString()); } } catch (Exception) { // In case this element is not a child of the root. Ignore. } } foreach (VisualTreeItem child in item.Children) { DumpItem(child); } Writer.Write(baseIndent); Writer.WriteLine("</node>"); }
private void FilterBindings(VisualTreeItem node) { foreach (VisualTreeItem child in node.Children) { if (child.HasBindingError) this.visualTreeItems.Add(child); else FilterBindings(child); } }
private void Load(object root) { this.root = root; this.visualTreeItems.Clear(); this.rootVisualTreeItem = VisualTreeItem.Construct(root, null); this.CurrentSelection = this.rootVisualTreeItem; this.SetFilter(this.filter); this.OnPropertyChanged("Root"); }
private void HandleRefresh(object sender, ExecutedRoutedEventArgs e) { Cursor saveCursor = Mouse.OverrideCursor; Mouse.OverrideCursor = Cursors.Wait; try { object currentTarget = this.CurrentSelection != null ? this.CurrentSelection.Target : null; this.visualTreeItems.Clear(); this.rootVisualTreeItem = VisualTreeItem.Construct(this.root, null); if (currentTarget != null) { VisualTreeItem visualItem = this.FindItem(currentTarget); if (visualItem != null) this.CurrentSelection = visualItem; } this.SetFilter(this.filter); } finally { Mouse.OverrideCursor = saveCursor; } }
/// <summary> /// Find the VisualTreeItem for the specified visual. /// If the item is not found and is not part of the Snoop UI, /// the tree will be adjusted to include the window the item is in. /// </summary> private VisualTreeItem FindItem(object target) { VisualTreeItem node = this.rootVisualTreeItem.FindNode(target); Visual rootVisual = this.rootVisualTreeItem.MainVisual; if (node == null) { Visual visual = target as Visual; if (visual != null && rootVisual != null) { // If target is a part of the SnoopUI, let's get out of here. if (visual.IsDescendantOf(this)) { return null; } // If not in the root tree, make the root be the tree the visual is in. if (!visual.IsDescendantOf(rootVisual)) { var presentationSource = PresentationSource.FromVisual(visual); if (presentationSource == null) { return null; // Something went wrong. At least we will not crash with null ref here. } this.rootVisualTreeItem = new VisualItem(presentationSource.RootVisual, null); } } this.rootVisualTreeItem.Reload(); node = this.rootVisualTreeItem.FindNode(target); this.SetFilter(this.filter); } return node; }
public VisualItem(Visual visual, VisualTreeItem parent) : base(visual, parent) { this.visual = visual; }
public ResourceDictionaryItem(ResourceDictionary dictionary, VisualTreeItem parent) : base(dictionary, parent) { this.dictionary = dictionary; }
/// <summary> /// Loop through the properties in the current PropertyGrid and save away any properties /// that have been changed by the user. /// </summary> /// <param name="owningObject">currently selected object that owns the properties in the grid (before changing selection to the new object)</param> private void SaveEditedProperties( VisualTreeItem owningObject ) { foreach (PropertyInformation property in PropertyGrid.PropertyGrid.Properties) { if (property.IsValueChangedByUser) { EditedPropertiesHelper.AddEditedProperty( Dispatcher, owningObject, property ); } } }
public static void DumpTree(VisualTreeItem root, System.IO.StreamWriter writer) { XMLTreeWriter treeWriter = new XMLTreeWriter(writer); writer.WriteLine("<?xml version=\"1.0\" encoding=\"UTF-8\"?>"); writer.WriteLine("<root>"); treeWriter.DumpItem(root); writer.WriteLine("</root>"); }
public ResourceContainerItem(object target, VisualTreeItem parent): base(target, parent) { }
private void FilterTree(VisualTreeItem node, string filter) { foreach (VisualTreeItem child in node.Children) { if (child.Filter(filter)) this.visualTreeItems.Add(child); else FilterTree(child, filter); } }
protected void RemoveChild(VisualTreeItem item) { item.IsSelected = false; this.Children.Remove(item); }