1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
|
DTD definitions for Quanta+ are made up from two parts:
a) the description.rc
b) the tag files
The content of them depends also on the type of the DTD (real or pseudo
DTD).
A. The description.rc
---------------------
Contains some information and rules about the DTD itself.
A1. description.rc for real DTDs
--------------------------------
[General] - generic information
Name = DTD definition string (like -//W3C//DTD HTML 4.01 Transitional//EN)
NickName = the beautified name of the DTD (like HTML 4.01 Transitional). If not
defined, the Name is used as NickName.
URL = url pointing to the DTD definition (http://www.w3.org/TR/html4/loose.dtd)
DoctypeString = the string that should appear in the !DOCTYPE tag
(HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd")
Inherits = the name of the DTD from where this DTD inherits the tags (-//W3C//DTD HTML 4.01//EN)
DefaultExtension = new files are created with this extension (html)
Groups = the list of common attribute groups, which may be present in more than
one tag (Core, I18n, Script). See below (Group1, Group2...)
OBSOLETE, don't use. Groups are read from common.tag.
NumOfPages = how many pages does a tag dialog have (aside of the page containing
the attributes defined in the tag file). See below (Page1,...)
CaseSensitive = case-sensitiveness of the DTD
QuotedAttributes = OBSOLETE, not used
Family = 1 (it's a real DTD)
[Toolbars] - information about DTD toolbars
Location = the directory inside the $TDEDIR($TDEHOME)/share/apps/quanta/toolbars
where the toolbars for this DTD are
Names = the list of toolbar file names (without the .toolbar.tgz extension) that
are loaded for this DTD from the above directory
[Group1] - replace with one of the Groups listed below
Attributes = the list of attributes for this group. Currently all of the listed
attributes are treated as strings.
Example:
[Core]
Attributes = id, class, style, title
[Page1] - description of a tag editor page
Title = the title of this page in the tag editing dialog
Groups = list of groups appearing on this page (like Core, I18n)
[Extra tags] - OBSOLETE! Please define the tags in external files!
List = list of tags not defined in external tag files.
tag_name = attribute1, attribute2 - attribute names of tag called tag_name
tag_name_options = options of tag called tag_name
[Extra rules] - some rules not fitted in other places
BooleanAttributes = simple or complex.
Example for simple: <tag booleanAttr>.
Example for complex: <tag booleanAttr="1"> or <tag booleanAttr="true">
Single Tag Style = html or XML.
Example for html: <single_tag>
Example for XML: <single_tag />
StructGroupsCount = the number of structure groups. See below.
MinusAllowedInWords = if true "this-is-a-word" is treated like a word. Otherwise
it's treated like 4 words.
TagAutoCompleteAfter = CHAR. The autocompletion box is brought up automatically
once this CHAR is entered or SPACE is pressed after this CHAR. For real
DTDs it's usually "<", but for CSS pseudo DTD it's "{". The text "none"
instead of a CHAR specifies that the tag completion box should not be brought
up automatically, only if the user requests it.
AttributeSeparator = CHAR. This CHAR means that the attribute name has ended.
It's " for XML DTDs and , for pseudo DTDs.
TagSeparator = CHAR. Similar to the above.
[StructGroup_1] - definition of structure group 1
Name = the text that appears if there are tags matching this group settings
(like Links)
No_Name = the text that appears if there are NO tags matching this group settings
(like No Links)
Icon = the name of the icon appearing before the above texts (like www)
Tag = tagname(attribute1, attribute2, ...). Tags with name tagname will appear
under this group. The item text will be "attribute1_value | attribute2_value | ..."
Currently only one tag may be listed here.
HasFileName = true if the item text (one of the above attribute values) contains a file name
FileNameRx = regular expression used to remove the unnecessary chars from the item
text.
[Parsing rules] - rules used when parsing the document
SpecialAreas = the beginning and ending string of special areas, separatted by a comma.
Special areas are not parsed according to this DTD's rules, but as their own rules.
A special area can be a pseudo DTD,a comment or something like that. Eg. <!-- -->
SpecialAreaNames = comma separated list of the above special area names. Eg. comment
Comments = comma separated list of area borders for comments. EOL means end-of-line.
Eg: // EOL, /* */
AppendCommonRules = true or false. If true, the following rules are automatically appended:
SpecialAreas = <?xml ?>, <!-- -->, <! >
SpecialAreaNames = XML PI, comment, DTD
Comments = <!-- -->
Default is "true", so append the rules.
SpecialTags = tagname(attributename) - specifies a tag which defines the start of
a special area
MayContain = comma separated list of pseudo-DTDs that can be present in the document.
E.g. php, css
A2. description.rc for pseudo DTDs
----------------------------------
Only the differences, special notices are listed here.
[General]
Groups = (There are no common groups)
NumOfPages = 0 . There is no tag editing dialog for pseudo DTDs.
Family = 2 (it's a pseudo DTD)
[Extra rules]
ScriptName = OBSOLETE, don't use.
ScriptTagBorders = OBSOLETE, don't use.
ScriptRegExp = OBSOLETE, don't use.
AttributeAutoCompletionAfter = CHAR. Similar to the TagAutoCompletionAfter, but
for tag attributes. It's "(" by default and ":" for CSS. Not used for real
DTDs.
RequestSpaceBeforeTagAutoCompletion = boolean. If "true", the list of tags
does not appear if the user types the TagAutoCompletionAfter char, only
if it is followed by at least one space. The default is "false".
VariableGroupIndex = the index value of the group that defines variables.
-1 if there is no such group, otherwise the group must exists.
FunctionGroupIndex = the index value of the group that defines functions.
-1 if there is no such group, otherwise the group must exists.
ClassGroupIndex = the index value of the group that defines classes.
-1 if there is no such group, otherwise the group must exists.
ObjectGroupIndex = the index value of the group that defines objects.
ClassGroupIndex must be defined, otherwise this doesn't make sense.
-1 if there is no such group, otherwise the group must exists.
MemberAutoCompleteAfter = a regular expression which defines when may a member
variable/method appear after a class' usage. Example:
- we have a class called "foo" with some member variables
- the object of type "foo" is used in the document as $objFoo
- the members can appear as $objFoo->member or $objFoo.member
- in the above case this entry shoul look like (?:->|\.)$ (autocomplete
if the object is followed by -> or .)
The regular expression must be terminated with "$" (match end of line).
[StructGroup_1]
DefinitionRx = regular expression used to find text areas in the pseudo DTD, which
will belong to this group. The first captured area should be the actual name
of the group entry.
Example:
\bclass[\\s]+([0-9a-zA-Z_\x7f-\xff]*)[\\s]*
The first captured area (between "(" and ")") holds the class name.
UsageRx = to find an usage of an element of the group.
Example:
- classes are defined as "class foo {...}"
- classes are used as $objFoo
Example 2:
- variables are defined as "int i"
- variables are used as @i
Example 3:
- variables are defined as $i
- variables are used as $i. In this case UsageRx is the same as
DefinitionRx
TypeRx = regular expression to find the type of the element. The pattern is
searched on the result of DefinitionRx match and the first captured areas
will hold the element type. Example (simplified):
DefinitionRx =\$+([a-zA-Z]+)=new\\s[a-zA-Z]+;
TypeRx = new\\s([a-zA-Z]+);
This will match strings like "$fooObj=new foo;". Now this string is
searched and it will find "new foo;", where "foo" is the first
captured text (the regular expression matching foo is between brackets).
So the type of "$fooObj" is "foo".
SearchRx = OBSOLETED by DefinitionRx. Don't use it.
ClearRx = OBSOLETED by DefinitionRx. Don't use it.
[Parsing rules]
AreaBorders = comma separated list of the area borders encapsulating this pseudo
DTD. In case of PHP it is: <? ?>, <* *>, <% %>
Tags = tagname(attribute[defaultvalue]). If the parent(real) DTD has a tag with tagname and
the attribute value of this tag is equal with the DTD name, the tag area
is parsed according to the rules of this DTD. If [defaultvalue] is present, it means that if the attribute
is not present in the tag it's taken as present with value = defaultvalue. Example:
Tags = style(type[text/css]) means that both <style> and <style type="text/css"> are
treated the same way and the DTD defined by this tag is named "text/css".
Comments = comma separated list of area borders for comments. EOL means end-of-line.
Eg: // EOL, /* */
StructKeywords = "," separated list of structure keywords. Structures are treated
as new nodes in the structure tree.
StructBeginStr = a string specifying the beginning of a structure (like {)
StructEndStr = a string specifying the beginning of a structure (like })
StructRx = regular expression containing the beginning or the end of the structure
area. Eg. \\{ | \\} (structure area border can be { or })
MayContain = pseudo DTDs can contain other pseudo DTDs
B. Tag file structure
---------------------
Tag files are described in the Quanta doc tab under Quanta Tag Dialog Definition XML.
|
