private void OnRegionsCollapsed(object sender, RegionsCollapsedEventArgs args)
{
foreach (var collapsedRegion in args.CollapsedRegions.Where(IsRegion))
{
outliningManager.Expand(collapsedRegion);
}
}
private async Task ExpandAllRegionsContainingSpanAsync(SnapshotSpan selectedSpan, IWpfTextView textView)
{
IOutliningManager outliningManager = await ServiceProvider.GetOutliningManagerAsync(textView);
if (outliningManager == null)
{
return;
}
outliningManager.GetCollapsedRegions(selectedSpan, exposedRegionsOnly: false)
.ForEach(region => outliningManager.Expand(region));
}
private void OnRegionCollapsed(object sender, RegionsCollapsedEventArgs e)
{
foreach (var region in e.CollapsedRegions.Where(x => x.IsCollapsed))
{
var regionSnapshot = region.Extent.TextBuffer.CurrentSnapshot;
var regionText = region.Extent.GetText(regionSnapshot);
if (regionText.StartsWith("#region", StringComparison.InvariantCultureIgnoreCase))
{
_outliningManager.Expand(region);
}
}
}
private void OnRegionsCollapsed(object sender, RegionsCollapsedEventArgs e)
{
foreach (var collapsed in e.CollapsedRegions)
{
try
{
_outliningManager.Expand(collapsed);
}
catch (InvalidOperationException) { }
}
//_outliningManager.RegionsCollapsed -= OnRegionsCollapsed;
}
//=====================================================================
/// <summary>
/// Update the state of the controls based on the current issue
/// </summary>
private void UpdateState()
{
if (!updatingState)
{
updatingState = true;
try
{
if (currentTextView != null)
{
var currentIssue = currentTagger.CurrentMisspellings.FirstOrDefault();
ucSpellCheck.UpdateState(false, currentTagger.Dictionary.DictionaryCount > 1, currentIssue);
if (parentFocused && currentIssue != null)
{
var span = currentIssue.Span.GetSpan(currentIssue.Span.TextBuffer.CurrentSnapshot);
// If in a collapsed region, expand the region
if (outliningManager != null)
{
foreach (var region in outliningManager.GetCollapsedRegions(span, false))
{
if (region.IsCollapsed)
{
outliningManager.Expand(region);
}
}
}
currentTextView.Caret.MoveTo(span.Start);
currentTextView.ViewScroller.EnsureSpanVisible(span, EnsureSpanVisibleOptions.AlwaysCenter);
currentTextView.Selection.Select(span, false);
}
}
else
{
ucSpellCheck.UpdateState(true, false, null);
}
}
finally
{
updatingState = false;
}
}
}
/// <summary>
/// An event handler raised when a code item parent's expanded state has changed.
/// </summary>
/// <param name="sender">The sender of the event.</param>
/// <param name="eventArgs">The event arguments.</param>
private void OnCodeItemParentIsExpandedChanged(object sender, EventArgs eventArgs)
{
if (sender is ICodeItemParent codeItemParent)
{
var iCollapsible = FindCollapsibleFromCodeItemParent(codeItemParent);
if (iCollapsible != null)
{
if (codeItemParent.IsExpanded && iCollapsible.IsCollapsed)
{
_outliningManager.Expand(iCollapsible as ICollapsed);
}
else if (!codeItemParent.IsExpanded && !iCollapsible.IsCollapsed)
{
_outliningManager.TryCollapse(iCollapsible);
}
}
}
}
public void MoveTo(SnapshotSpan span)
{
if (_outliningManager != null)
{
foreach (var region in _outliningManager.GetCollapsedRegions(span, false))
{
_outliningManager.Expand(region);
}
}
if (span.Snapshot != _view.TextSnapshot)
{
span = span.TranslateTo(_view.TextSnapshot, SpanTrackingMode.EdgeExclusive);
}
_view.Caret.MoveTo(span.Start);
_view.Selection.Select(span, false);
_view.ViewScroller.EnsureSpanVisible(span);
}
/// <summary>
/// An event handler raised when a code item parent's expanded state has changed.
/// </summary>
/// <param name="sender">The sender of the event.</param>
/// <param name="eventArgs">The event arguments.</param>
private static void OnIsExpandedChanged(object sender, EventArgs eventArgs)
{
var item = sender as IMembers;
if (item != null)
{
var iCollapsible = FindCollapsibleFromCodeItem((CodeItem)item, _manager, _textView);
if (iCollapsible != null)
{
if (item.IsExpanded && iCollapsible.IsCollapsed)
{
_manager.Expand(iCollapsible as ICollapsed);
}
else if (!item.IsExpanded && !iCollapsible.IsCollapsed)
{
_manager.TryCollapse(iCollapsible);
}
}
}
}
private void ToggleCurrent()
{
var caretPosition = _textView.Caret.Position.BufferPosition;
var snapshot = _textView.TextBuffer.CurrentSnapshot;
var span = new SnapshotSpan(snapshot, new Span(caretPosition, 0));
var regions = OutliningManager.GetAllRegions(span);
// Find innermost one
ICollapsible region = null;
int regionStart = 0;
int regionEnd = snapshot.Length;
foreach (ICollapsible c in regions)
{
int start = c.Extent.GetStartPoint(snapshot);
int end = c.Extent.GetEndPoint(snapshot);
if (start >= regionStart && end < regionEnd)
{
regionStart = start;
regionEnd = end;
region = c;
}
}
if (region != null)
{
if (region.IsCollapsed)
{
OutliningManager.Expand(region as ICollapsed);
}
else
{
OutliningManager.TryCollapse(region);
}
}
}
//=====================================================================
/// <summary>
/// Update the state of the controls based on the current issue
/// </summary>
private void UpdateState()
{
if (updatingState)
{
return;
}
try
{
updatingState = lbSuggestions.IsEnabled = true;
btnReplace.IsEnabled = btnReplaceAll.IsEnabled = btnIgnoreOnce.IsEnabled = btnIgnoreAll.IsEnabled =
btnAddWord.IsEnabled = btnUndo.IsEnabled = txtMisspelledWord.IsEnabled = false;
lblIssue.Content = "_Misspelled Word";
txtMisspelledWord.Text = null;
lbSuggestions.Items.Clear();
if (currentTextView == null)
{
lblDisabled.Visibility = Visibility.Visible;
return;
}
lblDisabled.Visibility = Visibility.Collapsed;
if (currentTextView == null)
{
return;
}
if (misspellings.Count == 0)
{
txtMisspelledWord.Text = "(No more issues)";
return;
}
var issue = misspellings[0];
if (issue.MisspellingType == MisspellingType.DoubledWord)
{
lblIssue.Content = "_Doubled Word";
btnReplace.IsEnabled = btnIgnoreOnce.IsEnabled = true;
lbSuggestions.Items.Add("(Delete word)");
}
else
{
txtMisspelledWord.IsEnabled = btnIgnoreOnce.IsEnabled = btnIgnoreAll.IsEnabled = true;
switch (issue.MisspellingType)
{
case MisspellingType.CompoundTerm:
lblIssue.Content = "Co_mpound Term";
break;
case MisspellingType.DeprecatedTerm:
lblIssue.Content = "_Deprecated Term";
break;
case MisspellingType.UnrecognizedWord:
lblIssue.Content = "Un_recognized Word";
break;
default:
break;
}
if (issue.Suggestions.Any())
{
btnReplace.IsEnabled = btnReplaceAll.IsEnabled = true;
btnAddWord.IsEnabled = (issue.MisspellingType == MisspellingType.MisspelledWord);
foreach (var s in issue.Suggestions)
{
lbSuggestions.Items.Add(s);
}
lbSuggestions.SelectedIndex = issue.Suggestions.First().IsGroupHeader ? 1 : 0;
}
else
{
lbSuggestions.Items.Add("(No suggestions)");
}
}
txtMisspelledWord.Text = issue.Word;
if (parentFocused)
{
var span = issue.Span.GetSpan(issue.Span.TextBuffer.CurrentSnapshot);
// If in a collapsed region, expand the region
if (outliningManager != null)
{
foreach (var region in outliningManager.GetCollapsedRegions(span, false))
{
if (region.IsCollapsed)
{
outliningManager.Expand(region);
}
}
}
currentTextView.Caret.MoveTo(span.Start);
currentTextView.ViewScroller.EnsureSpanVisible(span, EnsureSpanVisibleOptions.AlwaysCenter);
currentTextView.Selection.Select(span, false);
}
}
finally
{
updatingState = false;
}
}
