<!-- This is the Document Type Definition for font configuration files -->
<!ELEMENT fontconfig (dir | 
		      cache | 
		      include | 
		      config |
		      match | 
		      alias)* >

<!-- 
    Add a directory that provides fonts
-->
<!ELEMENT dir (#PCDATA)>
<!ATTLIST dir xml:space (default|preserve) 'preserve'>

<!--
    Define the per-user file that holds cache font information.

    If the filename begins with '~', it is replaced with the users
    home directory path.
-->
<!ELEMENT cache (#PCDATA)>
<!ATTLIST cache xml:space (default|preserve) 'preserve'>

<!--
    Reference another configuration file; note that this
    is another complete font configuration file and not
    just a file included by the XML parser.

    Set 'ignore_missing' to 'yes' if errors are to be ignored.

    If the filename begins with '~', it is replaced with the users
    home directory path.
-->
<!ELEMENT include (#PCDATA)>
<!ATTLIST include
	  ignore_missing    (no|yes)		"no"
	  xml:space	    (default|preserve)	"preserve">

<!--
    Global library configuration data
 -->
<!ELEMENT config (blank|rescan)*>

<!--
    Specify the set of Unicode encoding values which
    represent glyphs that are allowed to contain no
    data.  With this list, fontconfig can examine
    fonts for broken glyphs and eliminate them from
    the set of valid Unicode chars.  This idea
    was borrowed from Mozilla
 -->
<!ELEMENT blank (int)*>

<!--
    Aliases are just a special case for multiple match elements

    They are syntactically equivalent to:

    <match>
	<test name="family">
	    <string value=[family]/>
	</test>
	<edit name="family" mode="prepend">
	    <string value=[prefer]/>
	    ...
	</edit>
	<edit name="family" mode="append">
	    <string value=[accept]/>
	    ...
	</edit>
	<edit name="family" mode="append_last">
	    <string value=[default]/>
	    ...
	</edit>
    </match>
-->
<!--
    Periodically rescan the font configuration and
    directories to synch internal state with filesystem
 -->
<!ELEMENT rescan (int)>


<!ELEMENT alias (family*, prefer?, accept?, default?)>
<!ELEMENT prefer (family)*>
<!ELEMENT accept (family)*>
<!ELEMENT default (family)*>
<!ELEMENT family (#PCDATA)>
<!ATTLIST family xml:space (default|preserve) 'preserve'>

<!ENTITY % expr 'int|double|string|matrix|bool|charset
		|name|const
		|or|and|eq|not_eq|less|less_eq|more|more_eq
		|plus|minus|times|divide|not|if'>

<!--
    Match and edit patterns.

    If 'target' is 'pattern', execute the match before selecting a font.
    if 'target' is 'font', execute the match on the result of a font
    selection.
-->
<!ELEMENT match (test*, edit*)>
<!ATTLIST match
	  target (pattern|font)	"pattern">

<!--
    Match a field in a pattern

    if 'qual' is 'any', then the match succeeds if any value in the field matches.
    if 'qual' is 'all', then the match succeeds only if all values match.
    if 'qual' is 'first', then the match succeeds only if the first value matches.
    if 'qual' is 'not_first', then the match succeeds only if any value other than
    	the first matches.
-->
<!ELEMENT test (%expr;)*>
<!ATTLIST test 
	  qual (any|all|first|not_first)    "any"
	  name CDATA	    #REQUIRED
	  compare (eq|not_eq|less|less_eq|more|more_eq)	"eq">

<!--
    Edit a field in a pattern

    The enclosed values are used together to edit the list of values
    associated with 'name'.

    If 'name' matches one of those used in a test element for this match element:
	if 'mode' is 'assign', replace the matched value.
	if 'mode' is 'assign_replace', replace all of the values
	if 'mode' is 'prepend', insert before the matched value
	if 'mode' is 'append', insert after the matched value
	if 'mode' is 'prepend_first', insert before all of the values
	if 'mode' is 'append_last', insert after all of the values
    If 'name' doesn't match any of those used in a test element:
	if 'mode' is 'assign' or 'assign_replace, replace all of the values
	if 'mode' is 'prepend' or 'prepend_first', insert before all of the values
	if 'mode' is 'append' or 'append_last', insert after all of the values
-->
<!ELEMENT edit (%expr;)*>
<!ATTLIST edit
	  name CDATA	    #REQUIRED
	  mode (assign|assign_replace|prepend|append|prepend_first|append_last) "assign"
	  binding (weak|strong) "weak">

<!--
    Elements of expressions follow
-->
<!ELEMENT int (#PCDATA)>
<!ATTLIST int xml:space (default|preserve) 'preserve'>
<!ELEMENT double (#PCDATA)>
<!ATTLIST double xml:space (default|preserve) 'preserve'>
<!ELEMENT string (#PCDATA)>
<!ATTLIST string xml:space (default|preserve) 'preserve'>
<!ELEMENT matrix (double,double,double,double)>
<!ELEMENT bool (true|false)>
<!ELEMENT charset (#PCDATA)>
<!ATTLIST charset xml:space (default|preserve) 'preserve'>
<!ELEMENT name (#PCDATA)>
<!ATTLIST name xml:space (default|preserve) 'preserve'>
<!ELEMENT const (#PCDATA)>
<!ATTLIST const xml:space (default|preserve) 'preserve'>
<!ELEMENT or (%expr;)*>
<!ELEMENT and (%expr;)*>
<!ELEMENT eq ((%expr;), (%expr;))>
<!ELEMENT not_eq ((%expr;), (%expr;))>
<!ELEMENT less ((%expr;), (%expr;))>
<!ELEMENT less_eq ((%expr;), (%expr;))>
<!ELEMENT more ((%expr;), (%expr;))>
<!ELEMENT more_eq ((%expr;), (%expr;))>
<!ELEMENT plus (%expr;)*>
<!ELEMENT minus (%expr;)*>
<!ELEMENT times (%expr;)*>
<!ELEMENT divide (%expr;)*>
<!ELEMENT not (%expr;)>
<!ELEMENT if ((%expr;), (%expr;), (%expr;))>
