def add_menu_options(self, menu):
"""
Add options to the menu for the kinship report.
"""
category_name = _("Report Options")
pid = PersonOption(_("Center Person"))
pid.set_help(_("The center person for the report"))
menu.add_option(category_name, "pid", pid)
stdoptions.add_name_format_option(menu, category_name)
maxdescend = NumberOption(_("Max Descendant Generations"), 2, 1, 20)
maxdescend.set_help(_("The maximum number of descendant generations"))
menu.add_option(category_name, "maxdescend", maxdescend)
maxascend = NumberOption(_("Max Ancestor Generations"), 2, 1, 20)
maxascend.set_help(_("The maximum number of ancestor generations"))
menu.add_option(category_name, "maxascend", maxascend)
incspouses = BooleanOption(_("Include spouses"), True)
incspouses.set_help(_("Whether to include spouses"))
menu.add_option(category_name, "incspouses", incspouses)
inccousins = BooleanOption(_("Include cousins"), True)
inccousins.set_help(_("Whether to include cousins"))
menu.add_option(category_name, "inccousins", inccousins)
incaunts = BooleanOption(_("Include aunts/uncles/nephews/nieces"), True)
incaunts.set_help(_("Whether to include aunts/uncles/nephews/nieces"))
menu.add_option(category_name, "incaunts", incaunts)
stdoptions.add_private_data_option(menu, category_name)
stdoptions.add_localization_option(menu, category_name)
def add_menu_options(self, menu):
category_name = _("Selection")
self.replace_without_asking = BooleanOption(
_("Replace existing references to the person "
"being assigned without asking"), REPLACE_WITHOUT_ASKING)
menu.add_option(category_name, "replace_without_asking",
self.replace_without_asking)
category_name = _("Face detection")
width, height = MIN_FACE_SIZE
sensitivity = SENSITIVITY
self.min_face_width = NumberOption(_("Minimum face width (px)"), width,
1, 1000, 1)
self.min_face_height = NumberOption(_("Minimum face height (px)"),
height, 1, 1000, 1)
self.detect_inside_existing_boxes = BooleanOption(
_("Detect faces inside existing boxes"),
DETECT_INSIDE_EXISTING_BOXES)
self.sensitivity = NumberOption(_("Sensitivity (1 min .. 20 max)"),
sensitivity, 1, 20, 1)
menu.add_option(category_name, "min_face_width", self.min_face_width)
menu.add_option(category_name, "min_face_height", self.min_face_height)
menu.add_option(category_name, "sensitivity", self.sensitivity)
menu.add_option(category_name, "detect_inside_existing_boxes",
self.detect_inside_existing_boxes)
def add_menu_options(self, menu):
category_name = _("Report Options")
if self.name.split(",")[0] == _PERSON_RPT_NAME:
self.__pid = PersonOption(_("Center Person"))
self.__pid.set_help(_("The center person for the report"))
menu.add_option(category_name, "pid", self.__pid)
else:
self.__pid = FamilyOption(_("Center Family"))
self.__pid.set_help(_("The center family for the report"))
menu.add_option(category_name, "pid", self.__pid)
genup = NumberOption(_("Generations up"), 10, 0, 100)
genup.set_help(_("The number of generations to include in the tree"))
menu.add_option(category_name, "genup", genup)
gendown = NumberOption(_("Generations down"), 10, 0, 100)
gendown.set_help(_("The number of generations to include in the tree"))
menu.add_option(category_name, "gendown", gendown)
siblings = BooleanOption(_("Include siblings"), True)
siblings.set_help(_("Include siblings of ancestors."))
menu.add_option(category_name, "siblings", siblings)
images = BooleanOption(_("Include images"), False)
images.set_help(_("Include images of people in the nodes."))
menu.add_option(category_name, "images", images)
locale_opt = stdoptions.add_localization_option(menu, category_name)
def build_options(self):
"""
Build the configuration options.
"""
from gramps.gen.plug.menu import NumberOption, EnumeratedListOption
self.opts = []
# Minimum number of lines we want to see. Further lines with the same
# distance to the main person will be added on top of this.
name = _("Minimum number of items to display")
opt = NumberOption(name, self.__todos_wanted, 1, 300)
self.opts.append(opt)
# How many generations of descendants to process before we go up to the
# next level of ancestors.
name = _("Descendant generations per ancestor generation")
opt = NumberOption(name, self.__downs_per_up, 1, 20)
self.opts.append(opt)
# After an ancestor was processed, how many extra rounds to delay until
# the descendants of this ancestor are processed.
name = _("Delay before descendants of an ancestor is processed")
opt = NumberOption(name, self.__ancestor_delay, 1, 10)
self.opts.append(opt)
# Tag to use to indicate that this person has no further marriages, if
# the person is not tagged, warn about this at the time the marriages
# for the person are processed.
name = _("Tag to indicate that a person is complete")
opt = EnumeratedListOption(name, self.__person_complete_tag)
self.opts.append(opt)
# Tag to use to indicate that there are no further children in this
# family, if this family is not tagged, warn about this at the time the
# children of this family are processed.
name = _("Tag to indicate that a family is complete")
opt = EnumeratedListOption(name, self.__family_complete_tag)
self.opts.append(opt)
# Tag to use to specify people and families to ignore. In his way,
# hopeless cases can be marked separately and don't clutter up the list.
name = _("Tag to indicate that a person or family should be ignored")
opt = EnumeratedListOption(name, self.__ignore_tag)
self.opts.append(opt)
self.opts[3].add_item('', '')
self.opts[4].add_item('', '')
self.opts[5].add_item('', '')
if self.dbstate.db.is_open():
for tag_handle in self.dbstate.db.get_tag_handles(
sort_handles=True):
tag = self.dbstate.db.get_tag_from_handle(tag_handle)
tag_name = tag.get_name()
self.opts[3].add_item(tag_name, tag_name)
self.opts[4].add_item(tag_name, tag_name)
self.opts[5].add_item(tag_name, tag_name)
list(map(self.add_option, self.opts))
def build_options(self):
from gramps.gen.plug.menu import NumberOption
self.top_size_option = NumberOption(_("Number of surnames"), self.top_size, 1, 150)
self.add_option(self.top_size_option)
self.min_option = NumberOption(_("Min font size"), self.min_font, 1, 50)
self.add_option(self.min_option)
self.max_option = NumberOption(_("Max font size"), self.max_font, 1, 50)
self.add_option(self.max_option)
def build_options(self):
from gramps.gen.plug.menu import NumberOption
self.add_option(NumberOption(_("Max age"), self.max_age, 5, 150, 5))
self.add_option(
NumberOption(_("Max age of Mother at birth"), self.max_mother_diff,
5, 150, 5))
self.add_option(
NumberOption(_("Max age of Father at birth"), self.max_father_diff,
5, 150, 5))
def build_options(self):
from gramps.gen.plug.menu import NumberOption
self.add_option(NumberOption(_("Max age"),
self.max_age, 1, 150))
self.add_option(NumberOption(_("Max age of Mother at birth"),
self.max_mother_diff, 1, 150))
self.add_option(NumberOption(_("Max age of Father at birth"),
self.max_father_diff, 1, 150))
self.add_option(NumberOption(_("Chart width"),
self.chart_width, 1, 150))
def add_menu_options(self, menu):
"""
Create all the menu options for this report.
"""
category_name = _("Report Options")
pid = PersonOption(_("Center Person"))
pid.set_help(_("The Center person for the graph"))
menu.add_option(category_name, "pid", pid)
stdoptions.add_name_format_option(menu, category_name)
stdoptions.add_private_data_option(menu, category_name)
stdoptions.add_living_people_option(menu, category_name)
max_gen = NumberOption(_('Max Descendant Generations'), 10, 1, 15)
max_gen.set_help(
_("The number of generations of descendants to "
"include in the graph"))
menu.add_option(category_name, "maxdescend", max_gen)
max_gen = NumberOption(_('Max Ancestor Generations'), 10, 1, 15)
max_gen.set_help(
_("The number of generations of ancestors to "
"include in the graph"))
menu.add_option(category_name, "maxascend", max_gen)
include_id = EnumeratedListOption(_('Include Gramps ID'), 0)
include_id.add_item(0, _('Do not include'))
include_id.add_item(1, _('Share an existing line'))
include_id.add_item(2, _('On a line of its own'))
include_id.set_help(_("Whether (and where) to include Gramps IDs"))
menu.add_option(category_name, "incid", include_id)
stdoptions.add_localization_option(menu, category_name)
################################
category_name = _("Graph Style")
################################
color = EnumeratedListOption(_("Graph coloring"), "filled")
for i in range(0, len(_COLORS)):
color.add_item(_COLORS[i]["value"], _COLORS[i]["name"])
color.set_help(
_("Males will be shown with blue, females "
"with red. If the sex of an individual "
"is unknown it will be shown with gray."))
menu.add_option(category_name, "color", color)
roundedcorners = BooleanOption(_("Use rounded corners"), False) # 2180
roundedcorners.set_help(
_("Use rounded corners to differentiate between women and men."))
menu.add_option(category_name, "roundcorners", roundedcorners)
def add_menu_options(self, menu):
""" Add the options for this report """
category_name = _("Report Options")
self.__title = StringOption(_('book|Title'), _('Title of the Book'))
self.__title.set_help(_("Title string for the book."))
menu.add_option(category_name, "title", self.__title)
subtitle = StringOption(_('Subtitle'), _('Subtitle of the Book'))
subtitle.set_help(_("Subtitle string for the book."))
menu.add_option(category_name, "subtitle", subtitle)
dateinfo = time.localtime(time.time())
rname = self.__db.get_researcher().get_name()
footer_string = _('Copyright %(year)d %(name)s') % {
'year': dateinfo[0],
'name': rname
}
footer = StringOption(_('Footer'), footer_string)
footer.set_help(_("Footer string for the page."))
menu.add_option(category_name, "footer", footer)
imgid = MediaOption(_('Image'))
imgid.set_help(_("Gramps ID of the media object to use as an image."))
menu.add_option(category_name, "imgid", imgid)
imgsize = NumberOption(_('Image Size'), 0, 0, 20, 0.1)
imgsize.set_help(
_("Size of the image in cm. A value of 0 indicates "
"that the image should be fit to the page."))
menu.add_option(category_name, "imgsize", imgsize)
def add_menu_options(self, menu):
"""
Add options to the menu for the ancestor report.
"""
category_name = _("Report Options")
self.__pid = PersonOption(_("Center Person"))
self.__pid.set_help(_("The center person for the report"))
menu.add_option(category_name, "pid", self.__pid)
maxgen = NumberOption(_("Generations"), 10, 1, 100)
maxgen.set_help(
_("The number of generations to include in the report"))
menu.add_option(category_name, "maxgen", maxgen)
pagebbg = BooleanOption(_("Page break between generations"), False)
pagebbg.set_help(
_("Whether to start a new page after each generation."))
menu.add_option(category_name, "pagebbg", pagebbg)
namebrk = BooleanOption(_("Add linebreak after each name"), False)
namebrk.set_help(
_("Indicates if a line break should follow the name."))
menu.add_option(category_name, "namebrk", namebrk)
category_name = _("Report Options (2)")
stdoptions.add_name_format_option(menu, category_name)
stdoptions.add_private_data_option(menu, category_name)
stdoptions.add_living_people_option(menu, category_name)
stdoptions.add_localization_option(menu, category_name)
def add_menu_options(self, menu):
category_name = _("Report Options")
self.__filter = FilterOption(_("Filter"), 0)
self.__filter.set_help(
_("Determines what people are included in the report."))
menu.add_option(category_name, "filter", self.__filter)
self.__filter.connect('value-changed', self.__filter_changed)
self.__pid = PersonOption(_("Filter Person"))
self.__pid.set_help(_("The center person for the filter"))
menu.add_option(category_name, "pid", self.__pid)
self.__pid.connect('value-changed', self.__update_filters)
top_size = NumberOption(_("Number of ranks to display"), 3, 1, 100)
menu.add_option(category_name, "top_size", top_size)
callname = EnumeratedListOption(_("Use call name"), CALLNAME_DONTUSE)
callname.set_items([(CALLNAME_DONTUSE, _("Don't use call name")),
(CALLNAME_REPLACE,
_("Replace first names with call name")),
(CALLNAME_UNDERLINE_ADD,
_("Underline call name in first names / "
"add call name to first name"))])
menu.add_option(category_name, "callname", callname)
footer = StringOption(_("Footer text"), "")
menu.add_option(category_name, "footer", footer)
category_name = _("Report Options (2)")
self._nf = stdoptions.add_name_format_option(menu, category_name)
self._nf.connect('value-changed', self.__update_filters)
self.__update_filters()
stdoptions.add_private_data_option(menu, category_name)
stdoptions.add_living_people_option(menu, category_name)
stdoptions.add_localization_option(menu, category_name)
p_count = 0
for (text, varname, default) in RECORDS:
if varname.startswith('person'):
p_count += 1
p_half = p_count // 2
p_idx = 0
for (text, varname, default) in RECORDS:
option = BooleanOption(_(text), default)
if varname.startswith('person'):
if p_idx >= p_half:
category_name = _("Person 2")
else:
category_name = _("Person 1")
p_idx += 1
elif varname.startswith('family'):
category_name = _("Family")
menu.add_option(category_name, varname, option)
def add_menu_options(self, menu):
"""
Add options to the menu for the fan chart.
"""
category_name = _("Report Options")
pid = PersonOption(_("Center Person"))
pid.set_help(_("The center person for the report"))
menu.add_option(category_name, "pid", pid)
stdoptions.add_private_data_option(menu, category_name)
stdoptions.add_living_people_option(menu, category_name)
max_gen = NumberOption(_("Generations"), 5, 1, self.MAX_GENERATIONS)
max_gen.set_help(
_("The number of generations "
"to include in the report"))
menu.add_option(category_name, "maxgen", max_gen)
circle = EnumeratedListOption(_('Type of graph'), HALF_CIRCLE)
circle.add_item(FULL_CIRCLE, _('full circle'))
circle.add_item(HALF_CIRCLE, _('half circle'))
circle.add_item(QUAR_CIRCLE, _('quarter circle'))
circle.set_help(
_("The form of the graph: full circle, half circle,"
" or quarter circle."))
menu.add_option(category_name, "circle", circle)
background = EnumeratedListOption(_('Background color'),
BACKGROUND_GEN)
background.add_item(BACKGROUND_WHITE, _('white'))
background.add_item(BACKGROUND_GEN, _('generation dependent'))
background.set_help(
_("Background color is either white or generation"
" dependent"))
menu.add_option(category_name, "background", background)
radial = EnumeratedListOption(_('Orientation of radial texts'),
RADIAL_UPRIGHT)
radial.add_item(RADIAL_UPRIGHT, _('upright'))
radial.add_item(RADIAL_ROUNDABOUT, _('roundabout'))
radial.set_help(_("Print radial texts upright or roundabout"))
menu.add_option(category_name, "radial", radial)
draw_empty = BooleanOption(_("Draw empty boxes"), True)
draw_empty.set_help(
_("Draw the background "
"although there is no information"))
menu.add_option(category_name, "draw_empty", draw_empty)
same_style = BooleanOption(
_("Use one font style "
"for all generations"), True)
same_style.set_help(
_("You can customize font and color "
"for each generation in the style editor"))
menu.add_option(category_name, "same_style", same_style)
stdoptions.add_localization_option(menu, category_name)
def build_options(self):
self.add_option(
NumberOption(_("Max generations"), self.max_generations, 1, 100))
self.add_option(BooleanOption(_("Show dates"), bool(self.show_dates)))
elist = EnumeratedListOption(_("Line type"), self.box_mode)
elist.add_item("UTF", "UTF")
elist.add_item("ASCII", "ASCII")
self.add_option(elist)
def add_menu_options(self, menu):
"""
Add options to the document menu for the AsciiDoc docgen.
"""
category_name = 'Document Options' # internal name: don't translate
linechars = NumberOption(_('Characters per line'), 72, 20, 9999)
linechars.set_help(_("The number of characters per line"))
menu.add_option(category_name, 'linechars', linechars)
def add_menu_options(self, menu):
category_name = _("Report Options")
self.__pid = PersonOption(_("Center Person"))
self.__pid.set_help(_("The center person for the report"))
menu.add_option(category_name, "pid", self.__pid)
genup = NumberOption(_("Generations up"), 10, 1, 100)
genup.set_help(_("The number of generations to include in the tree"))
menu.add_option(category_name, "genup", genup)
gendown = NumberOption(_("Generations down"), 10, 1, 100)
gendown.set_help(_("The number of generations to include in the tree"))
menu.add_option(category_name, "gendown", gendown)
images = BooleanOption(_("Include images"), False)
images.set_help(_("Include images of people in the nodes."))
menu.add_option(category_name, "images", images)
def add_menu_options(self, menu):
category_name = _("Report Options")
self.__pid = PersonOption(_("Center Person"))
self.__pid.set_help(_("The center person for the report"))
menu.add_option(category_name, "pid", self.__pid)
maxgen = NumberOption(_("Generations"), 10, 1, 100)
maxgen.set_help(_("The number of generations to include in the tree"))
menu.add_option(category_name, "maxgen", maxgen)
shift = NumberOption(_("Grandparent family spacing"), 0, 0, 50)
shift.set_help(_("Extra spacing of grandparent families (mm)"))
menu.add_option(category_name, "shift", shift)
images = BooleanOption(_("Include images"), False)
images.set_help(_("Include images of people in the nodes."))
menu.add_option(category_name, "images", images)
def add_menu_options(self, menu):
"""
Add options to the document menu for the AsciiDoc docgen.
"""
category_name = DOCGEN_OPTIONS
linechars = NumberOption(_('Characters per line'), 72, 20, 9999)
linechars.set_help(_("The number of characters per line"))
menu.add_option(category_name, 'linechars', linechars)
def add_menu_options(self, menu):
"""
Create all the menu options for this report.
"""
category_name = _("Options")
pid = PersonOption(_("Center Person"))
pid.set_help(_("The Center person for the graph"))
menu.add_option(category_name, "pid", pid)
stdoptions.add_name_format_option(menu, category_name)
max_gen = NumberOption(_('Max Descendant Generations'), 10, 1, 15)
max_gen.set_help(_("The number of generations of descendants to "
"include in the graph"))
menu.add_option(category_name, "maxdescend", max_gen)
max_gen = NumberOption(_('Max Ancestor Generations'), 10, 1, 15)
max_gen.set_help(_("The number of generations of ancestors to "
"include in the graph"))
menu.add_option(category_name, "maxascend", max_gen)
stdoptions.add_localization_option(menu, category_name)
################################
category_name = _("Graph Style")
################################
color = EnumeratedListOption(_("Graph coloring"), "filled")
for i in range( 0, len(_COLORS) ):
color.add_item(_COLORS[i]["value"], _COLORS[i]["name"])
color.set_help(_("Males will be shown with blue, females "
"with red. If the sex of an individual "
"is unknown it will be shown with gray."))
menu.add_option(category_name, "color", color)
roundedcorners = BooleanOption( # see bug report #2180
_("Use rounded corners"), False)
roundedcorners.set_help(
_("Use rounded corners to differentiate "
"between women and men."))
menu.add_option(category_name, "roundcorners", roundedcorners)
def add_menu_options(self, menu):
category_name = _("Report Options")
self.__pid = PersonOption(_("Center Person"))
self.__pid.set_help(_("The center person for the report"))
menu.add_option(category_name, "pid", self.__pid)
numbering = EnumeratedListOption(_("Numbering system"), "Simple")
numbering.set_items([
("Simple", _("Simple numbering")),
("d'Aboville", _("d'Aboville numbering")),
("Henry", _("Henry numbering")),
("Modified Henry", _("Modified Henry numbering")),
("de Villiers/Pama", _("de Villiers/Pama numbering")),
("Meurgey de Tupigny", _("Meurgey de Tupigny numbering"))
])
numbering.set_help(_("The numbering system to be used"))
menu.add_option(category_name, "numbering", numbering)
gen = NumberOption(_("Generations"), 10, 1, 15)
gen.set_help(_("The number of generations to include in the report"))
menu.add_option(category_name, "gen", gen)
stdoptions.add_gramps_id_option(menu, category_name)
marrs = BooleanOption(_('Show marriage info'), False)
marrs.set_help(
_("Whether to show marriage information in the report."))
menu.add_option(category_name, "marrs", marrs)
divs = BooleanOption(_('Show divorce info'), False)
divs.set_help(_("Whether to show divorce information in the report."))
menu.add_option(category_name, "divs", divs)
dups = BooleanOption(_('Show duplicate trees'), True)
dups.set_help(
_("Whether to show duplicate Family Trees in the report."))
menu.add_option(category_name, "dups", dups)
category_name = _("Report Options (2)")
stdoptions.add_name_format_option(menu, category_name)
stdoptions.add_place_format_option(menu, category_name)
stdoptions.add_private_data_option(menu, category_name)
stdoptions.add_living_people_option(menu, category_name)
locale_opt = stdoptions.add_localization_option(menu, category_name)
stdoptions.add_date_format_option(menu, category_name, locale_opt)
def add_menu_options(self, menu):
category_name = _("Report Options")
self.__filter = FilterOption(_("Filter"), 0)
self.__filter.set_help(
_("Select filter to restrict people that appear in the report"))
menu.add_option(category_name, "filter", self.__filter)
self.__pid = PersonOption(_("Center Person"))
self.__pid.set_help(_("The center person for the report"))
menu.add_option(category_name, "pid", self.__pid)
self.__pid.connect('value-changed', self.__update_filters)
self.__update_filters()
# We must figure out the value of the first option before we can
# create the EnumeratedListOption
fmt_list = global_name_display.get_name_format()
name_format = EnumeratedListOption(_("Name format"), 0)
name_format.add_item(0, _("Default"))
for num, name, fmt_str, act in fmt_list:
name_format.add_item(num, name)
name_format.set_help(_("Select the format to display names"))
menu.add_option(category_name, "name_format", name_format)
numbering = EnumeratedListOption(_("Numbering system"), "Simple")
numbering.set_items([
("Simple", _("Simple numbering")),
("de Villiers/Pama", _("de Villiers/Pama numbering")),
("Meurgey de Tupigny", _("Meurgey de Tupigny numbering"))
])
numbering.set_help(_("The numbering system to be used"))
menu.add_option(category_name, "numbering", numbering)
gen = NumberOption(_("Generations"), 10, 1, 15)
gen.set_help(_("The number of generations to include in the report"))
menu.add_option(category_name, "gen", gen)
marrs = BooleanOption(_('Show marriage info'), False)
marrs.set_help(
_("Whether to show marriage information in the report."))
menu.add_option(category_name, "marrs", marrs)
divs = BooleanOption(_('Show divorce info'), False)
divs.set_help(_("Whether to show divorce information in the report."))
menu.add_option(category_name, "divs", divs)
dups = BooleanOption(_('Show duplicate trees'), True)
dups.set_help(
_("Whether to show duplicate family trees in the report."))
menu.add_option(category_name, "dups", dups)
def add_menu_options(self, menu):
self.person = BooleanOption(_("Persons"), False)
menu.add_option(_("Option"), "person", self.person)
self.__person_filter = FilterOption(_("Person Filter"), 0)
self.__person_filter.set_help(_("Select filter to restrict people"))
menu.add_option(_("Option"), "person_filter", self.__person_filter)
person_filter_all = GenericFilterFactory("Person")()
person_filter_all.name = _("Entire Database")
person_filter_list = [person_filter_all
] + CustomFilters.get_filters("Person")
self.__person_filter.set_filters(person_filter_list)
self.event = BooleanOption(_("Events"), False)
menu.add_option(_("Option"), "event", self.event)
self.__event_filter = FilterOption(_("Event Filter"), 0)
self.__event_filter.set_help(_("Select filter to restrict events"))
menu.add_option(_("Option"), "event_filter", self.__event_filter)
event_filter_all = GenericFilterFactory("Event")()
event_filter_all.name = _("Entire Database")
event_filter_list = [event_filter_all
] + CustomFilters.get_filters('Event')
self.__event_filter.set_filters(event_filter_list)
self.media = BooleanOption(_("Media"), False)
menu.add_option(_("Option"), "media", self.media)
self.__media_filter = FilterOption(_("Media Filter"), 0)
self.__media_filter.set_help(_("Select filter to restrict medias"))
menu.add_option(_("Option"), "media_filter", self.__media_filter)
media_filter_all = GenericFilterFactory("Media")()
media_filter_all.name = _("Entire Database")
media_filter_list = [media_filter_all
] + CustomFilters.get_filters('Media')
self.__media_filter.set_filters(media_filter_list)
self.no_date = BooleanOption(_("Always private if no date."), False)
self.no_date.set_help(
_("If checked, all objects without a date will "
"also be set private."))
menu.add_option(_("Option"), "no_date", self.no_date)
self.years = NumberOption(_("Years"), 0, 0, 2000)
self.years.set_help(
_("The time range in years from today you want to "
"set objects private.\n"
"'0 years' = remove privacy from all objects."))
menu.add_option(_("Option"), "years", self.years)
def add_menu_options(self, menu):
"""Add the options to the report option menu"""
head = StringOption(_("Heading"), "")
menu.add_option(_("Report Options"), "head", head)
media = MediaOption(_("Media"))
media.set_help(_("Select a media file for this report"))
menu.add_option(_("Report Options"), "mid", media)
self.note = NoteOption(_("Custom note"))
self.note.set_help(_("Select a note for this report"))
menu.add_option(_("Report Options"), "note", self.note)
self.incl_note = BooleanOption(_("Include custom note"), False)
self.incl_note.set_help(_("The custom note will be included"))
menu.add_option(_("Report Options"), "incl_note", self.incl_note)
self.incl_note.connect('value-changed', self.__update_custom_note_opt)
incl_pers = BooleanOption(_("Include referenced people"), False)
incl_pers.set_help(_("Referenced people will be included"))
menu.add_option(_("Report Options"), "incl_pers", incl_pers)
incl_data = BooleanOption(_("Include media data"), False)
incl_data.set_help(_("Tags, notes and attributes will be included"))
menu.add_option(_("Report Options"), "incl_data", incl_data)
media_w = NumberOption(_("Media width"), 100, 10, 100, 10)
media_w.set_help(
_("Maximum media width in % of available "
"page width."))
menu.add_option(_("Report Options"), "media_w", media_w)
media_h = NumberOption(_("Media height"), 100, 10, 100, 10)
media_h.set_help(
_("Maximum media height in % of available page "
"height."))
menu.add_option(_("Report Options"), "media_h", media_h)
def add_menu_options(self, menu):
"""
Add options to the menu for the ancestor report.
"""
category_name = _("Report Options")
self.__pid = PersonOption(_("Center Person"))
self.__pid.set_help(_("The center person for the report"))
menu.add_option(category_name, "pid", self.__pid)
maxgen = NumberOption(_("Generations"), 10, 1, 300)
maxgen.set_help(
_("The number of generations to include in the report"))
menu.add_option(category_name, "maxgen", maxgen)
Filleddigit = NumberOption(_("Filled digit"), 10, 1, 50)
Filleddigit.set_help(
_("The number of digits after comma to include in the report for the percentage of ancestor found at a given generation"
))
menu.add_option(category_name, "Filled_digit", Filleddigit)
Collapsedigit = NumberOption(_("Collapsed digit"), 10, 1, 50)
Collapsedigit.set_help(
_("The number of digits after comma to include in the report for the pedigree Collapse"
))
menu.add_option(category_name, "Collapsed_digit", Collapsedigit)
displayth = BooleanOption(_("Display theoretical"), False)
displayth.set_help(
_("Whether to display the theoretical number of ancestor by generation"
))
menu.add_option(category_name, "Display_theoretical", displayth)
stdoptions.add_name_format_option(menu, category_name)
stdoptions.add_localization_option(menu, category_name)
def add_menu_options(self, menu):
"""Add the menu options to the report dialog"""
category_name = _("Tree Options")
pid = PersonOption(_("Center Person"))
pid.set_help(_("The center person for the tree"))
menu.add_option(category_name, "pid", pid)
max_gen = NumberOption(_("Generations"), 10, 1, 50)
max_gen.set_help(_("The number of generations to include in the tree"))
menu.add_option(category_name, "maxgen", max_gen)
show_captions = BooleanOption(_("Show Mother/Father captions"), False)
show_captions.set_help(_("Show the title of mother or father beside each ancestor's box."))
menu.add_option(category_name, "showcaptions", show_captions)
def add_menu_options(self, menu):
category_name = _("Report Options")
self.__pid = PersonOption(_("Center Person"))
self.__pid.set_help(_("The center person for the report"))
menu.add_option(category_name, "pid", self.__pid)
maxgen = NumberOption(_("Generations"), 10, 1, 100)
maxgen.set_help(_("The number of generations to include in the tree"))
menu.add_option(category_name, "maxgen", maxgen)
images = BooleanOption(_("Include images"), False)
images.set_help(_("Include images of people in the nodes."))
menu.add_option(category_name, "images", images)
locale_opt = stdoptions.add_localization_option(menu, category_name)
def add_menu_options(self, menu):
"""
Add options to the menu for the ancestral fan chart report.
"""
category_name = _("Ancestral Fan Chart Options")
pid = PersonOption(_("Center Person"))
pid.set_help(_("The center person for the report"))
menu.add_option(category_name, "pid", pid)
# We must figure out the value of the first option before we can
# create the EnumeratedListOption
fmt_list = global_name_display.get_name_format()
name_format = EnumeratedListOption(_("Name format"), 0)
name_format.add_item(0, _("Default"))
for num, name, fmt_str, act in fmt_list:
name_format.add_item(num, name)
name_format.set_help(_("Select the format to display names"))
menu.add_option(category_name, "name_format", name_format)
self._maxgen = NumberOption(_("Include Generations"), 10, 1, 100)
self._maxgen.set_help(
_("The number of generations to include in " + "the report"))
menu.add_option(category_name, "maxgen", self._maxgen)
self._maxgen.connect('value-changed', self.validate_gen)
pat_bg = ColorOption(_("Paternal Background Color"), "#ccddff")
pat_bg.set_help(_("RGB-color for paternal box background."))
menu.add_option(category_name, "pat_bg", pat_bg)
mat_bg = ColorOption(_("Maternal Background"), "#ffb2a1")
mat_bg.set_help(_("RGB-color for maternal box background."))
menu.add_option(category_name, "mat_bg", mat_bg)
dest_path = DestinationOption(_("Destination"),
config.get('paths.website-directory'))
dest_path.set_help(_("The destination path for generated files."))
dest_path.set_directory_entry(True)
menu.add_option(category_name, "dest_path", dest_path)
dest_file = StringOption(_("Filename"), "AncestralFanchart.html")
dest_file.set_help(_("The destination file name for html content."))
menu.add_option(category_name, "dest_file", dest_file)
def add_menu_options(self, menu):
self.person = BooleanOption(_("Persons"), False)
menu.add_option(_("Option"), "person", self.person)
self.event = BooleanOption(_("Events"), False)
menu.add_option(_("Option"), "event", self.event)
self.media = BooleanOption(_("Media"), False)
menu.add_option(_("Option"), "media", self.media)
self.no_date = BooleanOption(_("Always private if no date."), False)
self.no_date.set_help(
_("If checked, all objects without a date will "
"also be set private."))
menu.add_option(_("Option"), "no_date", self.no_date)
self.years = NumberOption(_("Years"), 0, 0, 2000)
self.years.set_help(
_("The time range in years from today you want to "
"set objects private.\n"
"'0 years' = remove privacy from all objects."))
menu.add_option(_("Option"), "years", self.years)
def add_menu_options(self, menu):
from functools import partial
# Report Options
category = _("Report Options")
addopt = partial(menu.add_option, category)
pid = PersonOption(_("Center Person"))
pid.set_help(_("The center person for the report"))
addopt("pid", pid)
start_number = NumberOption(_("Sosa-Stradonitz number"), 1, 1, 16384)
start_number.set_help(
_('The Sosa-Stradonitz number of the central person.'))
addopt("initial_sosa", start_number)
stdoptions.add_name_format_option(menu, category)
gen = NumberOption(_("Generations"),10,1,100)
gen.set_help(_("The number of generations to include in the report"))
addopt("gen", gen)
stdoptions.add_private_data_option(menu, category)
pagebbg = BooleanOption(_("Page break between generations"),False)
pagebbg.set_help(
_("Whether to start a new page after each generation."))
addopt("pagebbg", pagebbg)
pageben = BooleanOption(_("Page break before end notes"),False)
pageben.set_help(
_("Whether to start a new page before the end notes."))
addopt("pageben", pageben)
stdoptions.add_localization_option(menu, category)
# Content options
addopt = partial(menu.add_option, _("Content"))
usecall = BooleanOption(_("Use callname for common name"),False)
usecall.set_help(_("Whether to use the call name as the first name."))
addopt("usecall", usecall)
fulldates = BooleanOption(
_("Use full dates instead of only the year"),True)
fulldates.set_help(_("Whether to use full dates instead of just year."))
addopt("fulldates", fulldates)
listc = BooleanOption(_("List children"),True)
listc.set_help(_("Whether to list children."))
addopt("listc", listc)
computeage = BooleanOption(_("Compute death age"),True)
computeage.set_help(_("Whether to compute a person's age at death."))
addopt("computeage", computeage)
omitda = BooleanOption(_("Omit duplicate ancestors"),True)
omitda.set_help(_("Whether to omit duplicate ancestors."))
addopt("omitda", omitda)
verbose = BooleanOption(_("Use Complete Sentences"),True)
verbose.set_help(
_("Whether to use complete sentences or succinct language."))
addopt("verbose", verbose)
desref = BooleanOption(_("Add descendant reference in child list"),True)
desref.set_help(
_("Whether to add descendant references in child list."))
addopt("desref", desref)
# What to include
addopt = partial(menu.add_option, _("Include"))
incnotes = BooleanOption(_("Include notes"),True)
incnotes.set_help(_("Whether to include notes."))
addopt("incnotes", incnotes)
incattrs = BooleanOption(_("Include attributes"),False)
incattrs.set_help(_("Whether to include attributes."))
addopt("incattrs", incattrs)
incphotos = BooleanOption(_("Include Photo/Images from Gallery"),False)
incphotos.set_help(_("Whether to include images."))
addopt("incphotos", incphotos)
incnames = BooleanOption(_("Include alternative names"),False)
incnames.set_help(_("Whether to include other names."))
addopt("incnames", incnames)
incevents = BooleanOption(_("Include events"),False)
incevents.set_help(_("Whether to include events."))
addopt("incevents", incevents)
incaddresses = BooleanOption(_("Include addresses"),False)
incaddresses.set_help(_("Whether to include addresses."))
addopt("incaddresses", incaddresses)
incsources = BooleanOption(_("Include sources"),False)
incsources.set_help(_("Whether to include source references."))
addopt("incsources", incsources)
incsrcnotes = BooleanOption(_("Include sources notes"), False)
incsrcnotes.set_help(_("Whether to include source notes in the "
"Endnotes section. Only works if Include sources is selected."))
addopt("incsrcnotes", incsrcnotes)
# How to handle missing information
addopt = partial(menu.add_option, _("Missing information"))
repplace = BooleanOption(_("Replace missing places with ______"),False)
repplace.set_help(_("Whether to replace missing Places with blanks."))
addopt("repplace", repplace)
repdate = BooleanOption(_("Replace missing dates with ______"),False)
repdate.set_help(_("Whether to replace missing Dates with blanks."))
addopt("repdate", repdate)
def add_menu_options(self, menu):
# ---------------------
category_name = _('Report Options')
add_option = partial(menu.add_option, category_name)
# ---------------------
followpar = BooleanOption(_('Follow parents to determine '
'"family lines"'), True)
followpar.set_help(_('Parents and their ancestors will be '
'considered when determining "family lines".'))
add_option('followpar', followpar)
followchild = BooleanOption(_('Follow children to determine '
'"family lines"'), True)
followchild.set_help(_('Children will be considered when '
'determining "family lines".'))
add_option('followchild', followchild)
remove_extra_people = BooleanOption(_('Try to remove extra '
'people and families'), True)
remove_extra_people.set_help(_('People and families not directly '
'related to people of interest will '
'be removed when determining '
'"family lines".'))
add_option('removeextra', remove_extra_people)
arrow = EnumeratedListOption(_("Arrowhead direction"), 'd')
for i in range( 0, len(_ARROWS) ):
arrow.add_item(_ARROWS[i]["value"], _ARROWS[i]["name"])
arrow.set_help(_("Choose the direction that the arrows point."))
add_option("arrow", arrow)
color = EnumeratedListOption(_("Graph coloring"), "filled")
for i in range(len(_COLORS)):
color.add_item(_COLORS[i]["value"], _COLORS[i]["name"])
color.set_help(_("Males will be shown with blue, females "
"with red, unless otherwise set above for filled. "
"If the sex of an individual "
"is unknown it will be shown with gray."))
add_option("color", color)
roundedcorners = EnumeratedListOption(_("Rounded corners"), '')
for i in range( 0, len(_CORNERS) ):
roundedcorners.add_item(_CORNERS[i]["value"], _CORNERS[i]["name"])
roundedcorners.set_help(_("Use rounded corners e.g. to differentiate "
"between women and men."))
add_option("useroundedcorners", roundedcorners)
stdoptions.add_gramps_id_option(menu, category_name, ownline=True)
# ---------------------
category_name = _('Report Options (2)')
add_option = partial(menu.add_option, category_name)
# ---------------------
stdoptions.add_name_format_option(menu, category_name)
stdoptions.add_private_data_option(menu, category_name, default=False)
stdoptions.add_living_people_option(menu, category_name)
locale_opt = stdoptions.add_localization_option(menu, category_name)
stdoptions.add_date_format_option(menu, category_name, locale_opt)
# --------------------------------
add_option = partial(menu.add_option, _('People of Interest'))
# --------------------------------
person_list = PersonListOption(_('People of interest'))
person_list.set_help(_('People of interest are used as a starting '
'point when determining "family lines".'))
add_option('gidlist', person_list)
self.limit_parents = BooleanOption(_('Limit the number of ancestors'),
False)
self.limit_parents.set_help(_('Whether to '
'limit the number of ancestors.'))
add_option('limitparents', self.limit_parents)
self.limit_parents.connect('value-changed', self.limit_changed)
self.max_parents = NumberOption('', 50, 10, 9999)
self.max_parents.set_help(_('The maximum number '
'of ancestors to include.'))
add_option('maxparents', self.max_parents)
self.limit_children = BooleanOption(_('Limit the number '
'of descendants'),
False)
self.limit_children.set_help(_('Whether to '
'limit the number of descendants.'))
add_option('limitchildren', self.limit_children)
self.limit_children.connect('value-changed', self.limit_changed)
self.max_children = NumberOption('', 50, 10, 9999)
self.max_children.set_help(_('The maximum number '
'of descendants to include.'))
add_option('maxchildren', self.max_children)
# --------------------
category_name = _('Include')
add_option = partial(menu.add_option, category_name)
# --------------------
self.include_dates = BooleanOption(_('Include dates'), True)
self.include_dates.set_help(_('Whether to include dates for people '
'and families.'))
add_option('incdates', self.include_dates)
self.include_dates.connect('value-changed', self.include_dates_changed)
self.justyears = BooleanOption(_("Limit dates to years only"), False)
self.justyears.set_help(_("Prints just dates' year, neither "
"month or day nor date approximation "
"or interval are shown."))
add_option("justyears", self.justyears)
include_places = BooleanOption(_('Include places'), True)
include_places.set_help(_('Whether to include placenames for people '
'and families.'))
add_option('incplaces', include_places)
include_num_children = BooleanOption(_('Include the number of '
'children'), True)
include_num_children.set_help(_('Whether to include the number of '
'children for families with more '
'than 1 child.'))
add_option('incchildcnt', include_num_children)
self.include_images = BooleanOption(_('Include '
'thumbnail images of people'),
True)
self.include_images.set_help(_('Whether to '
'include thumbnail images of people.'))
add_option('incimages', self.include_images)
self.include_images.connect('value-changed', self.images_changed)
self.image_location = EnumeratedListOption(_('Thumbnail location'), 0)
self.image_location.add_item(0, _('Above the name'))
self.image_location.add_item(1, _('Beside the name'))
self.image_location.set_help(_('Where the thumbnail image '
'should appear relative to the name'))
add_option('imageonside', self.image_location)
self.image_size = EnumeratedListOption(_('Thumbnail size'), SIZE_NORMAL)
self.image_size.add_item(SIZE_NORMAL, _('Normal'))
self.image_size.add_item(SIZE_LARGE, _('Large'))
self.image_size.set_help(_('Size of the thumbnail image'))
add_option('imagesize', self.image_size)
# ----------------------------
add_option = partial(menu.add_option, _('Family Colors'))
# ----------------------------
surname_color = SurnameColorOption(_('Family colors'))
surname_color.set_help(_('Colors to use for various family lines.'))
add_option('surnamecolors', surname_color)
# -------------------------
add_option = partial(menu.add_option, _('Individuals'))
# -------------------------
color_males = ColorOption(_('Males'), '#e0e0ff')
color_males.set_help(_('The color to use to display men.'))
add_option('colormales', color_males)
color_females = ColorOption(_('Females'), '#ffe0e0')
color_females.set_help(_('The color to use to display women.'))
add_option('colorfemales', color_females)
color_unknown = ColorOption(_('Unknown'), '#e0e0e0')
color_unknown.set_help(_('The color to use '
'when the gender is unknown.'))
add_option('colorunknown', color_unknown)
color_family = ColorOption(_('Families'), '#ffffe0')
color_family.set_help(_('The color to use to display families.'))
add_option('colorfamilies', color_family)
self.limit_changed()
self.images_changed()
def add_menu_options(self, menu):
"""
Add options to the menu for the statistics report.
"""
################################
category_name = _("Report Options")
add_option = partial(menu.add_option, category_name)
################################
self.__filter = FilterOption(_("Filter"), 0)
self.__filter.set_help(_("Determines what people are included "
"in the report."))
add_option("filter", self.__filter)
self.__filter.connect('value-changed', self.__filter_changed)
self.__pid = PersonOption(_("Filter Person"))
self.__pid.set_help(_("The center person for the filter."))
menu.add_option(category_name, "pid", self.__pid)
self.__pid.connect('value-changed', self.__update_filters)
sortby = EnumeratedListOption(_('Sort chart items by'),
_options.SORT_VALUE)
for item_idx in range(len(_options.opt_sorts)):
item = _options.opt_sorts[item_idx]
sortby.add_item(item_idx, item[2])
sortby.set_help(_("Select how the statistical data is sorted."))
add_option("sortby", sortby)
reverse = BooleanOption(_("Sort in reverse order"), False)
reverse.set_help(_("Check to reverse the sorting order."))
add_option("reverse", reverse)
this_year = time.localtime()[0]
year_from = NumberOption(_("People Born After"),
1700, 1, this_year)
year_from.set_help(_("Birth year from which to include people."))
add_option("year_from", year_from)
year_to = NumberOption(_("People Born Before"),
this_year, 1, this_year)
year_to.set_help(_("Birth year until which to include people"))
add_option("year_to", year_to)
no_years = BooleanOption(_("Include people without known birth years"),
False)
no_years.set_help(_("Whether to include people without "
"known birth years."))
add_option("no_years", no_years)
gender = EnumeratedListOption(_('Genders included'),
Person.UNKNOWN)
for item_idx in range(len(_options.opt_genders)):
item = _options.opt_genders[item_idx]
gender.add_item(item[0], item[2])
gender.set_help(_("Select which genders are included into "
"statistics."))
add_option("gender", gender)
bar_items = NumberOption(_("Max. items for a pie"), 8, 0, 20)
bar_items.set_help(_("With fewer items pie chart and legend will be "
"used instead of a bar chart."))
add_option("bar_items", bar_items)
################################
category_name = _("Report Options (2)")
add_option = partial(menu.add_option, category_name)
################################
self._nf = stdoptions.add_name_format_option(menu, category_name)
self._nf.connect('value-changed', self.__update_filters)
self.__update_filters()
stdoptions.add_private_data_option(menu, category_name)
stdoptions.add_living_people_option(menu, category_name)
stdoptions.add_localization_option(menu, category_name)
################################
# List of available charts on separate option tabs
################################
idx = 0
third = (len(_Extract.extractors) + 1) // 3
chart_types = []
for (chart_opt, ctuple) in _Extract.extractors.items():
chart_types.append((_(ctuple[1]), chart_opt, ctuple))
sorted_chart_types = sorted(chart_types,
key=lambda x: glocale.sort_key(x[0]))
for (translated_option_name, opt_name, ctuple) in sorted_chart_types:
if idx >= (third * 2):
category_name = _("Charts 3")
elif idx >= third:
category_name = _("Charts 2")
else:
category_name = _("Charts 1")
opt = BooleanOption(translated_option_name, False)
opt.set_help(_("Include charts with indicated data."))
menu.add_option(category_name, opt_name, opt)
idx += 1
# Enable a couple of charts by default
menu.get_option_by_name("data_gender").set_value(True)
menu.get_option_by_name("data_ccount").set_value(True)
menu.get_option_by_name("data_bmonth").set_value(True)
