Beispiel #1
0
        private void CollapseAll()
        {
            ITextSnapshot snapshot     = _textView.TextBuffer.CurrentSnapshot;
            SnapshotSpan  snapshotSpan = new SnapshotSpan(snapshot, 0, snapshot.Length);

            OutliningManager.CollapseAll(snapshotSpan, (collapsible => true));
        }
Beispiel #2
0
 public void OpenFold_AdhocPartialLine()
 {
     Create("cat dog", "fish tree");
     _adhocOutliner.CreateOutliningRegion(_textBuffer.GetLineSpan(0, 3, 4), "", "");
     _outliningeManager.CollapseAll(_textBuffer.GetLine(0).ExtentIncludingLineBreak, _ => true);
     Assert.Equal("cat", _visualBuffer.GetLine(0).GetText());
     _foldManager.OpenFold(_textView.GetPoint(0), 1);
     Assert.Equal("cat dog", _visualBuffer.GetLine(0).GetText());
 }
        private void OutliningManager_RegionsChanged(object sender, RegionsChangedEventArgs e)
        {
            const string xmlDocCollapsedFormStart = "/// <summary>";

            IOutliningManager outliningManager = sender as IOutliningManager;

            outliningManager.CollapseAll(e.AffectedSpan, c => c?.CollapsedForm?.ToString()?.StartsWith(xmlDocCollapsedFormStart) ?? false && !c.IsCollapsed && c.IsCollapsible);

            //Unsubscribe from RegionsChanged after initial change
            outliningManager.RegionsChanged -= OutliningManager_RegionsChanged;
        }
        private void OutliningManagerOnRegionsChanged(object sender, RegionsChangedEventArgs args)
        {
            outliningManager.RegionsChanged -= OutliningManagerOnRegionsChanged;

            var currentSnapshot = textView.TextBuffer.CurrentSnapshot;
            var span            = new SnapshotSpan(currentSnapshot, 0, currentSnapshot.Length);

            if (settings.BehaviorMode == BehaviorMode.ExpandAll || settings.BehaviorMode == BehaviorMode.PreventCollapse)
            {
                outliningManager.ExpandAll(span, c => c.IsCollapsed && IsRegion(c));
            }
            else if (settings.BehaviorMode == BehaviorMode.CollapseAll)
            {
                outliningManager.CollapseAll(span, c => !c.IsCollapsed && IsRegion(c));
            }
        }
        // Re-collapse the spans
        public void CollapseRegions()
        {
            if (_outliningManager == null || _textView == null || _collapsedSpans == null)
            {
                return;
            }

            ITextSnapshot snapshot = _textView.TextBuffer.CurrentSnapshot;

            // Get a span that includes all collapsed regions
            int min = Int32.MinValue;
            int max = Int32.MinValue;

            foreach (Tuple <Span, IOutliningRegionTag> span in _collapsedSpans)
            {
                if (min == Int32.MinValue || span.Item1.Start < min)
                {
                    min = span.Item1.Start;
                }

                if (max == Int32.MinValue || span.Item1.End > max)
                {
                    max = span.Item1.End;
                }
            }

            // avoid running if there were no spans
            if (min == Int32.MinValue)
            {
                Debug.Fail("No spans");
                return;
            }

            // span containing all collapsed regions
            SnapshotSpan entireSpan = new SnapshotSpan(snapshot, min, max - min);

            // regions have not yet been tagged by the language service during the undo/redo and
            // so we need to tag them again in order to do the collapse
            SimpleTagger <IOutliningRegionTag> simpleTagger =
                _textView.TextBuffer.Properties.GetOrCreateSingletonProperty <SimpleTagger <IOutliningRegionTag> >(() => new SimpleTagger <IOutliningRegionTag>(_textView.TextBuffer));

            Debug.Assert(!simpleTagger.GetTaggedSpans(entireSpan).GetEnumerator().MoveNext(),
                         "The code is not expecting the regions to be tagged already. Verify that redundant tagging is not occurring.");

            List <Span> toCollapse = new List <Span>();

            // tag the regions and add them to the list to be bulk collapsed
            foreach (Tuple <Span, IOutliningRegionTag> span in _collapsedSpans)
            {
                ITrackingSpan tspan = snapshot.CreateTrackingSpan(span.Item1, SpanTrackingMode.EdgeExclusive);
                simpleTagger.CreateTagSpan(tspan, span.Item2);

                toCollapse.Add(span.Item1);
            }

            // Disable the OutliningUndoManager to avoid it adding our collapse to the undo stack as an expand
            bool disableOutliningUndo = _textView.Options.IsOutliningUndoEnabled();

            try
            {
                if (disableOutliningUndo)
                {
                    _textView.Options.SetOptionValue(DefaultTextViewOptions.OutliningUndoOptionId, false);
                }

                // Do the collapse
                _outliningManager.CollapseAll(entireSpan, colSpan => (!colSpan.IsCollapsed && toCollapse.Contains(colSpan.Extent.GetSpan(snapshot))));
            }
            finally
            {
                if (disableOutliningUndo)
                {
                    _textView.Options.SetOptionValue(DefaultTextViewOptions.OutliningUndoOptionId, true);
                }
            }
        }