<?xml version="1.0" encoding="UTF-8"?>
<!--
    SPDX-FileCopyrightText: 2001 Joseph Wenninger <jowenn@kde.org>
    SPDX-FileCopyrightText: 2002 Anders Lund <anders@alweb.dk>
    SPDX-FileCopyrightText: 2003 Simon Huerlimann <simon.huerlimann@access.unizh.ch>
    SPDX-FileCopyrightText: 2005 Dominik Haumann <dhdev@gmx.de>
    SPDX-FileCopyrightText: 2008 Wilbert Berendsen <info@wilbertberendsen.nl>

    This file describes the XML format used for syntax highlight descriptions
    for the Kate text editor (https://kate-editor.org), which is part of the
    KDE desktop environment (https://kde.org).
    You'll find the "Working with Syntax Highlighting" at
    https://docs.kde.org/stable5/en/kate/katepart/highlight.html

    You can validate your syntax files using "validatehl.sh yourSyntax.xml".
    This needs xmllint from the libxml2 XML library.

    In any case, the katehighlightingindexer will validate all files bundled
    with KTextEditor during compile time and fail on errors.

  TODO
    - find a more readable way for the - -dtdvalid stuff, it's just annoying
      xml comments don't allow it.
-->
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" elementFormDefault="qualified">
  <!--
    Default Styles
    Allowed predefined default styles for itemData, available are:
      - dsNormal,   used for normal text
      - dsKeyword,  used for keywords
      - dsFunction, used for function calls
      - dsVariable, used for variables
      - dsControlFlow, used for control flow, e.g. if, then, else, continue, break
      - dsOperator, used for operators such as +, -, *, ::
      - dsBuiltIn,  used for built-in language classes and functions
      - dsExtension,used for extensions, such as boost, Qt
      - dsPreprocessor, used for preprocessor statements
      - dsAttribute,used for attributes, e.g. @override in java

      - dsChar,     used for a character
      - dsSpecialChar, used for escaped characters
      - dsString,   used for strings
      - dsVerbatimString, used for strings such as HERE docs
      - dsSpecialString, used for strings such as regular expressions or LaTeX math mode
      - dsImport,   used for includes, imports and modules

      - dsDataType, used for data types
      - dsDecVal,   used for decimal values
      - dsBaseN,    used for values with a base other than 10
      - dsFloat,    used for float values
      - dsConstant, used for language constants

      - dsComment,  used for comments
      - dsDocumentation, used for comments that are API documentation
      - dsAnnotation, used for annotation in comments, e.g. @param in doxygen
      - dsCommentVar, used for variables in comments, e.g. after @param in doxygen
      - dsRegionMarker, used for region markers
      - dsInformation, used for information in comments, e.g. @note in doxygen
      - dsWarning,  used for warnings in comments, e.g. @warning in doxygen
      - dsAlert,    used for warning messages such as TODO, WARNING in comments

      - dsOthers,   used for 'other' things
      - dsError,    used for error highlighting.
  -->
  <xs:simpleType name="defStyles">
    <xs:restriction base="xs:token">
      <xs:enumeration value="dsNormal"/>
      <xs:enumeration value="dsKeyword"/>
      <xs:enumeration value="dsFunction"/>
      <xs:enumeration value="dsVariable"/>
      <xs:enumeration value="dsControlFlow"/>
      <xs:enumeration value="dsOperator"/>
      <xs:enumeration value="dsBuiltIn"/>
      <xs:enumeration value="dsExtension"/>
      <xs:enumeration value="dsPreprocessor"/>
      <xs:enumeration value="dsAttribute"/>
      <xs:enumeration value="dsChar"/>
      <xs:enumeration value="dsSpecialChar"/>
      <xs:enumeration value="dsString"/>
      <xs:enumeration value="dsVerbatimString"/>
      <xs:enumeration value="dsSpecialString"/>
      <xs:enumeration value="dsImport"/>
      <xs:enumeration value="dsDataType"/>
      <xs:enumeration value="dsDecVal"/>
      <xs:enumeration value="dsBaseN"/>
      <xs:enumeration value="dsFloat"/>
      <xs:enumeration value="dsConstant"/>
      <xs:enumeration value="dsComment"/>
      <xs:enumeration value="dsDocumentation"/>
      <xs:enumeration value="dsAnnotation"/>
      <xs:enumeration value="dsCommentVar"/>
      <xs:enumeration value="dsRegionMarker"/>
      <xs:enumeration value="dsInformation"/>
      <xs:enumeration value="dsWarning"/>
      <xs:enumeration value="dsAlert"/>
      <xs:enumeration value="dsOthers"/>
      <xs:enumeration value="dsError"/>
    </xs:restriction>
  </xs:simpleType>
  <!--
    Char type
    A sequence of exactly 1 character
  -->
  <xs:simpleType name="char">
    <xs:restriction base="xs:string">
      <xs:length value="1"/>
    </xs:restriction>
  </xs:simpleType>
  <!--
    Language specification
      name:        The name of this syntax description. Used in the Highlightning Mode menu
      alternativeNames:    A list of alternative names to match the language on. [optional]
      section:     The logical group to which this syntax description belongs. Used for sub menus
      extensions:  A file glob or pattern to decide for which documents to use this syntax description
      style:       The style that this highlighter provides. It is used through required-syntax-style by the indenters. [optional]
      mimetype:    A list of mimetypes to decide for which documents to use this syntax description [optional]
      version:     Version number of this syntax description
      kateversion: Kate version required for using this file
      casesensitive: Ignored but preserved to maintain compatibility in older versions of KF5.
      priority:    Priority of this language, if more than one are usable for the file [optional]
      author:      Name of author of this hl file [optional]
      license:     License for this hl file [optional]
      indenter:    Name of the Indenter to use for this highlighting mode per default, like "cstyle" [optional]
      hidden:      Should it be hidden in menu [boolean, optional, default=false]
  -->
  <xs:element name="language">
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="highlighting"/>
        <xs:element minOccurs="0" ref="general"/>
        <xs:element minOccurs="0" ref="spellchecking"/>
      </xs:sequence>
      <xs:attribute name="name" use="required"/>
      <xs:attribute name="alternativeNames"/>
      <xs:attribute name="section" use="required" type="xs:NMTOKEN"/>
      <xs:attribute name="extensions" use="required"/>
      <xs:attribute name="version" use="required" type="xs:integer"/>
      <xs:attribute name="kateversion" use="required" type="xs:decimal"/>
      <xs:attribute name="style"/>
      <xs:attribute name="mimetype"/>
      <!-- always ignored, <keywords casesensitive> must be used -->
      <xs:attribute name="casesensitive" type="xs:boolean"/>
      <xs:attribute name="priority" type="xs:integer"/>
      <xs:attribute name="author"/>
      <xs:attribute name="license"/>
      <xs:attribute name="indenter"/>
      <xs:attribute name="hidden" type="xs:boolean"/>
    </xs:complexType>
  </xs:element>
  <!-- General options -->
  <xs:element name="general">
    <xs:complexType>
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:element ref="folding"/>
        <xs:element ref="comments"/>
        <xs:element ref="keywords"/>
        <xs:element ref="emptyLines"/>
      </xs:choice>
    </xs:complexType>
  </xs:element>
  <!--
    List of folding
    indentationsensitive: If true, the code folding is indentation based.
  -->
  <xs:element name="folding">
    <xs:complexType>
      <xs:attribute name="indentationsensitive" type="xs:boolean"/>
    </xs:complexType>
  </xs:element>
  <!-- List of comments -->
  <xs:element name="comments">
    <xs:complexType>
      <xs:sequence>
        <xs:element maxOccurs="unbounded" ref="comment"/>
      </xs:sequence>
    </xs:complexType>
  </xs:element>
  <!--
    Comment specification
    name:         Type of this comment. Allowed are 'singleLine' and 'multiLine'
    start:        The comment starts with this string
    end:          The comment ends with this string [optional]
    region:       The region name of the foldable multiline comment. If you have
                  beginRegion="Comment" ... endRegion="Comment" you should use
                  region="Comment". This way uncomment works even if you do not
                  select all the text of the multiline comment.
    position:     only availalbe for type singleLine. Default is column0, to insert
                  the single line comment characters after the whitespaces
                  (= before the first non space) set position to "afterwhitespace"
  -->
  <xs:element name="comment">
    <xs:complexType>
      <xs:attribute name="name" use="required">
        <xs:simpleType>
          <xs:restriction base="xs:token">
            <xs:enumeration value="singleLine"/>
            <xs:enumeration value="multiLine"/>
          </xs:restriction>
        </xs:simpleType>
      </xs:attribute>
      <xs:attribute name="start" use="required"/>
      <xs:attribute name="end"/>
      <xs:attribute name="region"/>
      <xs:attribute name="position">
        <xs:simpleType>
          <xs:restriction base="xs:token">
            <xs:enumeration value="afterwhitespace"/>
          </xs:restriction>
        </xs:simpleType>
      </xs:attribute>
    </xs:complexType>
  </xs:element>
  <!--
    Keyword options
    casesensitive:        Whether keywords are matched case sensitive. [boolean, optional, default=true]
    weakDeliminator:      Add weak deliminators [optional, default: ""]
    additionalDeliminator: Add deliminators [optional]
    wordWrapDeliminator:  characters that are used to wrap long lines [optional]

  -->
  <xs:element name="keywords">
    <xs:complexType>
      <xs:attribute name="casesensitive" type="xs:boolean"/>
      <xs:attribute name="weakDeliminator"/>
      <xs:attribute name="additionalDeliminator"/>
      <xs:attribute name="wordWrapDeliminator"/>
    </xs:complexType>
  </xs:element>
  <!--
    Treat lines that match a given regular expression as empty line. This is
    needed for example in Python for comments (#...), as then the indentation
    based folding should ignore the line.
    This is only implemented for indentation based folding. If the folding
    is not indentation based, the emptyLines are not used.
  -->
  <xs:element name="emptyLines">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="emptyLine"/>
      </xs:sequence>
    </xs:complexType>
  </xs:element>
  <!--
    One empty line regular expression.
    regexpr:       The regular expression, example from python: ^\s*#.*$
    casesensitive: Sets, whether the regular expression match is performed case sesitive
  -->
  <xs:element name="emptyLine">
    <xs:complexType>
      <xs:attribute name="regexpr" use="required"/>
      <xs:attribute name="casesensitive" type="xs:boolean"/>
    </xs:complexType>
  </xs:element>
  <!-- Highlighting specification -->
  <xs:element name="highlighting">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="list"/>
        <xs:element ref="contexts"/>
        <xs:element ref="itemDatas"/>
      </xs:sequence>
    </xs:complexType>
  </xs:element>
  <!--
    List of items
    name:     Name of this list
  -->
  <xs:element name="list">
    <xs:complexType>
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:element ref="item"/>
        <xs:element ref="include"/>
      </xs:choice>
      <xs:attribute name="name" use="required"/>
    </xs:complexType>
  </xs:element>
  <!--
    List item
    contains string used in <keyword>
  -->
  <xs:element name="item" type="xs:string"/>
  <!--
    List include
    contains a name of <keyword>
  -->
  <xs:element name="include" type="xs:string"/>
  <!-- List of contexts -->
  <xs:element name="contexts">
    <xs:complexType>
      <xs:sequence>
        <xs:element maxOccurs="unbounded" ref="context"/>
      </xs:sequence>
    </xs:complexType>
  </xs:element>
  <!--
    context specification
      name:             The name of this context specification. Used in '*Context' attributes [optional]
      attribute:        The name of the ItemData to be used for matching text
      lineEndContext:   Next context if end of line is encountered [optional, default='#stay']
      lineEmptyContext: Next context if an empty line is encountered [optional, default=value of lineEndContext]
      fallthrough:      Use a fallthrough context [optional]
                deprecated since 5.62 but preserved to maintain compatibility in older versions of KF5
      fallthroughContext: Fall through to this context [optional, default='#stay']
      dynamic:          Dynamic context [boolean, optional]
                deprecated since always but preserved to maintain compatibility in older versions of KF5
      noIndentationBasedFolding: Python uses indentation based folding. However, Python has parts where
            it does not use indentation based folding (e.g. for """ strings). In this case
            switch to an own context and set this attribute to true. Then the indentation
            based folding will ignore this parts and not change folding markers. [optional]
      stopEmptyLineContextSwitchLoop: Do not continue the context switching if an empty line is encountered. [boolean, optional, default=false]
  -->
  <xs:element name="context">
    <xs:complexType>
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:element ref="keyword"/>
        <xs:element ref="Float"/>
        <xs:element ref="HlCOct"/>
        <xs:element ref="HlCHex"/>
        <xs:element ref="Int"/>
        <xs:element ref="DetectChar"/>
        <xs:element ref="Detect2Chars"/>
        <xs:element ref="AnyChar"/>
        <xs:element ref="StringDetect"/>
        <xs:element ref="WordDetect"/>
        <xs:element ref="RegExpr"/>
        <xs:element ref="LineContinue"/>
        <xs:element ref="HlCStringChar"/>
        <xs:element ref="RangeDetect"/>
        <xs:element ref="HlCChar"/>
        <xs:element ref="IncludeRules"/>
        <xs:element ref="DetectSpaces"/>
        <xs:element ref="DetectIdentifier"/>
      </xs:choice>
      <xs:attribute name="name"/>
      <xs:attribute name="attribute" use="required"/>
      <xs:attribute name="lineEndContext"/>
      <xs:attribute name="lineEmptyContext"/>
      <xs:attribute name="fallthrough">
        <xs:simpleType>
          <!-- always true since 5.62 -->
          <xs:restriction base="xs:token">
            <xs:enumeration value="1"/>
            <xs:enumeration value="true"/>
          </xs:restriction>
        </xs:simpleType>
      </xs:attribute>
      <xs:attribute name="fallthroughContext"/>
      <!-- always ignored -->
      <xs:attribute name="dynamic" type="xs:boolean"/>
      <xs:attribute name="noIndentationBasedFolding" type="xs:boolean"/>
      <!-- since 5.103 -->
      <xs:attribute name="stopEmptyLineContextSwitchLoop" type="xs:boolean"/>
    </xs:complexType>
  </xs:element>
  <!--
    Common attributes
    attribute:    The name of the ItemData to be used for matching text
    context:      The name of the context to go to when this rule matches
    beginRegion:  Begin a region of type beginRegion [optional]
    endRegion:    End a region of type endRegion [optional]
    firstNonSpace: should this rule only match at first non-space char in line?
    column: should this rule only match at given column in line (column == count of chars in front)
  -->
  <xs:attributeGroup name="commonAttributes">
    <xs:attribute name="attribute"/>
    <xs:attribute name="context"/>
    <xs:attribute name="beginRegion"/>
    <xs:attribute name="endRegion"/>
    <xs:attribute name="lookAhead" type="xs:boolean"/>
    <xs:attribute name="firstNonSpace" type="xs:boolean"/>
    <xs:attribute name="column" type="xs:integer"/>
  </xs:attributeGroup>
  <!--
    Detect members of a keyword list
      commonAttributes: Common attributes
      insensitive:      Is this list case-insensitive? [boolean, optional, see note]
      String:           Name of the list
      weakDeliminator:  Add weak deliminators [optional, see note]
      additionalDeliminator: Add deliminators [optional, see note]

      By default, case sensitivity is determined from <keywords casesensitive> in
      <general> (default=true), but can be overridden per-list with 'insensitive'.

      weakDeliminator and additionalDeliminator are accumulated to those defined in
      <keywords weakDeliminator additionalDeliminator> in <general>.
  -->
  <xs:element name="keyword">
    <xs:complexType>
      <xs:attributeGroup ref="commonAttributes"/>
      <xs:attribute name="insensitive" type="xs:boolean"/>
      <xs:attribute name="String" use="required"/>
      <xs:attribute name="weakDeliminator"/>
      <xs:attribute name="additionalDeliminator"/>
    </xs:complexType>
  </xs:element>
  <!--
    Detect a floating point number (as the regular expression: (\b[0-9]+\.[0-9]*|\.[0-9]+)([eE][-+]?[0-9]+)?).
    commonAttributes: Common attributes
    weakDeliminator:  Add weak deliminators [optional]
    additionalDeliminator: Add deliminators [optional]
  -->
  <xs:element name="Float">
    <xs:complexType>
      <xs:attributeGroup ref="commonAttributes"/>
      <xs:attribute name="weakDeliminator"/>
      <xs:attribute name="additionalDeliminator"/>
    </xs:complexType>
  </xs:element>
  <!--
    Detect an octal number (as the regular expression: \b0[0-7]+).
    commonAttributes: Common attributes
    weakDeliminator:  Add weak deliminators [optional]
    additionalDeliminator: Add deliminators [optional]
  -->
  <xs:element name="HlCOct">
    <xs:complexType>
      <xs:attributeGroup ref="commonAttributes"/>
      <xs:attribute name="weakDeliminator"/>
      <xs:attribute name="additionalDeliminator"/>
    </xs:complexType>
  </xs:element>
  <!--
    Detect a hexadecimal number (as a regular expression: \b0[xX][0-9a-fA-F]+).
    commonAttributes: Common attributes
    weakDeliminator:  Add weak deliminators [optional]
    additionalDeliminator: Add deliminators [optional]
  -->
  <xs:element name="HlCHex">
    <xs:complexType>
      <xs:attributeGroup ref="commonAttributes"/>
      <xs:attribute name="weakDeliminator"/>
      <xs:attribute name="additionalDeliminator"/>
    </xs:complexType>
  </xs:element>
  <!--
    Detect C-style character. Characters enclosed in a tick (Example: 'c') which may be a simple character or an escaped character (as a regular expression: '(\\([abefnrtv"'?\\.]|x[0-9a-fA-F]{1,2}|[0-7]{1,3})|[^'])')
      commonAttributes: Common attributes
  -->
  <xs:element name="HlCChar">
    <xs:complexType>
      <xs:attributeGroup ref="commonAttributes"/>
    </xs:complexType>
  </xs:element>
  <!--
    Detect an integer number
    commonAttributes: Common attributes
    weakDeliminator:  Add weak deliminators [optional]
    additionalDeliminator: Add deliminators [optional]
  -->
  <xs:element name="Int">
    <xs:complexType>
      <xs:attributeGroup ref="commonAttributes"/>
      <xs:attribute name="weakDeliminator"/>
      <xs:attribute name="additionalDeliminator"/>
    </xs:complexType>
  </xs:element>
  <!--
    Detect a single character
    commonAttributes: Common attributes
    char:             The character to look for
    dynamic:          Uses 1 .. 9 as placeholders for dynamic arguments (in fact, first char of arg...) [boolean, optional, default=false]
  -->
  <xs:element name="DetectChar">
    <xs:complexType>
      <xs:attributeGroup ref="commonAttributes"/>
      <xs:attribute name="char" type="char" use="required"/>
      <xs:attribute name="dynamic" type="xs:boolean"/>
    </xs:complexType>
  </xs:element>
  <!--
    Detect two characters
    commonAttributes: Common attributes
    char:             The first character
    char1:            The second character
  -->
  <xs:element name="Detect2Chars">
    <xs:complexType>
      <xs:attributeGroup ref="commonAttributes"/>
      <xs:attribute name="char" type="char" use="required"/>
      <xs:attribute name="char1" type="char" use="required"/>
    </xs:complexType>
  </xs:element>
  <!--
    Detect one character of a set of specified characters.
      commonAttributes: Common attributes
      String:           The set of characters
  -->
  <xs:element name="AnyChar">
    <xs:complexType>
      <xs:attributeGroup ref="commonAttributes"/>
      <xs:attribute name="String" use="required"/>
    </xs:complexType>
  </xs:element>
  <!--
    Detect a string
      commonAttributes: Common attributes
      String:           The string to look for
      insensitive:      Whether the string is matched case INsensitive. [boolean, optional, default=false]
      dynamic:          Uses %1 .. %9 as placeholders for dynamic arguments [boolean, optional, default=false]
  -->
  <xs:element name="StringDetect">
    <xs:complexType>
      <xs:attributeGroup ref="commonAttributes"/>
      <xs:attribute name="String" use="required"/>
      <xs:attribute name="insensitive" type="xs:boolean"/>
      <xs:attribute name="dynamic" type="xs:boolean"/>
    </xs:complexType>
  </xs:element>
  <!--
    Detect a word, i.e. a string at word boundaries
      commonAttributes: Common attributes
      String:           The string to look for
      insensitive:      Whether the string is matched case INsensitive. [boolean, optional, default=false]
      weakDeliminator:  Add weak deliminators [optional]
      additionalDeliminator: Add deliminators [optional]
  -->
  <xs:element name="WordDetect">
    <xs:complexType>
      <xs:attributeGroup ref="commonAttributes"/>
      <xs:attribute name="String" use="required"/>
      <xs:attribute name="insensitive" type="xs:boolean"/>
      <xs:attribute name="weakDeliminator"/>
      <xs:attribute name="additionalDeliminator"/>
    </xs:complexType>
  </xs:element>
  <!--
    Detect a match of a regular expression
    commonAttributes: Common attributes
    String:           The regular expression pattern
    insensitive:      Whether the text is matched case INsensitive. [boolean, optional, default=false]
    minimal:          Wheather to use minimal matching for wild cards in the pattern [boolean, optional, default=false]
    dynamic:          Uses %1 .. %9 as placeholders for dynamic arguments [boolean, optional, default=false]
  -->
  <xs:element name="RegExpr">
    <xs:complexType>
      <xs:attributeGroup ref="commonAttributes"/>
      <xs:attribute name="String" use="required"/>
      <xs:attribute name="insensitive" type="xs:boolean"/>
      <xs:attribute name="minimal" type="xs:boolean"/>
      <xs:attribute name="dynamic" type="xs:boolean"/>
    </xs:complexType>
  </xs:element>
  <!--
    Detect a line continuation
    commonAttributes: Common attributes
    char:             The char marking the end of line [char,  optional,  default='\\']
  -->
  <xs:element name="LineContinue">
    <xs:complexType>
      <xs:attributeGroup ref="commonAttributes"/>
      <xs:attribute name="char" type="char"/>
    </xs:complexType>
  </xs:element>
  <!--
    Detect a C-style escaped character (as a regular expression: \\([abefnrtv"'?\\.]|x[0-9a-fA-F]{1,2}|[0-7]{1,3})).
      commonAttributes: Common attributes
  -->
  <xs:element name="HlCStringChar">
    <xs:complexType>
      <xs:attributeGroup ref="commonAttributes"/>
    </xs:complexType>
  </xs:element>
  <!--
    Detect a string with defined start and end characters.
    commonAttributes: Common attributes
    char:             The character starting the range
    char1:            The character terminating the range
  -->
  <xs:element name="RangeDetect">
    <xs:complexType>
      <xs:attributeGroup ref="commonAttributes"/>
      <xs:attribute name="char" type="char" use="required"/>
      <xs:attribute name="char1" type="char" use="required"/>
    </xs:complexType>
  </xs:element>
  <!--
    Include Rules of another context
    context:             The name of the context to include
    includeAttrib:       If this is true, the host context of the IncludeRules
                         will be given the attribute of the source context
  -->
  <xs:element name="IncludeRules">
    <xs:complexType>
      <xs:attribute name="context" use="required"/>
      <xs:attribute name="includeAttrib" type="xs:boolean"/>
    </xs:complexType>
  </xs:element>
  <!-- Detect all following Spaces -->
  <xs:element name="DetectSpaces">
    <xs:complexType>
      <xs:attributeGroup ref="commonAttributes"/>
    </xs:complexType>
  </xs:element>
  <!-- Detect an Identifier ( == LETTER(LETTER|NUMBER|_)*) -->
  <xs:element name="DetectIdentifier">
    <xs:complexType>
      <xs:attributeGroup ref="commonAttributes"/>
    </xs:complexType>
  </xs:element>
  <!-- List of attributes -->
  <xs:element name="itemDatas">
    <xs:complexType>
      <xs:sequence>
        <xs:element maxOccurs="unbounded" ref="itemData"/>
      </xs:sequence>
    </xs:complexType>
  </xs:element>
  <!--
    Attribute specification
    name          CDATA   #REQUIRED       The name of this attribute
    defStyleNum   CDATA   #REQUIRED       The index of the default style to use
    color         CDATA   #IMPLIED        Color for this style, either a hex triplet, a name or some other format recognized by Qt [optional]
    selColor      CDATA   #IMPLIED        The color for this style when text is selected [optional]
    italic        CDATA   #IMPLIED        Whether this attribute should be rendered using an italic typeface [optional, boolean, default=false]
    bold          CDATA   #IMPLIED        Whether this attribute should be renederd using a bold typeface [optional, boolean, default=false]
    underline     CDATA   #IMPLIED        Whether this attribute should be underlined [optional, boolean, default=false]
    strikeOut     CDATA   #IMPLIED        Whether this attribute should be striked out [optional, boolean, default=false]
    backgroundColor    CDATA #IMPLIED     The background color for this style [optional]
    selBackgroundColor CDATA #IMPLIED     The background color for this style when text is selected [optional]
    spellChecking      CDATA #IMPLIED     Whether this attribute should be spell checked [optional, boolean, default=true]
  -->
  <xs:element name="itemData">
    <xs:complexType>
      <xs:attribute name="name" use="required"/>
      <xs:attribute name="defStyleNum" use="required" type="defStyles"/>
      <xs:attribute name="color"/>
      <xs:attribute name="selColor"/>
      <xs:attribute name="italic" type="xs:boolean"/>
      <xs:attribute name="bold" type="xs:boolean"/>
      <xs:attribute name="underline" type="xs:boolean"/>
      <xs:attribute name="strikeOut" type="xs:boolean"/>
      <xs:attribute name="backgroundColor"/>
      <xs:attribute name="selBackgroundColor"/>
      <xs:attribute name="spellChecking" type="xs:boolean"/>
    </xs:complexType>
  </xs:element>
  <!-- Spellchecking specification -->
  <xs:element name="spellchecking">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="encodings"/>
      </xs:sequence>
    </xs:complexType>
  </xs:element>
  <!-- List of character encodings -->
  <xs:element name="encodings">
    <xs:complexType>
      <xs:sequence>
        <xs:element maxOccurs="unbounded" ref="encoding"/>
      </xs:sequence>
    </xs:complexType>
  </xs:element>
  <!--
    Encoding specification
    sequence       CDATA        #REQUIRED  Character sequence of the encoding; must not contain new-line characters, i.e. \n or \r
    character      CDATA        #IMPLIED   Encoded character; must be of length 1
    ignored        (%boolean;)  #IMPLIED   If true, then the encoding sequence is ignored for spellchecking
  -->
  <xs:element name="encoding">
    <xs:complexType>
      <xs:attribute name="string" use="required"/>
      <xs:attribute name="char" type="char"/>
      <xs:attribute name="ignored" type="xs:boolean"/>
    </xs:complexType>
  </xs:element>
</xs:schema>