// Token: 0x06007BC7 RID: 31687 RVA: 0x0022C590 File Offset: 0x0022A790 public override ContentLocator GenerateLocator(PathNode node, out bool continueGenerating) { if (node == null) { throw new ArgumentNullException("node"); } continueGenerating = true; ContentLocator contentLocator = null; DocumentPageView documentPageView = node.Node as DocumentPageView; int num = -1; if (documentPageView != null) { if (documentPageView.DocumentPage is FixedDocumentPage || documentPageView.DocumentPage is FixedDocumentSequenceDocumentPage) { num = documentPageView.PageNumber; } } else { FixedTextSelectionProcessor.FixedPageProxy fixedPageProxy = node.Node as FixedTextSelectionProcessor.FixedPageProxy; if (fixedPageProxy != null) { num = fixedPageProxy.Page; } } if (num >= 0) { contentLocator = new ContentLocator(); ContentLocatorPart item = FixedPageProcessor.CreateLocatorPart(num); contentLocator.Parts.Add(item); } return(contentLocator); }
// 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); }
/// <summary> /// Do the GetAnnotations work inside a lock statement for thread safety reasons /// </summary> /// <param name="query"></param> /// <param name="anchorLocator"></param> /// <returns></returns> private IList <Annotation> InternalGetAnnotations(string query, ContentLocator anchorLocator) { // anchorLocator being null is handled appropriately below Invariant.Assert(query != null, "Parameter 'query' is null."); lock (SyncRoot) { CheckStatus(); List <Guid> annotationIds = FindAnnotationIds(query); Dictionary <Guid, Annotation> annotations = null; // Now, get the annotations in the map that satisfies the query criterion if (anchorLocator == null) { annotations = _storeAnnotationsMap.FindAnnotations(); } else { annotations = _storeAnnotationsMap.FindAnnotations(anchorLocator); } // merge both query results return(MergeAndCacheAnnotations(annotations, annotationIds)); } }
/// <summary> /// Queries the Xml stream for annotations that have an anchor /// that contains a locator that begins with the locator parts /// in anchorLocator. /// </summary> /// <param name="anchorLocator">the locator we are looking for</param> /// <returns> /// A list of annotations that have locators in their anchors /// starting with the same locator parts list as of the input locator /// If no such annotations an empty list will be returned. The method /// never returns null. /// </returns> /// <exception cref="ObjectDisposedException">if object has been Disposed</exception> /// <exception cref="InvalidOperationException">the stream is null</exception> public override IList <Annotation> GetAnnotations(ContentLocator anchorLocator) { // First we generate the XPath expression if (anchorLocator == null) { throw new ArgumentNullException("anchorLocator"); } if (anchorLocator.Parts == null) { throw new ArgumentNullException("anchorLocator.Parts"); } //fire trace event EventTrace.EasyTraceEvent(EventTrace.Keyword.KeywordAnnotation, EventTrace.Event.GetAnnotationByLocBegin); IList <Annotation> annotations = null; try { string query = @"//" + AnnotationXmlConstants.Prefixes.CoreSchemaPrefix + ":" + AnnotationXmlConstants.Elements.ContentLocator; if (anchorLocator.Parts.Count > 0) { query += @"/child::*[1]/self::"; for (int i = 0; i < anchorLocator.Parts.Count; i++) { if (anchorLocator.Parts[i] != null) { if (i > 0) { query += @"/following-sibling::"; } string fragment = anchorLocator.Parts[i].GetQueryFragment(_namespaceManager); if (fragment != null) { query += fragment; } else { query += "*"; } } } } query += @"/ancestor::" + AnnotationXmlConstants.Prefixes.CoreSchemaPrefix + ":Anchors/ancestor::" + AnnotationXmlConstants.Prefixes.CoreSchemaPrefix + ":Annotation"; annotations = InternalGetAnnotations(query, anchorLocator); } finally { //fire trace event EventTrace.EasyTraceEvent(EventTrace.Keyword.KeywordAnnotation, EventTrace.Event.GetAnnotationByLocEnd); } return(annotations); }
// Token: 0x06007C04 RID: 31748 RVA: 0x0022DB84 File Offset: 0x0022BD84 public IList <IAttachedAnnotation> ProcessAnnotations(DependencyObject node) { base.VerifyAccess(); if (node == null) { throw new ArgumentNullException("node"); } IList <IAttachedAnnotation> list = new List <IAttachedAnnotation>(); IList <ContentLocatorBase> list2 = this.GenerateLocators(node); if (list2.Count > 0) { AnnotationStore annotationStore; if (this._internalStore != null) { annotationStore = this._internalStore; } else { AnnotationService service = AnnotationService.GetService(node); if (service == null || !service.IsEnabled) { throw new InvalidOperationException(SR.Get("AnnotationServiceNotEnabled")); } annotationStore = service.Store; } ContentLocator[] array = new ContentLocator[list2.Count]; list2.CopyTo(array, 0); IList <Annotation> annotations = annotationStore.GetAnnotations(array[0]); foreach (ContentLocatorBase contentLocatorBase in list2) { ContentLocator contentLocator = (ContentLocator)contentLocatorBase; if (contentLocator.Parts[contentLocator.Parts.Count - 1].NameValuePairs.ContainsKey("IncludeOverlaps")) { contentLocator.Parts.RemoveAt(contentLocator.Parts.Count - 1); } } foreach (Annotation annotation in annotations) { foreach (AnnotationResource annotationResource in annotation.Anchors) { foreach (ContentLocatorBase locator in annotationResource.ContentLocators) { AttachmentLevel attachmentLevel; object attachedAnchor = this.FindAttachedAnchor(node, array, locator, out attachmentLevel); if (attachmentLevel != AttachmentLevel.Unresolved) { list.Add(new AttachedAnnotation(this, annotation, annotationResource, attachedAnchor, attachmentLevel)); break; } } } } } return(list); }
// -------------------------- GoToMark_Click -------------------------- void GoToMark_Click(object sender, RoutedEventArgs e) { Annotation ann = null; if (sender is Button) { ann = ((Button)sender).Tag as Annotation; } else if (sender is MenuItem) { ann = ((MenuItem)sender).Tag as Annotation; } if (ann == null) { return; } ContentLocator cloc = ann.Anchors[0].ContentLocators[0] as ContentLocator; if (cloc == null) { return; } if (cloc.Parts.Count < 2) { return; } ContentLocatorPart cPart = cloc.Parts[1]; if (cPart == null) { return; } if (cPart.NameValuePairs["Segment0"] != null) { string[] charPos = cPart.NameValuePairs["Segment0"].Split(','); FlowDocument fd = FDPV.Document as FlowDocument; TextPointer tp = fd.ContentStart.GetPositionAtOffset( int.Parse(charPos[0]), LogicalDirection.Forward); if (tp == null) { return; } FrameworkContentElement fce = tp.Parent as FrameworkContentElement; if (fce == null) { return; } fce.BringIntoView(); } }
// Token: 0x06007BBD RID: 31677 RVA: 0x0022C1DC File Offset: 0x0022A3DC public Dictionary <Guid, Annotation> FindAnnotations(ContentLocator anchorLocator) { if (anchorLocator == null) { throw new ArgumentNullException("locator"); } Dictionary <Guid, Annotation> dictionary = new Dictionary <Guid, Annotation>(); foreach (StoreAnnotationsMap.CachedAnnotation cachedAnnotation in this._currentAnnotations.Values) { Annotation annotation = cachedAnnotation.Annotation; bool flag = false; foreach (AnnotationResource annotationResource in annotation.Anchors) { foreach (ContentLocatorBase contentLocatorBase in annotationResource.ContentLocators) { ContentLocator contentLocator = contentLocatorBase as ContentLocator; if (contentLocator != null) { if (contentLocator.StartsWith(anchorLocator)) { flag = true; } } else { ContentLocatorGroup contentLocatorGroup = contentLocatorBase as ContentLocatorGroup; if (contentLocatorGroup != null) { foreach (ContentLocator contentLocator2 in contentLocatorGroup.Locators) { if (contentLocator2.StartsWith(anchorLocator)) { flag = true; break; } } } } if (flag) { dictionary.Add(annotation.Id, annotation); break; } } if (flag) { break; } } } return(dictionary); }
/// <summary>Returns a list of annotations that have <see cref="P:System.Windows.Annotations.Annotation.Anchors" /> with locators that begin with a matching <see cref="T:System.Windows.Annotations.ContentLocatorPart" /> sequence.</summary> /// <param name="anchorLocator">The starting <see cref="T:System.Windows.Annotations.ContentLocatorPart" /> sequence to return matching annotations for.</param> /// <returns>The list of annotations that have <see cref="P:System.Windows.Annotations.Annotation.Anchors" /> with locators that start and match the given <paramref name="anchorLocator" />; otherwise, <see langword="null" /> if no matching annotations were found.</returns> // Token: 0x0600636F RID: 25455 RVA: 0x001BF5A4 File Offset: 0x001BD7A4 public override IList <Annotation> GetAnnotations(ContentLocator anchorLocator) { if (anchorLocator == null) { throw new ArgumentNullException("anchorLocator"); } if (anchorLocator.Parts == null) { throw new ArgumentNullException("anchorLocator.Parts"); } EventTrace.EasyTraceEvent(EventTrace.Keyword.KeywordAnnotation, EventTrace.Event.GetAnnotationByLocBegin); IList <Annotation> result = null; try { string text = "//anc:ContentLocator"; if (anchorLocator.Parts.Count > 0) { text += "/child::*[1]/self::"; for (int i = 0; i < anchorLocator.Parts.Count; i++) { if (anchorLocator.Parts[i] != null) { if (i > 0) { text += "/following-sibling::"; } string queryFragment = anchorLocator.Parts[i].GetQueryFragment(this._namespaceManager); if (queryFragment != null) { text += queryFragment; } else { text += "*"; } } } } text += "/ancestor::anc:Anchors/ancestor::anc:Annotation"; result = this.InternalGetAnnotations(text, anchorLocator); } finally { EventTrace.EasyTraceEvent(EventTrace.Keyword.KeywordAnnotation, EventTrace.Event.GetAnnotationByLocEnd); } return(result); }
// Token: 0x06007BF0 RID: 31728 RVA: 0x0022D58C File Offset: 0x0022B78C public override ContentLocator GenerateLocator(PathNode node, out bool continueGenerating) { if (node == null) { throw new ArgumentNullException("node"); } continueGenerating = true; ContentLocator contentLocator = null; ContentLocatorPart contentLocatorPart = this.CreateLocatorPart(node.Node); if (contentLocatorPart != null) { contentLocator = new ContentLocator(); contentLocator.Parts.Add(contentLocatorPart); } return(contentLocator); }
// Token: 0x06007C06 RID: 31750 RVA: 0x0022DE04 File Offset: 0x0022C004 public object ResolveLocator(ContentLocatorBase locator, int offset, DependencyObject startNode, out AttachmentLevel attachmentLevel) { base.VerifyAccess(); if (locator == null) { throw new ArgumentNullException("locator"); } if (startNode == null) { throw new ArgumentNullException("startNode"); } ContentLocator contentLocator = locator as ContentLocator; if (contentLocator != null && (offset < 0 || offset >= contentLocator.Parts.Count)) { throw new ArgumentOutOfRangeException("offset"); } return(this.InternalResolveLocator(locator, offset, startNode, false, out attachmentLevel)); }
// Token: 0x06007C0A RID: 31754 RVA: 0x0022DEF4 File Offset: 0x0022C0F4 internal object FindAttachedAnchor(DependencyObject startNode, ContentLocator[] prefixes, ContentLocatorBase locator, out AttachmentLevel attachmentLevel) { if (startNode == null) { throw new ArgumentNullException("startNode"); } if (locator == null) { throw new ArgumentNullException("locator"); } attachmentLevel = AttachmentLevel.Unresolved; object result = null; bool flag = true; int num = this.FindMatchingPrefix(prefixes, locator, out flag); if (flag) { ContentLocator contentLocator = locator as ContentLocator; if (contentLocator == null || num < contentLocator.Parts.Count) { result = this.InternalResolveLocator(locator, num, startNode, num != 0, out attachmentLevel); } if (attachmentLevel == AttachmentLevel.Unresolved && num > 0) { if (num == 0) { attachmentLevel = AttachmentLevel.Unresolved; } else if (contentLocator != null && num < contentLocator.Parts.Count) { attachmentLevel = AttachmentLevel.Incomplete; result = startNode; } else { attachmentLevel = AttachmentLevel.Full; result = startNode; } } } return(result); }
/// <summary> /// Generates locators identifying 'chunks'. If node is a chunk, /// generates a locator with a single locator part containing a /// fingerprint of the chunk. Otherwise null is returned. /// </summary> /// <param name="node">the node to generate a locator for</param> /// <param name="continueGenerating">return flag indicating whether the search /// should continue (presumably because the search was not exhaustive). /// This processor will always return true because it is possible to locate /// parts of the node (if it is FixedPage or FixedPageProxy)</param> /// <returns>if node is a FixedPage or FixedPageProxy, a ContentLocator /// with a single locator part containing the page number; null if node is not /// FixedPage or FixedPageProxy </returns> /// <exception cref="ArgumentNullException">node is null</exception> /// <exception cref="ArgumentException">node points to a Document Page View which /// doesn't contain a FixedDocumentPage</exception> public override ContentLocator GenerateLocator(PathNode node, out bool continueGenerating) { if (node == null) { throw new ArgumentNullException("node"); } // Initial value continueGenerating = true; ContentLocator locator = null; DocumentPageView dpv = node.Node as DocumentPageView; int pageNb = -1; if (dpv != null) { // Only produce locator parts for FixedDocumentPages if (dpv.DocumentPage is FixedDocumentPage || dpv.DocumentPage is FixedDocumentSequenceDocumentPage) { pageNb = dpv.PageNumber; } } else { FixedTextSelectionProcessor.FixedPageProxy fPage = node.Node as FixedTextSelectionProcessor.FixedPageProxy; if (fPage != null) { pageNb = fPage.Page; } } if (pageNb >= 0) { locator = new ContentLocator(); ContentLocatorPart locatorPart = CreateLocatorPart(pageNb); locator.Parts.Add(locatorPart); } return(locator); }
public QuickOrderBlockController( IQuickOrderService quickOrderService, ICartService cartService, IFileHelperService fileHelperService, IOrderRepository orderRepository, ReferenceConverter referenceConverter, ICommerceSearchService _searchService, ICustomerService customerService, IContentLoader contentLoader, ContentLocator contentLocator) { _quickOrderService = quickOrderService; _cartService = cartService; _fileHelperService = fileHelperService; _orderRepository = orderRepository; _referenceConverter = referenceConverter; __searchService = _searchService; _customerService = customerService; _contentLoader = contentLoader; _contentLocator = contentLocator; }
// Token: 0x06007C0B RID: 31755 RVA: 0x0022DF94 File Offset: 0x0022C194 private int FindMatchingPrefix(ContentLocator[] prefixes, ContentLocatorBase locator, out bool matched) { matched = true; int result = 0; ContentLocator contentLocator = locator as ContentLocator; if (contentLocator != null && prefixes != null && prefixes.Length != 0) { matched = false; foreach (ContentLocator contentLocator2 in prefixes) { if (contentLocator.StartsWith(contentLocator2)) { result = contentLocator2.Parts.Count; matched = true; break; } } } return(result); }
public BunnyHopGame() { config = new Config(); database = new InMemoryDatabase(); ConfigLocator.Provide(config); ContentLocator.Provide(Content); InMemoryDatabaseLocator.Provide(database); graphics = new GraphicsDeviceManager(this); graphics.PreferredBackBufferWidth = ConfigLocator.Config.VirtualWidth * ConfigLocator.Config.Scale; graphics.PreferredBackBufferHeight = ConfigLocator.Config.VirtualHeight * ConfigLocator.Config.Scale; graphics.PreferMultiSampling = false; graphics.ApplyChanges(); GraphicsLocator.Provide(graphics); var viewportAdapter = new BoxingViewportAdapter(Window, GraphicsDevice, ConfigLocator.Config.VirtualWidth, ConfigLocator.Config.VirtualHeight); camera = new Camera2D(viewportAdapter); CameraLocator.Provide(camera); soundEffects = new List <SoundEffect>(); SoundLocator.Provide(soundEffects); Content.RootDirectory = "Content"; stateStack = new Stack <State>(); stateStack.Push(new SplashState()); //https://docs.microsoft.com/pt-br/dotnet/api/system.globalization.cultureinfo.currentculture?view=netcore-3.1 //CultureInfo culture = new CultureInfo("ko-KR", false); // us-EN ko-KR ja-JP //Thread.CurrentThread.CurrentCulture = culture; //Thread.CurrentThread.CurrentUICulture = culture; //Resources.Culture = CultureInfo.CurrentCulture; //Debug.Print(CultureInfo.CurrentCulture.Name); //Debug.Print(CultureInfo.CurrentCulture.TwoLetterISOLanguageName); //Debug.Print(Resources.Culture.Name); }
// Token: 0x0600637F RID: 25471 RVA: 0x001BFC54 File Offset: 0x001BDE54 private IList <Annotation> InternalGetAnnotations(string query, ContentLocator anchorLocator) { Invariant.Assert(query != null, "Parameter 'query' is null."); object syncRoot = base.SyncRoot; IList <Annotation> result; lock (syncRoot) { this.CheckStatus(); List <Guid> storeAnnotationsId = this.FindAnnotationIds(query); Dictionary <Guid, Annotation> mapAnnotations; if (anchorLocator == null) { mapAnnotations = this._storeAnnotationsMap.FindAnnotations(); } else { mapAnnotations = this._storeAnnotationsMap.FindAnnotations(anchorLocator); } result = this.MergeAndCacheAnnotations(mapAnnotations, storeAnnotationsId); } return(result); }
public CarouselBlockController(ContentLocator contentLocator, IContentLoader contentLoader) { this.contentLocator = contentLocator; this.contentLoader = contentLoader; }
public ContentLocator RegisterUrl(HtmlHelper helper, DisplayOptions options) { var view = helper.ViewContext.View as RazorView; string viewPath = view.ViewPath.ToLower(); if (viewPath.Contains("/index.cshtml")) { viewPath = viewPath.Replace("/index.cshtml", string.Empty); } var pageUrl = viewPath.Split(new string[] { "/" }, StringSplitOptions.RemoveEmptyEntries).LastOrDefault(); var locator = _contentLocators.FirstOrDefault(l => l.PageUrl == pageUrl && (options.Url != null ? options.Url.ToLower() == l.ContentUrl : l.ContentUrl == null)); if (locator == null) { locator = new ContentLocator { ContentUrl = options.Url != null ? options.Url.ToLower() : null, PageUrl = pageUrl.ToLower() }; _contentLocators.Add(locator); } return locator; }
// ----------------------- AddBookmarkOrComment ----------------------- private void AddBookmarkOrComment(ListBox collection, Annotation ann) { if (ann.Cargos.Count <= 1) { ann.Cargos.Add( new AnnotationResource(FDPV.MasterPageNumber.ToString())); } Assembly a = System.Reflection.Assembly.GetExecutingAssembly(); string path = System.IO.Path.Combine( a.Location.Remove(a.Location.LastIndexOf('\\')), "GoButton.xaml"); StackPanel EntryInList = XamlReader.Load(File.OpenRead(path)) as StackPanel; EntryInList.Width = BookmarkList.Width - 10; Button GoToMark = LogicalTreeHelper.FindLogicalNode( EntryInList, "GoToMark") as Button; if (GoToMark != null) { GoToMark.Tag = ann; GoToMark.Click += new RoutedEventHandler(GoToMark_Click); } MenuItem GoToMenu = LogicalTreeHelper.FindLogicalNode( GoToMark.ContextMenu, "GoToMenu") as MenuItem; GoToMenu.Click += new RoutedEventHandler(GoToMark_Click); GoToMenu.Tag = ann; MenuItem DeleteMark = LogicalTreeHelper.FindLogicalNode( GoToMark.ContextMenu, "DeleteMark") as MenuItem; DeleteMark.Click += new RoutedEventHandler(DeleteMark_Click); DeleteMark.Tag = ann; System.Windows.Shapes.Path markPath = LogicalTreeHelper.FindLogicalNode(EntryInList, "MarkPath") as System.Windows.Shapes.Path; if ((collection == CommentsList) && (markPath != null)) { LinearGradientBrush lBrush = new LinearGradientBrush(); GradientStopCollection gColl = new GradientStopCollection(); GradientStop gStop = new GradientStop(Colors.LightGreen, 0); gColl.Add(gStop); lBrush.GradientStops = gColl; markPath.Fill = lBrush; } collection.Items.Add(EntryInList); TextBlock spText = LogicalTreeHelper.FindLogicalNode(EntryInList, "TB") as TextBlock; string MarkText = ""; if (spText != null) { ContentLocator cloc = ann.Anchors[0].ContentLocators[0] as ContentLocator; if (cloc == null) { return; } if (cloc.Parts.Count < 2) { return; } ContentLocatorPart cPart = cloc.Parts[1]; if (cPart == null) { return; } if (cPart.NameValuePairs["Segment0"] != null) { string[] charPos = cPart.NameValuePairs["Segment0"].Split(','); FlowDocument fd = FDPV.Document as FlowDocument; TextPointer tp = fd.ContentStart.GetPositionAtOffset( int.Parse(charPos[0]), LogicalDirection.Forward); if (tp == null) { return; } if (tp.GetPointerContext(LogicalDirection.Forward) == TextPointerContext.Text) { MarkText += tp.GetTextInRun(LogicalDirection.Forward); } spText.Text = MarkText.Substring(0, (MarkText.Length > 150) ? 150 : MarkText.Length); } } }// end:AddBookmarkOrComment()
public PageListBlockViewComponent(ContentLocator contentLocator, IContentLoader contentLoader) { this.contentLocator = contentLocator; this.contentLoader = contentLoader; }
/// <summary> /// Queries the store map for annotations that have an anchor /// that contains a locator that begins with the locator parts /// in anchorLocator. /// </summary> /// <param name="anchorLocator">the locator we are looking for</param> /// <returns> /// A list of annotations that have locators in their anchors /// starting with the same locator parts list as of the input locator /// If no such annotations an empty list will be returned. The method /// never returns null. /// </returns> public Dictionary <Guid, Annotation> FindAnnotations(ContentLocator anchorLocator) { if (anchorLocator == null) { throw new ArgumentNullException("locator"); } Dictionary <Guid, Annotation> annotations = new Dictionary <Guid, Annotation>(); // In the future, this probably has to be done in a way more effecient than linear search // the plan of record is to start with this and improve later // the map is already solving a perf bottleneck for tablet Dictionary <Guid, CachedAnnotation> .ValueCollection.Enumerator annotationsEnumerator = _currentAnnotations.Values.GetEnumerator(); while (annotationsEnumerator.MoveNext()) { Annotation annotation = annotationsEnumerator.Current.Annotation; bool matchesQuery = false; foreach (AnnotationResource resource in annotation.Anchors) { foreach (ContentLocatorBase locator in resource.ContentLocators) { ContentLocator ContentLocator = locator as ContentLocator; if (ContentLocator != null) { if (ContentLocator.StartsWith(anchorLocator)) { matchesQuery = true; } } else { ContentLocatorGroup ContentLocatorGroup = locator as ContentLocatorGroup; if (ContentLocatorGroup != null) { foreach (ContentLocator list in ContentLocatorGroup.Locators) { if (list.StartsWith(anchorLocator)) { matchesQuery = true; break; } } } } if (matchesQuery) { annotations.Add(annotation.Id, annotation); break; } } if (matchesQuery) { break; } } } return(annotations); }
public void Start() { string content = new ContentLocator("testContent").LocateContent(); StartServer(content); }
public BlogStartPageController(ContentLocator contentLocator, IContentLoader contentLoader) { this.contentLocator = contentLocator; this.contentLoader = contentLoader; }
public TagCloudBlockController(ContentLocator contentLocator, IContentLoader contentLoader) { this.contentLocator = contentLocator; this.contentLoader = contentLoader; }
public ContactPageSelectionFactory(ContentLocator contentLocator) { _contentLocator = contentLocator; }
public SidebarNavBlockController(ContentLocator contentLocator, IContentLoader contentLoader) { this.contentLocator = contentLocator; this.contentLoader = contentLoader; }
public void Start() { string content = new ContentLocator("TestContent/AspNetApp").LocateContent(); StartServer(content); }
/// <summary> /// Queries the AnnotationStore for annotations that have an anchor /// that contains a locator that begins with the locator parts /// in anchorLocator. /// </summary> /// <param name="anchorLocator">the locator we are looking for</param> /// <returns> /// A list of annotations that have locators in their anchors /// starting with the same locator parts list as of the input locator /// Can return an empty list, but never null. /// </returns> /// <exception cref="ObjectDisposedException">if object has been disposed</exception> public abstract IList <Annotation> GetAnnotations(ContentLocator anchorLocator);
public PageListBlockController(ContentLocator contentLocator, IContentLoader contentLoader, IRenderingContextResolver renderingContextResolver) { this.contentLocator = contentLocator; this.contentLoader = contentLoader; _renderingContextResolver = renderingContextResolver; }
public PageListBlockController(ContentLocator contentLocator, IContentLoader contentLoader) { this.contentLocator = contentLocator; this.contentLoader = contentLoader; }