def end_indexentry(self, index_entry):
if self.index_entry_see is not None:
self.html_file.write("\\index{%s|see {%s}}" % (
normalize_ws(index_entry.text), self.index_entry_see))
self.index_entry_see = None
elif self.index_entry_subentry is not None:
self.html_file.write("\\index{%s!%s}" % (
normalize_ws(index_entry.text), self.index_entry_subentry))
self.index_entry_subentry = None
else:
self.html_file.write("\\index{%s}" % normalize_ws(index_entry.text))
return
def start_td(self, table_data):
"""
Start table data.
"""
width = table_data.get("width")
if width is not None:
width = int(width)
else:
width = 1
align = table_data.get("align")
if align is None:
align = "l"
self._current_column_in_table = (
(self._current_column_in_table + width) % self._number_of_columns_in_table)
if table_data.text is not None:
text = normalize_ws(table_data.text).strip()
# override for table headers
parent = table_data.getparent()
if parent.tag == "tableheaderrow":
text = "\\rpgtableheader{%s}" % text
if width > 1 or align != "l":
# multicolumn table data
assert align is not None
self.html_file.write("\\multicolumn{%s}{%s}{%s" % (width, align, text))
else:
# normal table data
self.html_file.write("%s" % text)
return
def start_li(self, list_item):
"""
Start list item.
"""
self.html_file.write("\\item ")
if list_item.text is not None:
self.html_file.write(normalize_ws(list_item.text))
return
def start_line(self, line):
"""
Start equation line.
"""
if not self._equation_first_line:
self.html_file.write("\\> ")
self._equation_first_line = False
if line.text:
self.html_file.write(" %s " % normalize_ws(line.text))
return
def start_measurement(self, distance):
if use_imperial:
distance_text = get_text_for_child(distance, "imperial")
if distance_text is None:
raise Exception("Imperial distance not specified!")
else:
distance_text = get_text_for_child(distance, "metric")
if distance_text is None:
raise Exception("Metric distance not specified!")
self.html_file.write(normalize_ws(distance_text).strip())
return
def end_see(self, index_entry):
self.index_entry_see = normalize_ws(index_entry.text)
return
def start_smaller(self, smaller):
self.html_file.write("\\scriptsize{%s} " % normalize_ws(smaller.text))
return
def start_bold(self, bold):
self.html_file.write("\\textbf{%s} " % normalize_ws(bold.text))
return
def _load(self, archetype_node, fail_fast):
# handle all the children
for child in list(archetype_node):
tag = child.tag
if tag == "archetypetitle":
if self.title is not None:
raise NonUniqueTagError(tag, self.fname, child.sourceline)
else:
self.title = child.text.strip()
elif tag == "archetypeid":
if self.archetype_id is not None:
raise NonUniqueTagError(tag, self.fname, child.sourceline)
else:
self.archetype_id = child.text.strip()
elif tag == "archetypeac":
if self.ac is not None:
raise NonUniqueTagError(tag, self.fname, child.sourceline)
else:
self.ac = child.text.strip()
elif tag == "archetypemove":
if self.move is not None:
raise NonUniqueTagError(tag, self.fname, child.sourceline)
else:
self.move = child.text.strip()
elif tag == "inheritance":
self._load_inheritance(inheritance=child)
elif tag == "archetypedescription":
if self.description is not None:
raise NonUniqueTagError(tag, self.fname, child.sourceline)
else:
self.description = children_to_string(child)
elif tag == "archetypeinitiative":
if self.initiative is not None:
raise NonUniqueTagError(tag, self.fname, child.sourceline)
#raise Exception("Only one archetypeinitiative per file.")
else:
self.initiative = convert_str_to_int(child.text)
elif tag == "startingcash":
if self.starting_cash is not None:
raise NonUniqueTagError(tag, self.fname, child.sourceline)
else:
self.starting_cash = child.text
elif tag == "startinggear":
if self.starting_gear is not None:
raise NonUniqueTagError(tag, self.fname, child.sourceline)
else:
self.starting_gear = normalize_ws(child.text)
elif tag == "height":
if self.height is not None:
raise NonUniqueTagError(tag, self.fname, child.sourceline)
else:
self.height = parse_measurement_to_str(self.fname, child)
elif tag == "weight":
if self.weight is not None:
raise NonUniqueTagError(tag, self.fname, child.sourceline)
else:
self.weight = parse_measurement_to_str(self.fname, child)
elif tag == "appearance":
if self.appearance is not None:
raise NonUniqueTagError(tag, self.fname, child.sourceline)
else:
self.appearance = normalize_ws(child.text)
elif tag == "age":
if self.age is not None:
raise NonUniqueTagError(tag, self.fname, child.sourceline)
else:
self.age = normalize_ws(child.text)
elif tag == "aspectexamples":
if self.aspect_examples is not None:
raise NonUniqueTagError(tag, self.fname, child.sourceline)
else:
self.aspect_examples = child.text
elif tag == "archetypetags":
self.tags.load(child, fail_fast)
elif tag == "archetypeinitialabilities":
if self.initial_abilities is not None:
raise NonUniqueTagError(tag, self.fname, child.sourceline)
else:
self.initial_abilities = children_to_string(child)
elif tag == "levelprogressiontable":
self.level_progression_table.load(child, fail_fast)
elif tag == "abilitymodifiers":
self._load_ability_modifiers(child)
elif tag == "attrbonus":
bonus = AttrBonus()
bonus.parse(self.fname, child)
self.attr_bonuses.append(bonus)
elif tag == "attrmax":
attr_max = AttrLimit()
attr_max.parse(self.fname, AttrLimitType.MAX, child)
self.attr_limits.append(attr_max)
elif tag == "attrmin":
attr_min = AttrLimit()
attr_min.parse(self.fname, AttrLimitType.MIN, child)
self.attr_limits.append(attr_min)
elif tag is COMMENT:
# ignore comments!
pass
else:
raise Exception("UNKNOWN XML TAG (%s) File: %s Line: %s\n" %
(child.tag, self.fname, child.sourceline))
return
def end_pageref(self, pageref):
self.html_file.write("~\\pageref{%s}" % normalize_ws(pageref.text))
return
def end_action_points(self, action_points):
self.html_file.write("%s\n" % normalize_ws(action_points.text))
return
def end_ability_class(self, ability_class):
self.html_file.write("%s\n" % normalize_ws(ability_class.text))
return
def end_ability_group(self, ability_group):
self.html_file.write("%s\n" % normalize_ws(ability_group.text))
return
def start_label(self, label):
self.html_file.write("\n\\label{%s} " % normalize_ws(label.text))
return
def end_subentry(self, index_subentry):
self.index_entry_subentry = normalize_ws(index_subentry.text)
return
def start_defn(self, defn):
# self.html_file.write(" \\textbf{%s}\\index{%s}" % (normalize_ws(defn.text),
# normalize_ws(defn.text)))
self.html_file.write(" \\textbf{%s}" % (normalize_ws(defn.text)))
return
def end_ref(self, ref):
self.html_file.write("~\\ref{%s}" % normalize_ws(ref.text))
return
def end_emph(self, emph):
self.html_file.write("\\emph{%s}" % normalize_ws(emph.text))
return
def load(self, archetype_node, fail_fast):
# handle all the children
for child in list(archetype_node):
tag = child.tag
if tag == "levelnumber":
if self.level_number is not None:
raise NonUniqueTagError(tag, self.fname, child.sourceline)
else:
self.level_number = int(child.text.strip())
elif tag == "levelresolve":
if self.level_resolve is not None:
raise NonUniqueTagError(tag, self.fname, child.sourceline)
else:
self.level_resolve = contents_to_string(child)
elif tag == "levelresolverefresh":
if self.level_resolve_refresh is not None:
raise NonUniqueTagError(tag, self.fname, child.sourceline)
else:
self.level_resolve_refresh = contents_to_string(child)
elif tag == "levelstamina":
if self.level_stamina is not None:
raise NonUniqueTagError(tag, self.fname, child.sourceline)
else:
self.level_stamina = normalize_ws(child.text.strip())
elif tag == "levelstaminarefresh":
if self.level_stamina_refresh is not None:
raise NonUniqueTagError(tag, self.fname, child.sourceline)
else:
self.level_stamina_refresh = normalize_ws(
child.text.strip())
elif tag == "levelhealth":
if self.level_health is not None:
raise NonUniqueTagError(tag, self.fname, child.sourceline)
else:
self.level_health = normalize_ws(child.text.strip())
elif tag == "levelhealthrefresh":
if self.level_health_refresh is not None:
raise NonUniqueTagError(tag, self.fname, child.sourceline)
else:
self.level_health_refresh = normalize_ws(
child.text.strip())
elif tag == "levellore":
if self.level_lore is not None:
raise NonUniqueTagError(tag, self.fname, child.sourceline)
else:
self.level_lore = convert_str_to_int(child.text.strip())
elif tag == "levelmartial":
if self.level_martial is not None:
raise NonUniqueTagError(tag, self.fname, child.sourceline)
else:
self.level_martial = convert_str_to_int(child.text.strip())
elif tag == "levelgeneral":
if self.level_general is not None:
raise NonUniqueTagError(tag, self.fname, child.sourceline)
else:
self.level_general = convert_str_to_int(child.text.strip())
elif tag == "levelmagical":
if self.level_magical is not None:
raise NonUniqueTagError(tag, self.fname, child.sourceline)
else:
self.level_magical = convert_str_to_int(child.text.strip())
elif tag == "leveldescription":
if self.level_description is not None:
raise NonUniqueTagError(tag, self.fname, child.sourceline)
else:
if child.text is not None:
self.level_description = contents_to_string(child)
elif tag == "newlevelabilities":
if len(self.level_abilities) > 0:
raise NonUniqueTagError(tag, self.fname, child.sourceline)
else:
if child.text is not None:
self.load_level_abilities(child)
elif tag == "newlevelpromotions":
if len(self.level_promotions) > 0:
raise NonUniqueTagError(tag, self.fname, child.sourceline)
else:
if child.text is not None:
self.load_level_promotions(child)
elif tag == "levelmagicpool":
if self.level_magic_pool is not None:
raise NonUniqueTagError(tag, self.fname, child.sourceline)
else:
self.level_magic_pool = contents_to_string(child)
elif tag == "levelmagicrefresh":
if self.level_magic_refresh is not None:
raise NonUniqueTagError(tag, self.fname, child.sourceline)
else:
self.level_magic_refresh = contents_to_string(child)
elif tag == "levelfate":
if self.level_fate is not None:
raise NonUniqueTagError(tag, self.fname, child.sourceline)
else:
self.level_fate = contents_to_string(child)
elif tag == "levelfaterefresh":
if self.level_fate_refresh is not None:
raise NonUniqueTagError(tag, self.fname, child.sourceline)
else:
self.level_fate_refresh = contents_to_string(child)
elif tag is COMMENT:
# ignore comments!
pass
else:
raise Exception("UNKNOWN XML TAG (%s) File: %s Line: %s\n" %
(child.tag, self.fname, child.sourceline))
return
