// Token: 0x06007C12 RID: 31762 RVA: 0x0022E560 File Offset: 0x0022C760 private bool ResolveLocatorPart(DependencyObject dependencyObject, LocatorManager.ResolvingLocatorState data, bool visitedViaVisualTree) { if (data.Finished) { return(false); } ContentLocator contentLocatorBase = data.ContentLocatorBase; bool result = true; ContentLocatorPart contentLocatorPart = contentLocatorBase.Parts[data.LocatorPartIndex]; if (contentLocatorPart == null) { result = false; } SubTreeProcessor subTreeProcessorForLocatorPart = this.GetSubTreeProcessorForLocatorPart(contentLocatorPart); if (subTreeProcessorForLocatorPart == null) { result = false; } if (contentLocatorPart != null && subTreeProcessorForLocatorPart != null) { DependencyObject dependencyObject2 = subTreeProcessorForLocatorPart.ResolveLocatorPart(contentLocatorPart, dependencyObject, out result); if (dependencyObject2 != null) { data.AttachmentLevel = AttachmentLevel.Incomplete; data.AttachedAnchor = dependencyObject2; result = true; data.LastNodeMatched = dependencyObject2; data.LocatorPartIndex++; if (data.LocatorPartIndex == contentLocatorBase.Parts.Count) { data.AttachmentLevel = AttachmentLevel.Full; data.AttachedAnchor = dependencyObject2; result = false; } else if (data.LocatorPartIndex == contentLocatorBase.Parts.Count - 1) { contentLocatorPart = contentLocatorBase.Parts[data.LocatorPartIndex]; SelectionProcessor selectionProcessorForLocatorPart = this.GetSelectionProcessorForLocatorPart(contentLocatorPart); if (selectionProcessorForLocatorPart != null) { AttachmentLevel attachmentLevel; object obj = selectionProcessorForLocatorPart.ResolveLocatorPart(contentLocatorPart, dependencyObject2, out attachmentLevel); if (obj != null) { data.AttachmentLevel = attachmentLevel; data.AttachedAnchor = obj; result = false; } else { result = false; } } } } } return(result); }
// Token: 0x06007C0D RID: 31757 RVA: 0x0022E17C File Offset: 0x0022C37C private ContentLocatorBase GenerateLocatorGroup(PathNode node, object selection) { SubTreeProcessor subTreeProcessor = this.GetSubTreeProcessor(node.Node); ContentLocatorGroup contentLocatorGroup = new ContentLocatorGroup(); foreach (object obj in node.Children) { PathNode startNode = (PathNode)obj; IList <ContentLocatorBase> list = this.GenerateLocators(subTreeProcessor, startNode, selection); if (list != null && list.Count > 0 && list[0] != null) { ContentLocator contentLocator = list[0] as ContentLocator; if (contentLocator != null && contentLocator.Parts.Count != 0) { contentLocatorGroup.Locators.Add(contentLocator); } else { ContentLocatorGroup contentLocatorGroup2 = list[0] as ContentLocatorGroup; } } } if (contentLocatorGroup.Locators.Count == 0) { return(null); } if (contentLocatorGroup.Locators.Count == 1) { ContentLocator contentLocator2 = contentLocatorGroup.Locators[0]; contentLocatorGroup.Locators.Remove(contentLocator2); return(contentLocator2); } return(contentLocatorGroup); }
// Token: 0x06007C05 RID: 31749 RVA: 0x0022DD80 File Offset: 0x0022BF80 public IList <ContentLocatorBase> GenerateLocators(object selection) { base.VerifyAccess(); if (selection == null) { throw new ArgumentNullException("selection"); } SelectionProcessor selectionProcessor = this.GetSelectionProcessor(selection.GetType()); if (selectionProcessor != null) { ICollection nodes = (ICollection)selectionProcessor.GetSelectedNodes(selection); IList <ContentLocatorBase> list = null; PathNode pathNode = PathNode.BuildPathForElements(nodes); if (pathNode != null) { SubTreeProcessor subTreeProcessor = this.GetSubTreeProcessor(pathNode.Node); list = this.GenerateLocators(subTreeProcessor, pathNode, selection); } if (list == null) { list = new List <ContentLocatorBase>(0); } return(list); } throw new ArgumentException("Unsupported Selection", "selection"); }
// Token: 0x06007C0F RID: 31759 RVA: 0x0022E2D0 File Offset: 0x0022C4D0 private bool PostVisit(DependencyObject dependencyObject, LocatorManager.ProcessingTreeState data, bool visitedViaVisualTree) { bool flag = data.Pop(); SubTreeProcessor subTreeProcessor = this.GetSubTreeProcessor(dependencyObject); bool flag2 = false; IList <IAttachedAnnotation> list = subTreeProcessor.PostProcessNode(dependencyObject, flag, out flag2); if (list != null) { data.AttachedAnnotations.AddRange(list); } data.CalledProcessAnnotations = (data.CalledProcessAnnotations || flag2 || flag); return(true); }
// Token: 0x06007BFE RID: 31742 RVA: 0x0022D984 File Offset: 0x0022BB84 public void RegisterSubTreeProcessor(SubTreeProcessor processor, string processorId) { base.VerifyAccess(); if (processor == null) { throw new ArgumentNullException("processor"); } if (processorId == null) { throw new ArgumentNullException("processorId"); } XmlQualifiedName[] locatorPartTypes = processor.GetLocatorPartTypes(); this._subtreeProcessors[processorId] = processor; if (locatorPartTypes != null) { foreach (XmlQualifiedName key in locatorPartTypes) { this._locatorPartHandlers[key] = processor; } } }
// Token: 0x06007BFF RID: 31743 RVA: 0x0022D9EC File Offset: 0x0022BBEC public SubTreeProcessor GetSubTreeProcessor(DependencyObject node) { base.VerifyAccess(); if (node == null) { throw new ArgumentNullException("node"); } string text = node.GetValue(LocatorManager.SubTreeProcessorIdProperty) as string; if (string.IsNullOrEmpty(text)) { return(this._subtreeProcessors["Id"] as SubTreeProcessor); } SubTreeProcessor subTreeProcessor = (SubTreeProcessor)this._subtreeProcessors[text]; if (subTreeProcessor != null) { return(subTreeProcessor); } throw new ArgumentException(SR.Get("InvalidSubTreeProcessor", new object[] { text })); }
//------------------------------------------------------ // // Private Methods // //------------------------------------------------------ #region Private Methods #region Generating Locators /// <summary> /// Walks the path through the element tree specified by 'root' and /// produces a set of locators identifying the path based on /// DependencyProperty settings on the tree. /// </summary> /// <param name="processor">SubTreeProcessor to use on node</param> /// <param name="startNode">the PathNode identifying the root of the subtree to process</param> /// <param name="selection">selection for which Locators are being generated</param> /// <returns> /// a set of locators identifying the path through the element tree; /// can return null if no locators can be generated for this root /// </returns> /// <exception cref="ArgumentNullException">root is null</exception> /// <exception cref="SystemException">no AnnotationStore is available from /// the element tree</exception> private IList<ContentLocatorBase> GenerateLocators(SubTreeProcessor processor, PathNode startNode, Object selection) { Debug.Assert(startNode != null, "startNode can not be null"); List <ContentLocatorBase> locatorsToReturn = new List<ContentLocatorBase> (); bool continueProcessing = true; // Process the current PathNode, with the possibilty of doing the whole // subtree (in which case continueProcessing comes back false). ContentLocator list = processor.GenerateLocator(startNode, out continueProcessing); bool processSelection = list != null; IList<ContentLocatorBase> newLocators = null; // If we should continue processing, we look at the children of the // root. Depending on the number of children we do different things. if (continueProcessing) { switch (startNode.Children.Count) { case 0 : // No children - we just return what we have so far if (list != null) { locatorsToReturn.Add(list); } break; case 1 : // One child - we ask the root of the subtree for the processor // to use and then ask the processor to handle the subtree. SubTreeProcessor newProcessor = GetSubTreeProcessor(startNode.Node); newLocators = GenerateLocators(newProcessor, (PathNode)startNode.Children[0], selection); if (newLocators != null && newLocators.Count > 0) processSelection = false; if (list != null) locatorsToReturn.AddRange(Merge(list, newLocators)); else locatorsToReturn.AddRange(newLocators); break; default : // Multiple children - we must process all the children as a // locator set. This returns one or more locators that all start // start with a ContentLocatorGroup which can have one locator for each // child. ContentLocatorBase newLocator = GenerateLocatorGroup(startNode, selection); if (newLocator != null) processSelection = false; if (list != null) locatorsToReturn.Add(list.Merge(newLocator)); else if (newLocator != null) locatorsToReturn.Add(newLocator); break; } } else { // If we shouldn't continue processing we package up the // locator we got from the first GenerateLocator call if (list != null) { locatorsToReturn.Add(list); } } // If we produced a locator for root and no one below us did as well, // we need to process the selection, if any if (processSelection && selection != null) { SelectionProcessor selProcessor = GetSelectionProcessor(selection.GetType()); if (selProcessor != null) { IList <ContentLocatorPart> locatorParts = selProcessor.GenerateLocatorParts(selection, startNode.Node); // Possible bug - AddLocatorPartsToLocator was only written to handle normal locators, not // locator groups. ToDo if (locatorParts != null && locatorParts.Count > 0) { List<ContentLocatorBase> tempLocators = new List<ContentLocatorBase>(locatorsToReturn.Count * locatorParts.Count); foreach (ContentLocatorBase loc in locatorsToReturn) { tempLocators.AddRange(((ContentLocator)loc).DotProduct(locatorParts)); // } locatorsToReturn = tempLocators; } } } return locatorsToReturn; }
//------------------------------------------------------ // // Public Methods // //------------------------------------------------------ #region Public Methods #region Processor Caches /// <summary> /// Registers a subtree processor. The processorId is the string to be /// used as the value of the SubTreeProcessorIdProperty for this processor. /// This call overrides any previous registrations for processorId or for /// the locator part types recognized by processor. /// </summary> /// <param name="processor">instance to be registered</param> /// <param name="processorId">string id used to specify this processor as /// the SubTreeProcessorIdProperty value</param> /// <exception cref="ArgumentNullException">if the processor or processorId are null</exception> public void RegisterSubTreeProcessor(SubTreeProcessor processor, String processorId) { VerifyAccess(); if (processor == null) throw new ArgumentNullException("processor"); if (processorId == null) throw new ArgumentNullException("processorId"); XmlQualifiedName[] locatorPartTypes = processor.GetLocatorPartTypes(); _subtreeProcessors[processorId] = processor; if (locatorPartTypes != null) { foreach (XmlQualifiedName typeName in locatorPartTypes) { _locatorPartHandlers[typeName] = processor; } } }
// Token: 0x06007C0C RID: 31756 RVA: 0x0022DFEC File Offset: 0x0022C1EC private IList <ContentLocatorBase> GenerateLocators(SubTreeProcessor processor, PathNode startNode, object selection) { List <ContentLocatorBase> list = new List <ContentLocatorBase>(); bool flag = true; ContentLocator contentLocator = processor.GenerateLocator(startNode, out flag); bool flag2 = contentLocator != null; if (flag) { int count = startNode.Children.Count; if (count != 0) { if (count != 1) { ContentLocatorBase contentLocatorBase = this.GenerateLocatorGroup(startNode, selection); if (contentLocatorBase != null) { flag2 = false; } if (contentLocator != null) { list.Add(contentLocator.Merge(contentLocatorBase)); } else if (contentLocatorBase != null) { list.Add(contentLocatorBase); } } else { SubTreeProcessor subTreeProcessor = this.GetSubTreeProcessor(startNode.Node); IList <ContentLocatorBase> list2 = this.GenerateLocators(subTreeProcessor, (PathNode)startNode.Children[0], selection); if (list2 != null && list2.Count > 0) { flag2 = false; } if (contentLocator != null) { list.AddRange(this.Merge(contentLocator, list2)); } else { list.AddRange(list2); } } } else if (contentLocator != null) { list.Add(contentLocator); } } else if (contentLocator != null) { list.Add(contentLocator); } if (flag2 && selection != null) { SelectionProcessor selectionProcessor = this.GetSelectionProcessor(selection.GetType()); if (selectionProcessor != null) { IList <ContentLocatorPart> list3 = selectionProcessor.GenerateLocatorParts(selection, startNode.Node); if (list3 != null && list3.Count > 0) { List <ContentLocatorBase> list4 = new List <ContentLocatorBase>(list.Count * list3.Count); foreach (ContentLocatorBase contentLocatorBase2 in list) { list4.AddRange(((ContentLocator)contentLocatorBase2).DotProduct(list3)); } list = list4; } } } return(list); }