diff --git a/Classifier/ClassificationFormats.cs b/Classifier/ClassificationFormats.cs index c3152f9..72e0bd5 100644 --- a/Classifier/ClassificationFormats.cs +++ b/Classifier/ClassificationFormats.cs @@ -1,7 +1,7 @@ using System.ComponentModel.Composition; +using System.Windows.Media; using Microsoft.VisualStudio.Text.Classification; using Microsoft.VisualStudio.Utilities; -using System.Windows.Media; namespace MarkdownMode { @@ -10,154 +10,219 @@ static class ClassificationFormats // Bold/italics [Export(typeof(EditorFormatDefinition))] - [ClassificationType(ClassificationTypeNames = "markdown.italics")] - [Name("markdown.italics")] + [ClassificationType(ClassificationTypeNames = ClassificationTypeNames.Italics)] + [Name(ClassificationTypeNames.Italics)] + [UserVisible(true)] sealed class MarkdownItalicsFormat : ClassificationFormatDefinition { - public MarkdownItalicsFormat() { this.IsItalic = true; } + public MarkdownItalicsFormat() + { + this.DisplayName = Resources.FormatItalics; + this.IsItalic = true; + } } [Export(typeof(EditorFormatDefinition))] - [ClassificationType(ClassificationTypeNames = "markdown.bold")] - [Name("markdown.bold")] + [ClassificationType(ClassificationTypeNames = ClassificationTypeNames.Bold)] + [Name(ClassificationTypeNames.Bold)] + [UserVisible(true)] sealed class MarkdownBoldFormat : ClassificationFormatDefinition { - public MarkdownBoldFormat() { this.IsBold = true; } + public MarkdownBoldFormat() + { + this.DisplayName = Resources.FormatBold; + this.IsBold = true; + } } // Headers [Export(typeof(EditorFormatDefinition))] - [ClassificationType(ClassificationTypeNames = "markdown.header")] - [Name("markdown.header")] - [DisplayName("Markdown header")] + [ClassificationType(ClassificationTypeNames = ClassificationTypeNames.Header)] + [Name(ClassificationTypeNames.Header)] [UserVisible(true)] sealed class MarkdownHeaderFormat : ClassificationFormatDefinition { - public MarkdownHeaderFormat() { this.ForegroundColor = Colors.MediumPurple; } + public MarkdownHeaderFormat() + { + this.DisplayName = Resources.FormatHeader; + this.ForegroundColor = Colors.MediumPurple; + } } [Export(typeof(EditorFormatDefinition))] - [ClassificationType(ClassificationTypeNames = "markdown.header.h1")] - [Name("markdown.header.h1")] + [ClassificationType(ClassificationTypeNames = ClassificationTypeNames.HeaderH1)] + [Name(ClassificationTypeNames.HeaderH1)] + [UserVisible(true)] sealed class MarkdownH1Format : ClassificationFormatDefinition { - public MarkdownH1Format() { this.FontRenderingSize = 22; } + public MarkdownH1Format() + { + this.DisplayName = Resources.FormatHeaderH1; + this.ForegroundColor = Colors.MediumPurple; + this.FontRenderingSize = 22; + } } [Export(typeof(EditorFormatDefinition))] - [ClassificationType(ClassificationTypeNames = "markdown.header.h2")] - [Name("markdown.header.h2")] + [ClassificationType(ClassificationTypeNames = ClassificationTypeNames.HeaderH2)] + [Name(ClassificationTypeNames.HeaderH2)] + [UserVisible(true)] sealed class MarkdownH2Format : ClassificationFormatDefinition { - public MarkdownH2Format() { this.FontRenderingSize = 20; } + public MarkdownH2Format() + { + this.DisplayName = Resources.FormatHeaderH2; + this.ForegroundColor = Colors.MediumPurple; + this.FontRenderingSize = 20; + } } [Export(typeof(EditorFormatDefinition))] - [ClassificationType(ClassificationTypeNames = "markdown.header.h3")] - [Name("markdown.header.h3")] + [ClassificationType(ClassificationTypeNames = ClassificationTypeNames.HeaderH3)] + [Name(ClassificationTypeNames.HeaderH3)] + [UserVisible(true)] sealed class MarkdownH3Format : ClassificationFormatDefinition { - public MarkdownH3Format() { this.FontRenderingSize = 18; } + public MarkdownH3Format() + { + this.DisplayName = Resources.FormatHeaderH3; + this.ForegroundColor = Colors.MediumPurple; + this.FontRenderingSize = 18; + } } [Export(typeof(EditorFormatDefinition))] - [ClassificationType(ClassificationTypeNames = "markdown.header.h4")] - [Name("markdown.header.h4")] + [ClassificationType(ClassificationTypeNames = ClassificationTypeNames.HeaderH4)] + [Name(ClassificationTypeNames.HeaderH4)] + [UserVisible(true)] sealed class MarkdownH4Format : ClassificationFormatDefinition { - public MarkdownH4Format() { this.FontRenderingSize = 16; } + public MarkdownH4Format() + { + this.DisplayName = Resources.FormatHeaderH4; + this.ForegroundColor = Colors.MediumPurple; + this.FontRenderingSize = 16; + } } [Export(typeof(EditorFormatDefinition))] - [ClassificationType(ClassificationTypeNames = "markdown.header.h5")] - [Name("markdown.header.h5")] + [ClassificationType(ClassificationTypeNames = ClassificationTypeNames.HeaderH5)] + [Name(ClassificationTypeNames.HeaderH5)] + [UserVisible(true)] sealed class MarkdownH5Format : ClassificationFormatDefinition { - public MarkdownH5Format() { this.FontRenderingSize = 14; } + public MarkdownH5Format() + { + this.DisplayName = Resources.FormatHeaderH5; + this.ForegroundColor = Colors.MediumPurple; + this.FontRenderingSize = 14; + } } [Export(typeof(EditorFormatDefinition))] - [ClassificationType(ClassificationTypeNames = "markdown.header.h6")] - [Name("markdown.header.h6")] + [ClassificationType(ClassificationTypeNames = ClassificationTypeNames.HeaderH6)] + [Name(ClassificationTypeNames.HeaderH6)] + [UserVisible(true)] sealed class MarkdownH6Format : ClassificationFormatDefinition { - public MarkdownH6Format() { this.FontRenderingSize = 12; } + public MarkdownH6Format() + { + this.DisplayName = Resources.FormatHeaderH6; + this.ForegroundColor = Colors.MediumPurple; + this.FontRenderingSize = 12; + } } // Lists [Export(typeof(EditorFormatDefinition))] - [ClassificationType(ClassificationTypeNames = "markdown.list")] - [Name("markdown.list")] + [ClassificationType(ClassificationTypeNames = ClassificationTypeNames.List)] + [Name(ClassificationTypeNames.List)] + [UserVisible(true)] sealed class MarkdownListFormat : ClassificationFormatDefinition { - public MarkdownListFormat() { this.IsBold = true; this.ForegroundColor = Colors.Teal; } + public MarkdownListFormat() + { + this.DisplayName = Resources.FormatList; + this.IsBold = true; + this.ForegroundColor = Colors.Teal; + } } // Code/pre [Export(typeof(EditorFormatDefinition))] - [ClassificationType(ClassificationTypeNames = "markdown.block")] - [Name("markdown.block")] - [DisplayName("Markdown code block")] + [ClassificationType(ClassificationTypeNames = ClassificationTypeNames.Block)] + [Name(ClassificationTypeNames.Block)] [UserVisible(true)] - [Order(Before = Priority.Default, After = "markdown.blockquote")] // Low priority + [Order(Before = Priority.Default, After = ClassificationTypeNames.BlockQuote)] // Low priority sealed class MarkdownCodeFormat : ClassificationFormatDefinition { - public MarkdownCodeFormat() - { + public MarkdownCodeFormat() + { + this.DisplayName = Resources.FormatBlock; this.ForegroundColor = Colors.LimeGreen; - this.FontTypeface = new Typeface("Courier New"); + this.FontTypeface = new Typeface("Courier New"); } } [Export(typeof(EditorFormatDefinition))] - [ClassificationType(ClassificationTypeNames = "markdown.pre")] - [Name("markdown.pre")] - [Order(Before = Priority.Default, After = "markdown.blockquote")] // Low priority + [ClassificationType(ClassificationTypeNames = ClassificationTypeNames.Preformatted)] + [Name(ClassificationTypeNames.Preformatted)] + [UserVisible(true)] + [Order(Before = Priority.Default, After = ClassificationTypeNames.BlockQuote)] // Low priority sealed class MarkdownPreFormat : ClassificationFormatDefinition { - public MarkdownPreFormat() { this.FontTypeface = new Typeface("Courier New"); } + public MarkdownPreFormat() + { + this.DisplayName = Resources.FormatPre; + this.FontTypeface = new Typeface("Courier New"); + } } // Quotes [Export(typeof(EditorFormatDefinition))] - [ClassificationType(ClassificationTypeNames = "markdown.blockquote")] - [Name("markdown.blockquote")] - [DisplayName("Markdown blockquote")] + [ClassificationType(ClassificationTypeNames = ClassificationTypeNames.BlockQuote)] + [Name(ClassificationTypeNames.BlockQuote)] [UserVisible(true)] [Order(Before = Priority.Default)] // Low priority sealed class MarkdownBlockquoteFormat : ClassificationFormatDefinition { - public MarkdownBlockquoteFormat() { this.ForegroundColor = Colors.IndianRed; } + public MarkdownBlockquoteFormat() + { + this.DisplayName = Resources.FormatBlockQuote; + this.ForegroundColor = Colors.IndianRed; + } } // Links [Export(typeof(EditorFormatDefinition))] - [ClassificationType(ClassificationTypeNames = "markdown.link")] - [Name("markdown.link")] - [Order(Before = Priority.Default, After = "markdown.blockquote")] // Low priority + [ClassificationType(ClassificationTypeNames = ClassificationTypeNames.Link)] + [Name(ClassificationTypeNames.Link)] + [Order(Before = Priority.Default, After = ClassificationTypeNames.BlockQuote)] // Low priority + [UserVisible(true)] sealed class MarkdownLink : ClassificationFormatDefinition { public MarkdownLink() { + this.DisplayName = Resources.FormatLink; this.ForegroundColor = Colors.Crimson; this.IsBold = true; } } [Export(typeof(EditorFormatDefinition))] - [ClassificationType(ClassificationTypeNames = "markdown.link.text")] - [Name("markdown.link.text")] - [DisplayName("Markdown link text")] + [ClassificationType(ClassificationTypeNames = ClassificationTypeNames.LinkText)] + [Name(ClassificationTypeNames.LinkText)] [UserVisible(true)] sealed class MarkdownLinkText : ClassificationFormatDefinition { - public MarkdownLinkText() + public MarkdownLinkText() { + this.DisplayName = Resources.FormatLinkText; this.IsBold = false; this.ForegroundColor = Colors.DeepPink; this.TextDecorations = System.Windows.TextDecorations.Underline; @@ -165,42 +230,44 @@ public MarkdownLinkText() } [Export(typeof(EditorFormatDefinition))] - [ClassificationType(ClassificationTypeNames = "markdown.link.title")] - [Name("markdown.link.title")] - [DisplayName("Markdown link title")] + [ClassificationType(ClassificationTypeNames = ClassificationTypeNames.LinkTitle)] + [Name(ClassificationTypeNames.LinkTitle)] [UserVisible(true)] sealed class MarkdownLinkTitle : ClassificationFormatDefinition { public MarkdownLinkTitle() { + this.DisplayName = Resources.FormatLinkTitle; this.IsBold = true; this.ForegroundColor = Colors.CadetBlue; } } [Export(typeof(EditorFormatDefinition))] - [ClassificationType(ClassificationTypeNames = "markdown.link.label")] - [Name("markdown.link.label")] - [DisplayName("Markdown link label")] + [ClassificationType(ClassificationTypeNames = ClassificationTypeNames.LinkLabel)] + [Name(ClassificationTypeNames.LinkLabel)] [UserVisible(true)] - [Order(After = "markdown.link")] + [Order(After = ClassificationTypeNames.Link)] sealed class MarkdownLinkLabel : ClassificationFormatDefinition { public MarkdownLinkLabel() { + this.DisplayName = Resources.FormatLinkLabel; this.ForegroundColor = Colors.DeepSkyBlue; this.IsBold = false; } } [Export(typeof(EditorFormatDefinition))] - [ClassificationType(ClassificationTypeNames = "markdown.url.inline")] - [Name("markdown.url.inline")] - [Order(After = "markdown.link")] + [ClassificationType(ClassificationTypeNames = ClassificationTypeNames.UrlInline)] + [Name(ClassificationTypeNames.UrlInline)] + [UserVisible(true)] + [Order(After = ClassificationTypeNames.Link)] sealed class MarkdownUrl : ClassificationFormatDefinition { public MarkdownUrl() { + this.DisplayName = Resources.FormatUrl; this.ForegroundColor = Colors.Blue; this.IsBold = false; } @@ -209,27 +276,29 @@ public MarkdownUrl() // Images [Export(typeof(EditorFormatDefinition))] - [ClassificationType(ClassificationTypeNames = "markdown.image")] - [Name("markdown.image")] - [Order(Before = Priority.Default, After = "markdown.blockquote")] // Low priority + [ClassificationType(ClassificationTypeNames = ClassificationTypeNames.Image)] + [Name(ClassificationTypeNames.Image)] + [UserVisible(true)] + [Order(Before = Priority.Default, After = ClassificationTypeNames.BlockQuote)] // Low priority sealed class MarkdownImage : ClassificationFormatDefinition { public MarkdownImage() { + this.DisplayName = Resources.FormatImage; this.ForegroundColor = Colors.Crimson; this.IsBold = true; } } [Export(typeof(EditorFormatDefinition))] - [ClassificationType(ClassificationTypeNames = "markdown.image.alt")] - [Name("markdown.image.alt")] - [DisplayName("Markdown image alt text")] + [ClassificationType(ClassificationTypeNames = ClassificationTypeNames.ImageAlt)] + [Name(ClassificationTypeNames.ImageAlt)] [UserVisible(true)] sealed class MarkdownImageAlt : ClassificationFormatDefinition { - public MarkdownImageAlt() + public MarkdownImageAlt() { + this.DisplayName = Resources.FormatImageAlt; this.IsBold = false; this.IsItalic = true; this.ForegroundColor = Colors.DeepPink; @@ -237,29 +306,29 @@ public MarkdownImageAlt() } [Export(typeof(EditorFormatDefinition))] - [ClassificationType(ClassificationTypeNames = "markdown.image.label")] - [Name("markdown.image.label")] - [DisplayName("Markdown image label")] + [ClassificationType(ClassificationTypeNames = ClassificationTypeNames.ImageLabel)] + [Name(ClassificationTypeNames.ImageLabel)] [UserVisible(true)] - [Order(After = "markdown.image")] + [Order(After = ClassificationTypeNames.Image)] sealed class MarkdownImageLabel : ClassificationFormatDefinition { public MarkdownImageLabel() { + this.DisplayName = Resources.FormatImageLabel; this.ForegroundColor = Colors.DeepSkyBlue; this.IsBold = false; } } [Export(typeof(EditorFormatDefinition))] - [ClassificationType(ClassificationTypeNames = "markdown.image.title")] - [Name("markdown.image.title")] - [DisplayName("Markdown image title")] + [ClassificationType(ClassificationTypeNames = ClassificationTypeNames.ImageTitle)] + [Name(ClassificationTypeNames.ImageTitle)] [UserVisible(true)] sealed class MarkdownImageTitle : ClassificationFormatDefinition { public MarkdownImageTitle() { + this.DisplayName = Resources.FormatImageTitle; this.IsBold = true; this.ForegroundColor = Colors.CadetBlue; } @@ -268,14 +337,14 @@ public MarkdownImageTitle() // Miscellaneous [Export(typeof(EditorFormatDefinition))] - [ClassificationType(ClassificationTypeNames = "markdown.horizontalrule")] - [Name("markdown.horizontalrule")] - [DisplayName("Markdown horizontal rule")] + [ClassificationType(ClassificationTypeNames = ClassificationTypeNames.HorizontalRule)] + [Name(ClassificationTypeNames.HorizontalRule)] [UserVisible(true)] sealed class MarkdownHorizontalRule : ClassificationFormatDefinition { public MarkdownHorizontalRule() { + this.DisplayName = Resources.FormatHorizontalRule; this.TextDecorations = System.Windows.TextDecorations.Strikethrough; this.IsBold = true; } diff --git a/Classifier/ClassificationTypeNames.cs b/Classifier/ClassificationTypeNames.cs new file mode 100644 index 0000000..baadb04 --- /dev/null +++ b/Classifier/ClassificationTypeNames.cs @@ -0,0 +1,54 @@ +namespace MarkdownMode +{ + internal static class ClassificationTypeNames + { + public const string Markdown = "markdown"; + + public const string Italics = Prefix + "italics"; + public const string Bold = Prefix + "bold"; + public const string BoldItalics = Prefix + "bolditalics"; + + public const string Header = Prefix + "header"; + public const string HeaderH1 = HeaderLevelPrefix + "1"; + public const string HeaderH2 = HeaderLevelPrefix + "2"; + public const string HeaderH3 = HeaderLevelPrefix + "3"; + public const string HeaderH4 = HeaderLevelPrefix + "4"; + public const string HeaderH5 = HeaderLevelPrefix + "5"; + public const string HeaderH6 = HeaderLevelPrefix + "6"; + + public const string List = Prefix + "list"; + public const string ListUnordered = ListPrefix + "unordered"; + public const string ListOrdered = ListPrefix + "ordered"; + + public const string Preformatted = Prefix + "pre"; + public const string Block = Prefix + "block"; + public const string BlockQuote = Prefix + "blockquote"; + + public const string Label = Prefix + "label"; + public const string Link = Prefix + "link"; + public const string LinkText = LinkPrefix + "text"; + public const string LinkTitle = LinkPrefix + "title"; + public const string LinkLabel = LinkPrefix + "label"; + public const string LinkPunctuation = LinkPrefix + "punctuation"; + + public const string Image = Prefix + "image"; + public const string ImageAlt = ImagePrefix + "alt"; + public const string ImageLabel = ImagePrefix + "label"; + public const string ImageTitle = ImagePrefix + "title"; + + public const string Url = Prefix + "url"; + public const string UrlInline = UrlPrefix + "inline"; + public const string UrlDefinition = UrlPrefix + "definition"; + public const string UrlAutomatic = UrlPrefix + "automatic"; + public const string UrlImage = UrlPrefix + "image"; + + public const string HorizontalRule = Prefix + "horizontalrule"; + + private const string Prefix = Markdown + "."; + private const string HeaderLevelPrefix = Header + ".h"; + private const string ListPrefix = List + "."; + private const string LinkPrefix = Link + "."; + private const string ImagePrefix = Image + "."; + private const string UrlPrefix = Url + "."; + } +} diff --git a/Classifier/ClassificationTypes.cs b/Classifier/ClassificationTypes.cs index ae43013..ae0feb3 100644 --- a/Classifier/ClassificationTypes.cs +++ b/Classifier/ClassificationTypes.cs @@ -9,189 +9,189 @@ static class MarkdownClassificationTypes // Base definition for all other classification types [Export] - [Name("markdown")] + [Name(ClassificationTypeNames.Markdown)] internal static ClassificationTypeDefinition MarkdownClassificationDefinition = null; // Bold/italics [Export] - [Name("markdown.italics")] - [BaseDefinition("markdown")] + [Name(ClassificationTypeNames.Italics)] + [BaseDefinition(ClassificationTypeNames.Markdown)] internal static ClassificationTypeDefinition MarkdownItalicsDefinition = null; [Export] - [Name("markdown.bold")] - [BaseDefinition("markdown")] + [Name(ClassificationTypeNames.Bold)] + [BaseDefinition(ClassificationTypeNames.Markdown)] internal static ClassificationTypeDefinition MarkdownBoldDefinition = null; [Export] - [Name("markdown.bolditalics")] - [BaseDefinition("markdown.bold")] - [BaseDefinition("markdown.itlalics")] + [Name(ClassificationTypeNames.BoldItalics)] + [BaseDefinition(ClassificationTypeNames.Bold)] + [BaseDefinition(ClassificationTypeNames.Italics)] internal static ClassificationTypeDefinition MarkdownBoldItalicsDefinition = null; // Headers [Export] - [Name("markdown.header")] - [BaseDefinition("markdown")] + [Name(ClassificationTypeNames.Header)] + [BaseDefinition(ClassificationTypeNames.Markdown)] internal static ClassificationTypeDefinition MarkdownHeaderDefinition = null; [Export] - [Name("markdown.header.h1")] - [BaseDefinition("markdown.header")] + [Name(ClassificationTypeNames.HeaderH1)] + [BaseDefinition(ClassificationTypeNames.Header)] internal static ClassificationTypeDefinition MarkdownH1Definition = null; [Export] - [Name("markdown.header.h2")] - [BaseDefinition("markdown.header")] + [Name(ClassificationTypeNames.HeaderH2)] + [BaseDefinition(ClassificationTypeNames.Header)] internal static ClassificationTypeDefinition MarkdownH2Definition = null; [Export] - [Name("markdown.header.h3")] - [BaseDefinition("markdown.header")] + [Name(ClassificationTypeNames.HeaderH3)] + [BaseDefinition(ClassificationTypeNames.Header)] internal static ClassificationTypeDefinition MarkdownH3Definition = null; [Export] - [Name("markdown.header.h4")] - [BaseDefinition("markdown.header")] + [Name(ClassificationTypeNames.HeaderH4)] + [BaseDefinition(ClassificationTypeNames.Header)] internal static ClassificationTypeDefinition MarkdownH4Definition = null; [Export] - [Name("markdown.header.h5")] - [BaseDefinition("markdown.header")] + [Name(ClassificationTypeNames.HeaderH5)] + [BaseDefinition(ClassificationTypeNames.Header)] internal static ClassificationTypeDefinition MarkdownH5Definition = null; [Export] - [Name("markdown.header.h6")] - [BaseDefinition("markdown.header")] + [Name(ClassificationTypeNames.HeaderH6)] + [BaseDefinition(ClassificationTypeNames.Header)] internal static ClassificationTypeDefinition MarkdownH6Definition = null; // Lists [Export] - [Name("markdown.list")] - [BaseDefinition("markdown")] + [Name(ClassificationTypeNames.List)] + [BaseDefinition(ClassificationTypeNames.Markdown)] internal static ClassificationTypeDefinition MarkdownListDefinition = null; [Export] - [Name("markdown.list.unordered")] - [BaseDefinition("markdown.list")] + [Name(ClassificationTypeNames.ListUnordered)] + [BaseDefinition(ClassificationTypeNames.List)] internal static ClassificationTypeDefinition MarkdownUnorderedListDefinition = null; [Export] - [Name("markdown.list.ordered")] - [BaseDefinition("markdown.list")] + [Name(ClassificationTypeNames.ListOrdered)] + [BaseDefinition(ClassificationTypeNames.List)] internal static ClassificationTypeDefinition MarkdownOrderedListDefinition = null; // Code/pre [Export] - [Name("markdown.pre")] - [BaseDefinition("markdown")] + [Name(ClassificationTypeNames.Preformatted)] + [BaseDefinition(ClassificationTypeNames.Markdown)] internal static ClassificationTypeDefinition MarkdownPreDefinition = null; [Export] - [Name("markdown.block")] - [BaseDefinition("markdown.pre")] + [Name(ClassificationTypeNames.Block)] + [BaseDefinition(ClassificationTypeNames.Preformatted)] internal static ClassificationTypeDefinition MarkdownCodeDefinition = null; // Quotes [Export] - [Name("markdown.blockquote")] - [BaseDefinition("markdown")] - internal static ClassificationTypeDefinition MarkdowBlockquoteDefinition = null; + [Name(ClassificationTypeNames.BlockQuote)] + [BaseDefinition(ClassificationTypeNames.Markdown)] + internal static ClassificationTypeDefinition MarkdownBlockquoteDefinition = null; // Links [Export] - [Name("markdown.label")] - [BaseDefinition("markdown")] + [Name(ClassificationTypeNames.Label)] + [BaseDefinition(ClassificationTypeNames.Markdown)] internal static ClassificationTypeDefinition MarkdownLabel = null; [Export] - [Name("markdown.link")] - [BaseDefinition("markdown")] + [Name(ClassificationTypeNames.Link)] + [BaseDefinition(ClassificationTypeNames.Markdown)] internal static ClassificationTypeDefinition MarkdownLinkDefinition = null; [Export] - [Name("markdown.link.text")] - [BaseDefinition("markdown.link")] + [Name(ClassificationTypeNames.LinkText)] + [BaseDefinition(ClassificationTypeNames.Link)] internal static ClassificationTypeDefinition MarkdownLinkTextDefinition = null; [Export] - [Name("markdown.link.title")] - [BaseDefinition("markdown.link")] + [Name(ClassificationTypeNames.LinkTitle)] + [BaseDefinition(ClassificationTypeNames.Link)] internal static ClassificationTypeDefinition MarkdownLinkTitleDefinition = null; [Export] - [Name("markdown.link.label")] - [BaseDefinition("markdown.label")] - [BaseDefinition("markdown.link")] + [Name(ClassificationTypeNames.LinkLabel)] + [BaseDefinition(ClassificationTypeNames.Label)] + [BaseDefinition(ClassificationTypeNames.Link)] internal static ClassificationTypeDefinition MarkdownLinkLabelDefinition = null; [Export] - [Name("markdown.link.punctuation")] - [BaseDefinition("markdown.link")] + [Name(ClassificationTypeNames.LinkPunctuation)] + [BaseDefinition(ClassificationTypeNames.Link)] internal static ClassificationTypeDefinition MarkdownLinkPunctuationDefinition = null; // Link URLs [Export] - [Name("markdown.url")] - [BaseDefinition("markdown")] + [Name(ClassificationTypeNames.Url)] + [BaseDefinition(ClassificationTypeNames.Markdown)] internal static ClassificationTypeDefinition MarkdownLinkUrlDefinition = null; [Export] - [Name("markdown.url.inline")] - [BaseDefinition("markdown.url")] + [Name(ClassificationTypeNames.UrlInline)] + [BaseDefinition(ClassificationTypeNames.Url)] internal static ClassificationTypeDefinition MarkdownInlineLinkDefinition = null; [Export] - [Name("markdown.url.definition")] - [BaseDefinition("markdown.url")] + [Name(ClassificationTypeNames.UrlDefinition)] + [BaseDefinition(ClassificationTypeNames.Url)] internal static ClassificationTypeDefinition MarkdownDefinitionLinkDefinition = null; [Export] - [Name("markdown.url.automatic")] - [BaseDefinition("markdown.url")] + [Name(ClassificationTypeNames.UrlAutomatic)] + [BaseDefinition(ClassificationTypeNames.Url)] internal static ClassificationTypeDefinition MarkdownAutomaticLinkDefinition = null; // Images [Export] - [Name("markdown.image")] - [BaseDefinition("markdown")] + [Name(ClassificationTypeNames.Image)] + [BaseDefinition(ClassificationTypeNames.Markdown)] internal static ClassificationTypeDefinition MarkdownImageDefinition = null; [Export] - [Name("markdown.image.alt")] - [BaseDefinition("markdown.image")] + [Name(ClassificationTypeNames.ImageAlt)] + [BaseDefinition(ClassificationTypeNames.Image)] internal static ClassificationTypeDefinition MarkdownImageAltDefinition = null; [Export] - [Name("markdown.image.label")] - [BaseDefinition("markdown.label")] - [BaseDefinition("markdown.image")] + [Name(ClassificationTypeNames.ImageLabel)] + [BaseDefinition(ClassificationTypeNames.Label)] + [BaseDefinition(ClassificationTypeNames.Image)] internal static ClassificationTypeDefinition MarkdownImageLabelDefinition = null; [Export] - [Name("markdown.image.title")] - [BaseDefinition("markdown.image")] + [Name(ClassificationTypeNames.ImageTitle)] + [BaseDefinition(ClassificationTypeNames.Image)] internal static ClassificationTypeDefinition MarkdownImageTitleDefinition = null; [Export] - [Name("markdown.url.image")] - [BaseDefinition("markdown.image")] - [BaseDefinition("markdown.url")] + [Name(ClassificationTypeNames.UrlImage)] + [BaseDefinition(ClassificationTypeNames.Image)] + [BaseDefinition(ClassificationTypeNames.Url)] internal static ClassificationTypeDefinition MarkdownImageUrlDefinition = null; // Miscellaneous [Export] - [Name("markdown.horizontalrule")] - [BaseDefinition("markdown")] + [Name(ClassificationTypeNames.HorizontalRule)] + [BaseDefinition(ClassificationTypeNames.Markdown)] internal static ClassificationTypeDefinition MarkdownHorizontalRuleDefinition = null; } diff --git a/Classifier/Classifier.cs b/Classifier/Classifier.cs index 63c9880..de0cd8a 100644 --- a/Classifier/Classifier.cs +++ b/Classifier/Classifier.cs @@ -1,17 +1,15 @@ using System; using System.Collections.Generic; using System.ComponentModel.Composition; -using System.Windows.Media; +using System.Linq; using Microsoft.VisualStudio.Text; using Microsoft.VisualStudio.Text.Classification; using Microsoft.VisualStudio.Utilities; -using System.Text.RegularExpressions; -using System.Diagnostics; namespace MarkdownMode { [Export(typeof(IClassifierProvider))] - [ContentType("markdown")] + [ContentType(MarkdownClassifier.ContentType)] class MarkdownClassifierProvider : IClassifierProvider { [Import] @@ -25,8 +23,46 @@ public IClassifier GetClassifier(ITextBuffer buffer) class MarkdownClassifier : IClassifier { - IClassificationTypeRegistryService _classificationRegistry; - ITextBuffer _buffer; + public const string ContentType = "markdown"; + + private static readonly string[] _tokenToClassificationTypeName; + + private readonly IClassificationType[] _tokenToClassificationType = new IClassificationType[_tokenToClassificationTypeName.Length]; + private readonly IClassificationTypeRegistryService _classificationRegistry; + private readonly ITextBuffer _buffer; + + static MarkdownClassifier() + { + MarkdownParser.TokenType[] values = (MarkdownParser.TokenType[])Enum.GetValues(typeof(MarkdownParser.TokenType)); + MarkdownParser.TokenType max = values.Max(); + _tokenToClassificationTypeName = new string[(int)max + 1]; + + _tokenToClassificationTypeName[(int)MarkdownParser.TokenType.AutomaticUrl] = ClassificationTypeNames.UrlAutomatic; + _tokenToClassificationTypeName[(int)MarkdownParser.TokenType.Blockquote] = ClassificationTypeNames.BlockQuote; + _tokenToClassificationTypeName[(int)MarkdownParser.TokenType.Bold] = ClassificationTypeNames.Bold; + _tokenToClassificationTypeName[(int)MarkdownParser.TokenType.CodeBlock] = ClassificationTypeNames.Block; + _tokenToClassificationTypeName[(int)MarkdownParser.TokenType.H1] = ClassificationTypeNames.HeaderH1; + _tokenToClassificationTypeName[(int)MarkdownParser.TokenType.H2] = ClassificationTypeNames.HeaderH2; + _tokenToClassificationTypeName[(int)MarkdownParser.TokenType.H3] = ClassificationTypeNames.HeaderH3; + _tokenToClassificationTypeName[(int)MarkdownParser.TokenType.H4] = ClassificationTypeNames.HeaderH4; + _tokenToClassificationTypeName[(int)MarkdownParser.TokenType.H5] = ClassificationTypeNames.HeaderH5; + _tokenToClassificationTypeName[(int)MarkdownParser.TokenType.H6] = ClassificationTypeNames.HeaderH6; + _tokenToClassificationTypeName[(int)MarkdownParser.TokenType.HorizontalRule] = ClassificationTypeNames.HorizontalRule; + _tokenToClassificationTypeName[(int)MarkdownParser.TokenType.ImageAltText] = ClassificationTypeNames.ImageAlt; + _tokenToClassificationTypeName[(int)MarkdownParser.TokenType.ImageExpression] = ClassificationTypeNames.Image; + _tokenToClassificationTypeName[(int)MarkdownParser.TokenType.ImageLabel] = ClassificationTypeNames.ImageLabel; + _tokenToClassificationTypeName[(int)MarkdownParser.TokenType.ImageTitle] = ClassificationTypeNames.ImageTitle; + _tokenToClassificationTypeName[(int)MarkdownParser.TokenType.InlineUrl] = ClassificationTypeNames.UrlInline; + _tokenToClassificationTypeName[(int)MarkdownParser.TokenType.Italics] = ClassificationTypeNames.Italics; + _tokenToClassificationTypeName[(int)MarkdownParser.TokenType.LinkExpression] = ClassificationTypeNames.Link; + _tokenToClassificationTypeName[(int)MarkdownParser.TokenType.LinkLabel] = ClassificationTypeNames.LinkLabel; + _tokenToClassificationTypeName[(int)MarkdownParser.TokenType.LinkText] = ClassificationTypeNames.LinkText; + _tokenToClassificationTypeName[(int)MarkdownParser.TokenType.LinkTitle] = ClassificationTypeNames.LinkTitle; + _tokenToClassificationTypeName[(int)MarkdownParser.TokenType.OrderedListElement] = ClassificationTypeNames.ListOrdered; + _tokenToClassificationTypeName[(int)MarkdownParser.TokenType.PreBlock] = ClassificationTypeNames.Preformatted; + _tokenToClassificationTypeName[(int)MarkdownParser.TokenType.UnorderedListElement] = ClassificationTypeNames.ListUnordered; + _tokenToClassificationTypeName[(int)MarkdownParser.TokenType.UrlDefinition] = ClassificationTypeNames.UrlDefinition; + } public MarkdownClassifier(ITextBuffer buffer, IClassificationTypeRegistryService classificationRegistry) { @@ -135,42 +171,22 @@ public IList GetClassificationSpans(SnapshotSpan span) return spans; } - static Dictionary _tokenToClassificationType = new Dictionary() + private IClassificationType GetClassificationTypeForMarkdownToken(MarkdownParser.TokenType tokenType) { - { MarkdownParser.TokenType.AutomaticUrl, "markdown.url.automatic" }, - { MarkdownParser.TokenType.Blockquote, "markdown.blockquote" }, - { MarkdownParser.TokenType.Bold, "markdown.bold" }, - { MarkdownParser.TokenType.CodeBlock, "markdown.block" }, - { MarkdownParser.TokenType.H1, "markdown.header.h1" }, - { MarkdownParser.TokenType.H2, "markdown.header.h2" }, - { MarkdownParser.TokenType.H3, "markdown.header.h3" }, - { MarkdownParser.TokenType.H4, "markdown.header.h4" }, - { MarkdownParser.TokenType.H5, "markdown.header.h5" }, - { MarkdownParser.TokenType.H6, "markdown.header.h6" }, - { MarkdownParser.TokenType.HorizontalRule, "markdown.horizontalrule" }, - { MarkdownParser.TokenType.ImageAltText, "markdown.image.alt" }, - { MarkdownParser.TokenType.ImageExpression, "markdown.image" }, - { MarkdownParser.TokenType.ImageLabel, "markdown.image.label" }, - { MarkdownParser.TokenType.ImageTitle, "markdown.image.title" }, - { MarkdownParser.TokenType.InlineUrl, "markdown.url.inline" }, - { MarkdownParser.TokenType.Italics, "markdown.italics" }, - { MarkdownParser.TokenType.LinkExpression, "markdown.link" }, - { MarkdownParser.TokenType.LinkLabel, "markdown.link.label" }, - { MarkdownParser.TokenType.LinkText, "markdown.link.text" }, - { MarkdownParser.TokenType.LinkTitle, "markdown.link.title" }, - { MarkdownParser.TokenType.OrderedListElement, "markdown.list.ordered" }, - { MarkdownParser.TokenType.PreBlock, "markdown.pre" }, - { MarkdownParser.TokenType.UnorderedListElement, "markdown.list.unordered" }, - { MarkdownParser.TokenType.UrlDefinition, "markdown.url.definition" }, - }; - - IClassificationType GetClassificationTypeForMarkdownToken(MarkdownParser.TokenType tokenType) - { - string classificationType; - if (!_tokenToClassificationType.TryGetValue(tokenType, out classificationType)) - throw new ArgumentException("Unable to find classification type for " + tokenType.ToString(), "tokenType"); + if ((int)tokenType < 0 || (int)tokenType >= _tokenToClassificationType.Length) + return null; + + IClassificationType result = _tokenToClassificationType[(int)tokenType]; + if (result == null) + { + if (string.IsNullOrEmpty(_tokenToClassificationTypeName[(int)tokenType])) + throw new ArgumentException("Unable to find classification type for " + tokenType.ToString(), "tokenType"); + + result = _classificationRegistry.GetClassificationType(_tokenToClassificationTypeName[(int)tokenType]); + _tokenToClassificationType[(int)tokenType] = result; + } - return _classificationRegistry.GetClassificationType(classificationType); + return result; } } } diff --git a/MarkdownMode.csproj b/MarkdownMode.csproj index e9a411e..1990d62 100644 --- a/MarkdownMode.csproj +++ b/MarkdownMode.csproj @@ -75,6 +75,7 @@ + diff --git a/Resources.Designer.cs b/Resources.Designer.cs index cf57d60..556784f 100644 --- a/Resources.Designer.cs +++ b/Resources.Designer.cs @@ -1,7 +1,7 @@ //------------------------------------------------------------------------------ // // This code was generated by a tool. -// Runtime Version:4.0.21006.1 +// Runtime Version:4.0.30319.18034 // // Changes to this file may cause incorrect behavior and will be lost if // the code is regenerated. @@ -60,6 +60,9 @@ internal Resources() { } } + /// + /// Looks up a localized resource of type System.Drawing.Bitmap. + /// internal static System.Drawing.Bitmap _301 { get { object obj = ResourceManager.GetObject("301", resourceCulture); @@ -76,6 +79,213 @@ internal static string CanNotCreateWindow { } } + /// + /// Looks up a localized string similar to Markdown Block. + /// + internal static string FormatBlock { + get { + return ResourceManager.GetString("FormatBlock", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Markdown Block Quote. + /// + internal static string FormatBlockQuote { + get { + return ResourceManager.GetString("FormatBlockQuote", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Markdown Bold. + /// + internal static string FormatBold { + get { + return ResourceManager.GetString("FormatBold", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Markdown Header. + /// + internal static string FormatHeader { + get { + return ResourceManager.GetString("FormatHeader", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Markdown Header (Level 1). + /// + internal static string FormatHeaderH1 { + get { + return ResourceManager.GetString("FormatHeaderH1", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Markdown Header (Level 2). + /// + internal static string FormatHeaderH2 { + get { + return ResourceManager.GetString("FormatHeaderH2", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Markdown Header (Level 3). + /// + internal static string FormatHeaderH3 { + get { + return ResourceManager.GetString("FormatHeaderH3", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Markdown Header (Level 4). + /// + internal static string FormatHeaderH4 { + get { + return ResourceManager.GetString("FormatHeaderH4", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Markdown Header (Level 5). + /// + internal static string FormatHeaderH5 { + get { + return ResourceManager.GetString("FormatHeaderH5", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Markdown Header (Level 6). + /// + internal static string FormatHeaderH6 { + get { + return ResourceManager.GetString("FormatHeaderH6", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Markdown Horizonal Rule. + /// + internal static string FormatHorizontalRule { + get { + return ResourceManager.GetString("FormatHorizontalRule", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Markdown Image. + /// + internal static string FormatImage { + get { + return ResourceManager.GetString("FormatImage", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Markdown Image (Alt Text). + /// + internal static string FormatImageAlt { + get { + return ResourceManager.GetString("FormatImageAlt", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Markdown Image (Label). + /// + internal static string FormatImageLabel { + get { + return ResourceManager.GetString("FormatImageLabel", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Markdown Image (Title). + /// + internal static string FormatImageTitle { + get { + return ResourceManager.GetString("FormatImageTitle", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Markdown Italics. + /// + internal static string FormatItalics { + get { + return ResourceManager.GetString("FormatItalics", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Markdown Link. + /// + internal static string FormatLink { + get { + return ResourceManager.GetString("FormatLink", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Markdown Link (Label). + /// + internal static string FormatLinkLabel { + get { + return ResourceManager.GetString("FormatLinkLabel", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Markdown Link (Text). + /// + internal static string FormatLinkText { + get { + return ResourceManager.GetString("FormatLinkText", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Markdown Link (Title). + /// + internal static string FormatLinkTitle { + get { + return ResourceManager.GetString("FormatLinkTitle", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Markdown List. + /// + internal static string FormatList { + get { + return ResourceManager.GetString("FormatList", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Markdown Preformatted. + /// + internal static string FormatPre { + get { + return ResourceManager.GetString("FormatPre", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Markdown URL. + /// + internal static string FormatUrl { + get { + return ResourceManager.GetString("FormatUrl", resourceCulture); + } + } + /// /// Looks up a localized string similar to Markdown Preview Window. /// diff --git a/Resources.resx b/Resources.resx index 999ffe2..5a57b94 100644 --- a/Resources.resx +++ b/Resources.resx @@ -127,4 +127,73 @@ Markdown Preview Window + + Markdown Block + + + Markdown Block Quote + + + Markdown Bold + + + Markdown Header + + + Markdown Header (Level 1) + + + Markdown Header (Level 2) + + + Markdown Header (Level 3) + + + Markdown Header (Level 4) + + + Markdown Header (Level 5) + + + Markdown Header (Level 6) + + + Markdown Horizonal Rule + + + Markdown Image + + + Markdown Image (Alt Text) + + + Markdown Image (Label) + + + Markdown Image (Title) + + + Markdown Italics + + + Markdown Link + + + Markdown Link (Label) + + + Markdown Link (Text) + + + Markdown Link (Title) + + + Markdown List + + + Markdown Preformatted + + + Markdown URL + \ No newline at end of file