public CustomHl(string name)
{
HighlightingRuleSet rs = new HighlightingRuleSet();
Properties.Add("HTML", "HTML");
Name = "HTML";
}
public XmlHighlightingDefinition(XshdSyntaxDefinition xshd, IHighlightingDefinitionReferenceResolver resolver)
{
this.Name = xshd.Name;
xshd.AcceptElements(new RegisterNamedElementsVisitor(this));
TranslateElementVisitor translateVisitor = new TranslateElementVisitor(this, resolver);
foreach (XshdElement element in xshd.Elements)
{
HighlightingRuleSet rs = element.AcceptVisitor(translateVisitor) as HighlightingRuleSet;
XshdRuleSet xrs = element as XshdRuleSet;
if (rs != null && xrs != null && xrs.Name == null)
{
if (MainRuleSet != null)
{
throw Error(element, "Duplicate main RuleSet. There must be only one nameless RuleSet!");
}
else
{
MainRuleSet = rs;
}
}
}
if (MainRuleSet == null)
{
throw new HighlightingDefinitionInvalidException("Could not find main RuleSet.");
}
}
private void AddRuleSet(HighlightingRuleSet ruleSet)
{
if (ruleSet != null && !string.IsNullOrEmpty(ruleSet.Name) && !_namedRuleSets.ContainsKey(ruleSet.Name))
{
_namedRuleSets.Add(ruleSet.Name, ruleSet);
}
}
private HighlightingRuleSet Wrap(HighlightingRuleSet ruleSet)
{
if (ruleSet is null)
{
return(null);
}
if (!String.IsNullOrEmpty(ruleSet.Name) &&
NamedRuleSet.TryGetValue(ruleSet.Name, out var cachedRule))
{
return(cachedRule);
}
if (Converted.TryGetValue(ruleSet, out var cachedRule2))
{
return(cachedRule2);
}
var copySet = new HighlightingRuleSet();
copySet.Name = ruleSet.Name;
Converted[ruleSet] = copySet;
if (!String.IsNullOrEmpty(copySet.Name))
{
NamedRuleSet[copySet.Name] = copySet;
}
foreach (var baseSpan in ruleSet.Spans)
{
if (baseSpan is null)
{
continue;
}
var copySpan = new HighlightingSpan();
copySpan.StartExpression = baseSpan.StartExpression;
copySpan.EndExpression = baseSpan.EndExpression;
copySpan.RuleSet = Wrap(baseSpan.RuleSet);
copySpan.StartColor = Wrap(baseSpan.StartColor);
copySpan.SpanColor = Wrap(baseSpan.SpanColor);
copySpan.EndColor = Wrap(baseSpan.EndColor);
copySpan.SpanColorIncludesStart = baseSpan.SpanColorIncludesStart;
copySpan.SpanColorIncludesEnd = baseSpan.SpanColorIncludesEnd;
copySet.Spans.Add(copySpan);
}
foreach (var baseRule in ruleSet.Rules)
{
var copyRule = new HighlightingRule();
copyRule.Regex = baseRule.Regex;
copyRule.Color = Wrap(baseRule.Color);
copySet.Rules.Add(copyRule);
}
return(copySet);
}
public HighlightingDefinition(string name)
{
Name = name;
MainRuleSet = new HighlightingRuleSet {
Name = "Main"
};
AddRuleSet(MainRuleSet);
}
public CustomizableHighlightingColorizer(HighlightingRuleSet ruleSet, IEnumerable <CustomizedHighlightingColor> customizations)
: base(ruleSet)
{
if (customizations == null)
{
throw new ArgumentNullException("customizations");
}
this.customizations = customizations;
}
/// <summary>
/// Creates a new HighlightingColorizer instance.
/// </summary>
/// <param name="ruleSet">The root highlighting rule set.</param>
public PythonConsoleHighlightingColorizer(HighlightingRuleSet ruleSet, TextDocument document)
: base(ruleSet)
{
if (document == null)
{
throw new ArgumentNullException("document");
}
this.document = document;
}
public ForegroundHighlight(Brush foreground)
{
MainRuleSet = new HighlightingRuleSet();
MainRuleSet.Rules.Add(new HighlightingRule()
{
Regex = new Regex(".+"), Color = new HighlightingColor()
{
Foreground = new SimpleHighlightingBrush(foreground)
}
});
}
public object VisitImport(XshdImport import)
{
HighlightingRuleSet hrs = GetRuleSet(import, import.RuleSetReference);
XshdRuleSet inputRuleSet;
if (reverseRuleSetDict.TryGetValue(hrs, out inputRuleSet)) {
// ensure the ruleset is processed before importing its members
if (VisitRuleSet(inputRuleSet) != hrs)
Debug.Fail("this shouldn't happen");
}
return hrs;
}
public ApiHighlightDefinition(IEnumerable <string> highlightedWords, Brush highlightedWordsBackground, string highlightedText, Brush highlightedTextBackground)
{
MainRuleSet = new HighlightingRuleSet();
if (highlightedWords != null && highlightedWords.Any())
{
MainRuleSet.Rules.Add(CreateHighlightedRule(highlightedWords, highlightedWordsBackground, true));
}
if (!string.IsNullOrWhiteSpace(highlightedText))
{
MainRuleSet.Rules.Add(CreateHighlightedRule(new[] { highlightedText }, highlightedTextBackground, false));
}
}
public object VisitRuleSet(XshdRuleSet ruleSet)
{
HighlightingRuleSet rs = ruleSetDict[ruleSet];
if (processedRuleSets.Contains(ruleSet))
{
return(rs);
}
if (!processingStartedRuleSets.Add(ruleSet))
{
throw Error(ruleSet, "RuleSet cannot be processed because it contains cyclic <Import>");
}
bool oldIgnoreCase = ignoreCase;
if (ruleSet.IgnoreCase != null)
{
ignoreCase = ruleSet.IgnoreCase.Value;
}
rs.Name = ruleSet.Name;
foreach (XshdElement element in ruleSet.Elements)
{
object o = element.AcceptVisitor(this);
HighlightingRuleSet elementRuleSet = o as HighlightingRuleSet;
if (elementRuleSet != null)
{
Merge(rs, elementRuleSet);
}
else
{
HighlightingSpan span = o as HighlightingSpan;
if (span != null)
{
rs.Spans.Add(span);
}
else
{
HighlightingRule elementRule = o as HighlightingRule;
if (elementRule != null)
{
rs.Rules.Add(elementRule);
}
}
}
}
ignoreCase = oldIgnoreCase;
processedRuleSets.Add(ruleSet);
return(rs);
}
public object VisitRuleSet(XshdRuleSet ruleSet)
{
HighlightingRuleSet rs;
if (ruleSet.Name != null)
{
rs = def.ruleSetDict[ruleSet.Name];
}
else
{
rs = new HighlightingRuleSet();
}
bool oldIgnoreCase = ignoreCase;
if (ruleSet.IgnoreCase != null)
{
ignoreCase = ruleSet.IgnoreCase.Value;
}
rs.Name = ruleSet.Name;
foreach (XshdElement element in ruleSet.Elements)
{
object o = element.AcceptVisitor(this);
HighlightingRuleSet elementRuleSet = o as HighlightingRuleSet;
if (elementRuleSet != null)
{
Merge(rs, elementRuleSet);
}
else
{
HighlightingSpan span = o as HighlightingSpan;
if (span != null)
{
rs.Spans.Add(span);
}
else
{
HighlightingRule elementRule = o as HighlightingRule;
if (elementRule != null)
{
rs.Rules.Add(elementRule);
}
}
}
}
ignoreCase = oldIgnoreCase;
return(rs);
}
private void Look(HighlightingRuleSet ruleSet)
{
foreach (var span in ruleSet.Spans)
{
span.StartColor?.Foreground?.GetColor(null);
span.SpanColor?.Foreground?.GetColor(null);
span.EndColor?.Foreground?.GetColor(null);
}
foreach (var rule in ruleSet.Rules)
{
rule.Color?.Foreground?.GetColor(null);
}
}
HighlightingRuleSet GetRuleSet(XshdElement position, XshdReference<XshdRuleSet> ruleSetReference)
{
if (ruleSetReference.InlineElement != null) {
return (HighlightingRuleSet)ruleSetReference.InlineElement.AcceptVisitor(this);
} else if (ruleSetReference.ReferencedElement != null) {
IHighlightingDefinition definition = GetDefinition(position, ruleSetReference.ReferencedDefinition);
HighlightingRuleSet ruleSet = definition.GetNamedRuleSet(ruleSetReference.ReferencedElement);
if (ruleSet == null)
throw Error(position, "Could not find rule set named '" + ruleSetReference.ReferencedElement + "'.");
return ruleSet;
} else {
return null;
}
}
public object VisitRuleSet(XshdRuleSet ruleSet)
{
HighlightingRuleSet hrs = new HighlightingRuleSet();
ruleSets.Add(ruleSet, hrs);
if (ruleSet.Name != null) {
if (ruleSet.Name.Length == 0)
throw Error(ruleSet, "Name must not be the empty string");
if (def.ruleSetDict.ContainsKey(ruleSet.Name))
throw Error(ruleSet, "Duplicate rule set name '" + ruleSet.Name + "'.");
def.ruleSetDict.Add(ruleSet.Name, hrs);
}
ruleSet.AcceptElements(this);
return null;
}
public object VisitRuleSet(XshdRuleSet ruleSet)
{
HighlightingRuleSet hrs = new HighlightingRuleSet();
ruleSets.Add(ruleSet, hrs);
if (ruleSet.Name != null) {
if (ruleSet.Name.Length == 0)
throw Error(ruleSet, "Name must not be the empty string");
if (def.ruleSetDict.ContainsKey(ruleSet.Name))
throw Error(ruleSet, "Duplicate rule set name '" + ruleSet.Name + "'.");
def.ruleSetDict.Add(ruleSet.Name, hrs);
}
ruleSet.AcceptElements(this);
return null;
}
private static void Merge(HighlightingRuleSet target, HighlightingRuleSet source)
{
target.Rules.AddRange(source.Rules);
target.Spans.AddRange(source.Spans);
}
static void Merge(HighlightingRuleSet target, HighlightingRuleSet source)
{
target.Rules.AddRange(source.Rules);
target.Spans.AddRange(source.Spans);
}
public object VisitRuleSet(XshdRuleSet ruleSet)
{
HighlightingRuleSet rs;
if (ruleSet.Name != null)
rs = def.ruleSetDict[ruleSet.Name];
else
rs = new HighlightingRuleSet();
bool oldIgnoreCase = ignoreCase;
if (ruleSet.IgnoreCase != null)
ignoreCase = ruleSet.IgnoreCase.Value;
rs.Name = ruleSet.Name;
foreach (XshdElement element in ruleSet.Elements) {
object o = element.AcceptVisitor(this);
HighlightingRuleSet elementRuleSet = o as HighlightingRuleSet;
if (elementRuleSet != null) {
Merge(rs, elementRuleSet);
} else {
HighlightingSpan span = o as HighlightingSpan;
if (span != null) {
rs.Spans.Add(span);
} else {
HighlightingRule elementRule = o as HighlightingRule;
if (elementRule != null) {
rs.Rules.Add(elementRule);
}
}
}
}
ignoreCase = oldIgnoreCase;
return rs;
}
