/// <summary>
    /// Imports the settings from another highlighting strategy.
    /// </summary>
    /// <param name="source">The source.</param>
    protected void ImportSettingsFrom(DefaultHighlightingStrategy source)
    {
      if (source == null)
        throw new ArgumentNullException("source");

      _properties = source._properties;
      _extensions = source._extensions;
      _digitColor = source._digitColor;
      _defaultRuleSet = source._defaultRuleSet;
      _name = source._name;
      _rules = source._rules;
      _environmentColors = source._environmentColors;
      _defaultTextColor = source._defaultTextColor;
    }
    /// <summary>
    /// Imports the settings from another highlighting strategy.
    /// </summary>
    /// <param name="source">The source.</param>
    protected void ImportSettingsFrom(DefaultHighlightingStrategy source)
    {
      if (source == null)
        throw new ArgumentNullException("source");

      properties = source.properties;
      extensions = source.extensions;
      digitColor = source.digitColor;
      defaultRuleSet = source.defaultRuleSet;
      name = source.name;
      rules = source.rules;
      environmentColors = source.environmentColors;
      defaultTextColor = source.defaultTextColor;
    }
    /// <summary>
    /// Parses a highlighting definition.
    /// </summary>
    /// <param name="highlighter">The highlighting strategy, which is set.</param>
    /// <param name="syntaxMode">The syntax highlighting mode.</param>
    /// <param name="xmlReader">The XML reader.</param>
    /// <returns></returns>
    private static DefaultHighlightingStrategy Parse(DefaultHighlightingStrategy highlighter, SyntaxMode syntaxMode, XmlReader xmlReader)
    {
      if (syntaxMode == null)
        throw new ArgumentNullException("syntaxMode");

      if (xmlReader == null)
        throw new ArgumentNullException("xmlReader");

      try
      {
        List<ValidationEventArgs> errors = null;
        XmlReaderSettings settings = new XmlReaderSettings();
        Stream shemaStream = typeof(HighlightingDefinitionParser).Assembly.GetManifestResourceStream("DigitalRune.Windows.TextEditor.Resources.Mode.xsd");
        settings.Schemas.Add("", new XmlTextReader(shemaStream));
        settings.Schemas.ValidationEventHandler += delegate(object sender, ValidationEventArgs args)
        {
          if (errors == null)
          {
            errors = new List<ValidationEventArgs>();
          }
          errors.Add(args);
        };
        settings.ValidationType = ValidationType.Schema;
        XmlReader validatingReader = XmlReader.Create(xmlReader, settings);

        XmlDocument doc = new XmlDocument();
        doc.Load(validatingReader);

        if (highlighter == null)
          highlighter = new DefaultHighlightingStrategy(doc.DocumentElement.Attributes["name"].InnerText);

        if (doc.DocumentElement.HasAttribute("extends"))
        {
          KeyValuePair<SyntaxMode, ISyntaxModeFileProvider> entry = HighlightingManager.Manager.FindHighlighterEntry(doc.DocumentElement.GetAttribute("extends"));
          if (entry.Key == null)
          {
            throw new HighlightingDefinitionInvalidException("Cannot find referenced highlighting source " + doc.DocumentElement.GetAttribute("extends"));
          }
          else
          {
            highlighter = Parse(highlighter, entry.Key, entry.Value.GetSyntaxModeFile(entry.Key));
            if (highlighter == null) return null;
          }
        }
        if (doc.DocumentElement.HasAttribute("extensions"))
        {
          highlighter.Extensions = doc.DocumentElement.GetAttribute("extensions").Split(new char[] { ';', '|' });
        }

        XmlElement environment = doc.DocumentElement["Environment"];
        if (environment != null)
        {
          foreach (XmlNode node in environment.ChildNodes)
          {
            if (node is XmlElement)
            {
              XmlElement el = (XmlElement) node;
              if (el.Name == "Custom")
                highlighter.SetColorFor(el.GetAttribute("name"), el.HasAttribute("bgcolor") ? new HighlightBackground(el) : new HighlightColor(el));
              else
                highlighter.SetColorFor(el.Name, el.HasAttribute("bgcolor") ? new HighlightBackground(el) : new HighlightColor(el));
            }
          }
        }

        // parse properties
        if (doc.DocumentElement["Properties"] != null)
          foreach (XmlElement propertyElement in doc.DocumentElement["Properties"].ChildNodes)
            highlighter.Properties[propertyElement.Attributes["name"].InnerText] = propertyElement.Attributes["value"].InnerText;

        if (doc.DocumentElement["Digits"] != null)
          highlighter.DigitColor = new HighlightColor(doc.DocumentElement["Digits"]);

        XmlNodeList nodes = doc.DocumentElement.GetElementsByTagName("RuleSet");
        foreach (XmlElement element in nodes)
          highlighter.AddRuleSet(new HighlightRuleSet(element));

        xmlReader.Close();

        if (errors != null)
        {
          StringBuilder msg = new StringBuilder();
          foreach (ValidationEventArgs args in errors)
          {
            msg.AppendLine(args.Message);
          }
          throw new HighlightingDefinitionInvalidException(msg.ToString());
        }
        else
        {
          return highlighter;
        }
      }
      catch (Exception e)
      {
        throw new HighlightingDefinitionInvalidException("Could not load mode definition file '" + syntaxMode.FileName + "'.\n", e);
      }
    }
 void CreateDefaultHighlightingStrategy()
 {
     DefaultHighlightingStrategy defaultHighlightingStrategy = new DefaultHighlightingStrategy();
       defaultHighlightingStrategy.Extensions = new string[] { };
       defaultHighlightingStrategy.Rules.Add(new HighlightRuleSet());
       _highlightingDefinitions["Default"] = defaultHighlightingStrategy;
 }