public TextBlock Create(ImmutableArray <TaggedText> taggedParts)
{
var context = TaggedTextClassifierContext.Create(taggedParts);
return(TextBlockFactory.Create(context.Text, classificationFormatMap.DefaultTextProperties,
classifier.GetTags(context).Select(a => new TextRunPropertiesAndSpan(a.Span, classificationFormatMap.GetTextProperties(a.ClassificationType))), TextBlockFactory.Flags.DisableSetTextBlockFontFamily));
}
public UIElement Create()
{
var text = sb.ToString();
var propsSpans = CreateTextRunPropertiesAndSpans();
return(TextBlockFactory.Create(text, classificationFormatMap.DefaultTextProperties, propsSpans, TextBlockFactory.Flags.DisableSetTextBlockFontFamily | TextBlockFactory.Flags.DisableFontSize));
}
object CreateSignatureObject() {
if (session.IsDismissed)
return null;
var signature = session.SelectedSignature;
if (signature == null)
return null;
bool prettyPrintedContent = false;
var text = signature.Content;
if (text == null) {
prettyPrintedContent = true;
text = signature.PrettyPrintedContent;
}
if (text == null)
return null;
signatureTextBuffer.Properties[SignatureHelpConstants.UsePrettyPrintedContentBufferKey] = prettyPrintedContent;
signatureTextBuffer.Replace(new Span(0, signatureTextBuffer.CurrentSnapshot.Length), text);
var oldContentType = signatureTextBuffer.ContentType;
var atSpan = signature.ApplicableToSpan;
Debug.Assert(atSpan != null);
if (atSpan != null) {
var span = atSpan.GetStartPoint(atSpan.TextBuffer.CurrentSnapshot);
signatureTextBuffer.ChangeContentType(GetSigHelpContentType(span.Snapshot.ContentType), null);
}
if (signatureClassifier == null || oldContentType != signatureTextBuffer.ContentType) {
UnregisterSignatureClassifierEvents();
signatureClassifier = classifierAggregatorService.GetClassifier(signatureTextBuffer);
RegisterSignatureClassifierEvents();
}
var classificationSpans = signatureClassifier.GetClassificationSpans(new SnapshotSpan(signatureTextBuffer.CurrentSnapshot, 0, signatureTextBuffer.CurrentSnapshot.Length));
var propsSpans = classificationSpans.Select(a => new TextRunPropertiesAndSpan(a.Span.Span, classificationFormatMap.GetTextProperties(a.ClassificationType)));
return TextBlockFactory.Create(text, classificationFormatMap.DefaultTextProperties, propsSpans, TextBlockFactory.Flags.DisableSetTextBlockFontFamily | TextBlockFactory.Flags.DisableFontSize);
}
TextBlock TryCreateObject(StringBuilder sb, ImmutableArray <TaggedText> taggedParts, IClassificationFormatMap classificationFormatMap, IThemeClassificationTypeService themeClassificationTypeService)
{
if (taggedParts.IsDefaultOrEmpty)
{
return(null);
}
var text = ToString(sb, taggedParts);
var propsSpans = CreateTextRunPropertiesAndSpans(taggedParts, classificationFormatMap, themeClassificationTypeService);
return(TextBlockFactory.Create(text, classificationFormatMap.DefaultTextProperties, propsSpans, TextBlockFactory.Flags.DisableSetTextBlockFontFamily | TextBlockFactory.Flags.DisableFontSize));
}
object CreateSignatureCountObject() {
if (session.IsDismissed)
return null;
int sigIndex = session.Signatures.IndexOf(currentSignature);
// Can happen if the session removes a sig
if (sigIndex < 0)
return null;
var text = string.Format(dnSpy_Resources.SignatureHelp_Signature_N_of_TotalCount, sigIndex + 1, session.Signatures.Count);
var propsSpans = Array.Empty<TextRunPropertiesAndSpan>();
return TextBlockFactory.Create(text, classificationFormatMap.DefaultTextProperties, propsSpans, TextBlockFactory.Flags.DisableSetTextBlockFontFamily | TextBlockFactory.Flags.DisableFontSize);
}
object CreateUIObject(string text, IContentType contentType, SignatureHelpClassifierContext context) {
otherTextBuffer.Properties[SignatureHelpConstants.SignatureHelpClassifierContextBufferKey] = context;
otherTextBuffer.Replace(new Span(0, otherTextBuffer.CurrentSnapshot.Length), text);
var oldContentType = otherTextBuffer.ContentType;
otherTextBuffer.ChangeContentType(contentType, null);
if (otherClassifier == null || oldContentType != contentType) {
(otherClassifier as IDisposable)?.Dispose();
otherClassifier = classifierAggregatorService.GetClassifier(otherTextBuffer);
}
var classificationSpans = otherClassifier.GetClassificationSpans(new SnapshotSpan(otherTextBuffer.CurrentSnapshot, 0, otherTextBuffer.CurrentSnapshot.Length));
var propsSpans = classificationSpans.Select(a => new TextRunPropertiesAndSpan(a.Span.Span, classificationFormatMap.GetTextProperties(a.ClassificationType)));
var result = TextBlockFactory.Create(text, classificationFormatMap.DefaultTextProperties, propsSpans, TextBlockFactory.Flags.DisableSetTextBlockFontFamily | TextBlockFactory.Flags.DisableFontSize);
otherTextBuffer.Properties.RemoveProperty(SignatureHelpConstants.SignatureHelpClassifierContextBufferKey);
return result;
}
public FrameworkElement Create(CompletionSet completionSet, Completion completion, CompletionClassifierKind kind)
{
if (completionSet == null)
{
throw new ArgumentNullException(nameof(completionSet));
}
if (completion == null)
{
throw new ArgumentNullException(nameof(completion));
}
Debug.Assert(completionSet.Completions.Contains(completion));
CompletionClassifierContext context;
string defaultContentType;
switch (kind)
{
case CompletionClassifierKind.DisplayText:
var inputText = completionSet.ApplicableTo.GetText(completionSet.ApplicableTo.TextBuffer.CurrentSnapshot);
context = new CompletionDisplayTextClassifierContext(completionSet, completion, completion.DisplayText, inputText);
defaultContentType = ContentTypes.CompletionDisplayText;
break;
case CompletionClassifierKind.Suffix:
var suffix = (completion as Completion4)?.Suffix ?? string.Empty;
context = new CompletionSuffixClassifierContext(completionSet, completion, suffix);
defaultContentType = ContentTypes.CompletionSuffix;
break;
default:
throw new ArgumentOutOfRangeException(nameof(kind));
}
var contentType = (completionSet as ICompletionSetContentTypeProvider)?.GetContentType(contentTypeRegistryService, kind);
if (contentType == null)
{
contentType = contentTypeRegistryService.GetContentType(defaultContentType);
}
var classifier = GetTextClassifier(contentType);
return(TextBlockFactory.Create(context.Text, classificationFormatMap.DefaultTextProperties,
classifier.GetTags(context).Select(a => new TextRunPropertiesAndSpan(a.Span, classificationFormatMap.GetTextProperties(a.ClassificationType))), TextBlockFactory.Flags.DisableSetTextBlockFontFamily | TextBlockFactory.Flags.DisableFontSize));
}
public FrameworkElement Create(CompletionCollection collection, Completion completion)
{
if (collection == null)
{
throw new ArgumentNullException(nameof(collection));
}
if (completion == null)
{
throw new ArgumentNullException(nameof(completion));
}
Debug.Assert(collection.FilteredCollection.Contains(completion));
var classifier = GetCompletionClassifier(collection);
var inputText = collection.ApplicableTo.GetText(collection.ApplicableTo.TextBuffer.CurrentSnapshot);
var context = new CompletionClassifierContext(collection, completion, completion.DisplayText, inputText);
return(TextBlockFactory.Create(context.DisplayText, classificationFormatMap.DefaultTextProperties,
classifier.GetTags(context).Select(a => new TextRunPropertiesAndSpan(a.Span, classificationFormatMap.GetTextProperties(a.ClassificationType))), TextBlockFactory.Flags.DisableSetTextBlockFontFamily | TextBlockFactory.Flags.DisableFontSize));
}
public static FrameworkElement Create(IClassificationFormatMap classificationFormatMap, string text, IList <TextClassificationTag> tags, TextElementFlags flags)
{
bool useFastTextBlock = (flags & (TextElementFlags.TrimmingMask | TextElementFlags.WrapMask | TextElementFlags.FilterOutNewLines)) == (TextElementFlags.NoTrimming | TextElementFlags.NoWrap | TextElementFlags.FilterOutNewLines);
bool filterOutNewLines = (flags & TextElementFlags.FilterOutNewLines) != 0;
if (tags.Count != 0)
{
if (useFastTextBlock)
{
return(new FastTextBlock((flags & TextElementFlags.NewFormatter) != 0, new TextSrc {
text = ToString(WpfUnicodeUtils.ReplaceBadChars(text), filterOutNewLines),
classificationFormatMap = classificationFormatMap,
tagsList = tags.ToArray(),
}));
}
var propsSpans = tags.Select(a => new TextRunPropertiesAndSpan(a.Span, classificationFormatMap.GetTextProperties(a.ClassificationType)));
var textBlock = TextBlockFactory.Create(text, classificationFormatMap.DefaultTextProperties, propsSpans, TextBlockFactory.Flags.DisableSetTextBlockFontFamily | TextBlockFactory.Flags.DisableFontSize | (filterOutNewLines ? TextBlockFactory.Flags.FilterOutNewlines : 0));
textBlock.TextTrimming = GetTextTrimming(flags);
textBlock.TextWrapping = GetTextWrapping(flags);
return(textBlock);
}
FrameworkElement fwElem;
if (useFastTextBlock)
{
fwElem = new FastTextBlock((flags & TextElementFlags.NewFormatter) != 0)
{
Text = ToString(WpfUnicodeUtils.ReplaceBadChars(text), filterOutNewLines)
};
}
else
{
fwElem = new TextBlock {
Text = ToString(WpfUnicodeUtils.ReplaceBadChars(text), filterOutNewLines),
TextTrimming = GetTextTrimming(flags),
TextWrapping = GetTextWrapping(flags),
};
}
return(InitializeDefault(classificationFormatMap, fwElem));
}
public static FrameworkElement Create(IClassificationFormatMap classificationFormatMap, string text, List <TextClassificationTag> tagsList, bool useNewFormatter, bool useEllipsis = false, bool filterOutNewLines = true, TextWrapping textWrapping = TextWrapping.NoWrap)
{
if (tagsList.Count != 0)
{
if (!useEllipsis && filterOutNewLines)
{
return(new FastTextBlock(useNewFormatter, new TextSrc {
text = ToString(text, filterOutNewLines),
classificationFormatMap = classificationFormatMap,
tagsList = tagsList.ToArray(),
}));
}
var propsSpans = tagsList.Select(a => new TextRunPropertiesAndSpan(a.Span, classificationFormatMap.GetTextProperties(a.ClassificationType)));
return(TextBlockFactory.Create(text, classificationFormatMap.DefaultTextProperties, propsSpans, TextBlockFactory.Flags.DisableSetTextBlockFontFamily | TextBlockFactory.Flags.DisableFontSize));
}
FrameworkElement fwElem;
if (!useEllipsis && filterOutNewLines)
{
fwElem = new FastTextBlock(useNewFormatter)
{
Text = ToString(text, filterOutNewLines)
};
}
else
{
fwElem = new TextBlock {
Text = ToString(text, filterOutNewLines),
TextTrimming = TextTrimming.CharacterEllipsis,
TextWrapping = textWrapping,
};
}
return(InitializeDefault(classificationFormatMap, fwElem));
}
