class InfoDialog(object):
"""
Non modal dialog to show selectable info in a scrolled window
"""
def __init__(self, msg1, infotext, parent=None, monospaced=False):
self.xml = Glade(toplevel='infodialog')
self.top = self.xml.toplevel
self.top.set_icon(ICON)
self.top.set_title("%s - Gramps" % msg1)
label = self.xml.get_object('toplabel')
label.set_text('<span weight="bold" size="larger">%s</span>' % msg1)
label.set_use_markup(True)
infoview = self.xml.get_object('infoview')
infobuffer = gtk.TextBuffer()
infobuffer.set_text(infotext)
if monospaced:
startiter, enditer = infobuffer.get_bounds()
tag = infobuffer.create_tag(family="Monospace")
infobuffer.apply_tag(tag, startiter, enditer)
infoview.set_buffer(infobuffer)
if parent:
self.top.set_transient_for(parent)
self.top.connect('response', self.destroy)
self.top.show()
def destroy(self, dialog, response_id):
#no matter how it finishes, destroy dialog
dialog.destroy()
def __build_window(self):
"""Build the window from Glade.
"""
from glade import Glade
glade_xml = Glade()
self._window = glade_xml.toplevel
#self._window.set_transient_for(parent)
# remember active widgets for future use
self._swin = glade_xml.get_object('swin')
self._drawing_area = glade_xml.get_object('drawingarea')
self._first_button = glade_xml.get_object('first')
self._prev_button = glade_xml.get_object('prev')
self._next_button = glade_xml.get_object('next')
self._last_button = glade_xml.get_object('last')
self._pages_entry = glade_xml.get_object('entry')
self._pages_label = glade_xml.get_object('label')
self._zoom_fit_width_button = glade_xml.get_object('zoom_fit_width')
self._zoom_fit_width_button.set_stock_id('gramps-zoom-fit-width')
self._zoom_best_fit_button = glade_xml.get_object('zoom_best_fit')
self._zoom_best_fit_button.set_stock_id('gramps-zoom-best-fit')
self._zoom_in_button = glade_xml.get_object('zoom_in')
self._zoom_in_button.set_stock_id('gramps-zoom-in')
self._zoom_out_button = glade_xml.get_object('zoom_out')
self._zoom_out_button.set_stock_id('gramps-zoom-out')
# connect the signals
glade_xml.connect_signals(self)
class QuestionDialog2(object):
def __init__(self, msg1, msg2, label_msg1, label_msg2, parent=None):
self.xml = Glade(toplevel='questiondialog')
self.top = self.xml.toplevel
self.top.set_icon(ICON)
self.top.set_title("%s - Gramps" % msg1)
label1 = self.xml.get_object('qd_label1')
label1.set_text('<span weight="bold" size="larger">%s</span>' % msg1)
label1.set_use_markup(True)
label2 = self.xml.get_object('qd_label2')
# see https://github.com/emesene/emesene/issues/723
label2.connect('activate-link', on_activate_link)
label2.set_text(msg2)
label2.set_use_markup(True)
self.xml.get_object('okbutton').set_label(label_msg1)
self.xml.get_object('okbutton').set_use_underline(True)
self.xml.get_object('no').set_label(label_msg2)
self.xml.get_object('no').set_use_underline(True)
if parent:
self.top.set_transient_for(parent)
self.top.show()
def run(self):
response = self.top.run()
self.top.destroy()
return (response == gtk.RESPONSE_ACCEPT)
class SaveDialog(object):
def __init__(self, msg1, msg2, task1, task2, parent=None):
self.xml = Glade(toplevel='savedialog')
self.top = self.xml.toplevel
self.top.set_icon(ICON)
self.top.set_title("%s - Gramps" % msg1)
self.dontask = self.xml.get_object('dontask')
self.task1 = task1
self.task2 = task2
label1 = self.xml.get_object('sd_label1')
label1.set_text('<span weight="bold" size="larger">%s</span>' % msg1)
label1.set_use_markup(True)
label2 = self.xml.get_object('sd_label2')
label2.set_text(msg2)
label2.set_use_markup(True)
if parent:
self.top.set_transient_for(parent)
self.top.show()
response = self.top.run()
if response == gtk.RESPONSE_NO:
self.task1()
elif response == gtk.RESPONSE_YES:
self.task2()
config.set('interface.dont-ask', self.dontask.get_active())
self.top.destroy()
class QuestionDialog(object):
def __init__(self, msg1, msg2, label, task, parent=None):
self.xml = Glade(toplevel='questiondialog')
self.top = self.xml.toplevel
self.top.set_icon(ICON)
self.top.set_title("%s - Gramps" % msg1)
label1 = self.xml.get_object('qd_label1')
label1.set_text('<span weight="bold" size="larger">%s</span>' % msg1)
label1.set_use_markup(True)
label2 = self.xml.get_object('qd_label2')
label2.set_text(msg2)
label2.set_use_markup(True)
self.xml.get_object('okbutton').set_label(label)
if parent:
self.top.set_transient_for(parent)
self.top.show()
response = self.top.run()
self.top.destroy()
if response == gtk.RESPONSE_ACCEPT:
task()
class SoundGen(tool.Tool, ManagedWindow.ManagedWindow):
def __init__(self, dbstate, uistate, options_class, name, callback=None):
self.label = _('SoundEx code generator')
tool.Tool.__init__(self, dbstate, options_class, name)
ManagedWindow.ManagedWindow.__init__(self, uistate, [], self.__class__)
self.glade = Glade()
self.glade.connect_signals({
"destroy_passed_object": self.close,
"on_help_clicked": self.on_help_clicked,
"on_delete_event": self.close,
})
window = self.glade.toplevel
self.set_window(window, self.glade.get_object('title'), self.label)
self.value = self.glade.get_object("value")
self.autocomp = self.glade.get_object("name_list")
self.name = self.autocomp.child
self.name.connect('changed', self.on_apply_clicked)
names = []
person = None
for person in self.db.iter_people():
lastname = person.get_primary_name().get_surname()
if lastname not in names:
names.append(lastname)
names.sort()
AutoComp.fill_combo(self.autocomp, names)
if person:
n = person.get_primary_name().get_surname()
self.name.set_text(n)
try:
se_text = soundex.soundex(n)
except UnicodeEncodeError:
se_text = soundex.soundex('')
self.value.set_text(se_text)
else:
self.name.set_text("")
self.show()
def on_help_clicked(self, obj):
"""Display the relevant portion of GRAMPS manual"""
GrampsDisplay.help(WIKI_HELP_PAGE, WIKI_HELP_SEC)
def build_menu_names(self, obj):
return (self.label, None)
def on_apply_clicked(self, obj):
try:
se_text = soundex.soundex(unicode(obj.get_text()))
except UnicodeEncodeError:
se_text = soundex.soundex('')
self.value.set_text(se_text)
class MissingMediaDialog(object):
def __init__(self, msg1, msg2, task1, task2, task3, parent=None):
self.xml = Glade(toplevel='missmediadialog')
self.top = self.xml.toplevel
self.top.set_icon(ICON)
self.top.set_title("%s - Gramps" % msg1)
self.task1 = task1
self.task2 = task2
self.task3 = task3
label1 = self.xml.get_object('label4')
label1.set_text('<span weight="bold" size="larger">%s</span>' % msg1)
label1.set_use_markup(True)
label2 = self.xml.get_object('label3')
label2.set_text(msg2)
label2.set_use_markup(True)
check_button = self.xml.get_object('use_always')
if parent:
self.top.set_transient_for(parent)
self.top.show()
self.top.connect('delete_event', self.warn)
response = gtk.RESPONSE_DELETE_EVENT
# Need some magic here, because an attempt to close the dialog
# with the X button not only emits the 'delete_event' signal
# but also exits with the RESPONSE_DELETE_EVENT
while response == gtk.RESPONSE_DELETE_EVENT:
response = self.top.run()
if response == 1:
self.task1()
elif response == 2:
self.task2()
elif response == 3:
self.task3()
if check_button.get_active():
self.default_action = response
else:
self.default_action = 0
self.top.destroy()
def warn(self, obj, obj2):
WarningDialog(
_("Attempt to force closing the dialog"),
_("Please do not force closing this important dialog.\n"
"Instead select one of the available options"), self.top)
return True
def display(self):
# get the main window from glade
topDialog = Glade()
# set gramps style title for the window
window = topDialog.toplevel
self.set_window(window, topDialog.get_object("title"),
_("Database Owner Editor"))
# move help button to the left side
action_area = topDialog.get_object("action_area")
help_button = topDialog.get_object("help_button")
action_area.set_child_secondary(help_button, True)
# connect signals
topDialog.connect_signals({
"on_ok_button_clicked": self.on_ok_button_clicked,
"on_cancel_button_clicked": self.close,
"on_help_button_clicked": self.on_help_button_clicked,
"on_eventbox_button_press_event": self.on_button_press_event,
"on_menu_activate": self.on_menu_activate,
"on_delete_event": self.close,
})
# fetch the popup menu
self.menu = topDialog.get_object("popup_menu")
#topDialog.connect_signals({"on_menu_activate": self.on_menu_activate})
# get current db owner and attach it to the entries of the window
self.owner = self.db.get_researcher()
self.entries = []
entry = [
("name", self.owner.set_name, self.owner.get_name),
("address", self.owner.set_address, self.owner.get_address),
("locality", self.owner.set_locality, self.owner.get_locality),
("city", self.owner.set_city, self.owner.get_city),
("state", self.owner.set_state, self.owner.get_state),
("country", self.owner.set_country, self.owner.get_country),
("zip", self.owner.set_postal_code, self.owner.get_postal_code),
("phone", self.owner.set_phone, self.owner.get_phone),
("email", self.owner.set_email, self.owner.get_email),
]
for (name, set_fn, get_fn) in entry:
self.entries.append(
MonitoredEntry(topDialog.get_object(name), set_fn, get_fn,
self.db.readonly))
# ok, let's see what we've done
self.show()
class Eval(tool.Tool,ManagedWindow.ManagedWindow):
def __init__(self,dbstate, uistate, options_class, name, callback=None):
self.title = _("Python evaluation window")
tool.Tool.__init__(self,dbstate, options_class, name)
ManagedWindow.ManagedWindow.__init__(self,uistate,[],self.__class__)
self.glade = Glade()
window = self.glade.toplevel
self.dbuf = self.glade.get_object("display").get_buffer()
self.ebuf = self.glade.get_object("ebuf").get_buffer()
self.error = self.glade.get_object("error").get_buffer()
self.dbstate = dbstate
self.glade.connect_signals({
"on_apply_clicked" : self.apply_clicked,
"on_close_clicked" : self.close,
"on_clear_clicked" : self.clear_clicked,
"on_delete_event" : self.close,
})
self.set_window(window,self.glade.get_object('title'),self.title)
self.show()
def build_menu_names(self, obj):
return (self.title,None)
def apply_clicked(self, obj):
text = unicode(self.ebuf.get_text(self.ebuf.get_start_iter(),
self.ebuf.get_end_iter(),False))
outtext = cStringIO.StringIO()
errtext = cStringIO.StringIO()
sys.stdout = outtext
sys.stderr = errtext
try:
exec(text)
except:
traceback.print_exc()
self.dbuf.set_text(outtext.getvalue())
self.error.set_text(errtext.getvalue())
sys.stdout = sys.__stdout__
sys.stderr = sys.__stderr__
def clear_clicked(self, obj):
self.dbuf.set_text("")
self.ebuf.set_text("")
self.error.set_text("")
def __init__(self,default_metric,default_name,default_orientation,
margins=[2.54,2.54,2.54,2.54], custom=[29.7,21.0]):
gtk.HBox.__init__(self)
glade_xml = Glade()
self.paper_table = glade_xml.get_object('paper_table')
# get all the widgets
widgets = ('pwidth', 'pheight', 'lmargin', 'rmargin', 'tmargin',
'bmargin', 'lunits1', 'lunits2', 'lunits3', 'lunits4',
'lunits5', 'lunits6', 'metric')
for w in widgets:
setattr(self, w, glade_xml.get_object(w))
# insert custom widgets
self.papersize_menu = PaperComboBox(default_name)
self.orientation_menu = OrientationComboBox(default_orientation)
self.metric.set_active(default_metric)
# connect all widgets
format_table = glade_xml.get_object('format_table')
format_table.attach(self.papersize_menu, 1, 3, 0, 1,
yoptions=gtk.SHRINK)
format_table.attach(self.orientation_menu, 1, 3, 3, 4,
yoptions=gtk.SHRINK)
# connect signals
self.papersize_menu.connect('changed',self.size_changed)
self.metric.connect('toggled',self.units_changed)
# set initial values
self.paper_unit = 'cm'
self.paper_unit_multiplier = 1.0
self.pwidth.set_text("%.2f" % custom[0])
self.pheight.set_text("%.2f" % custom[1])
self.lmargin.set_text("%.2f" % margins[0])
self.rmargin.set_text("%.2f" % margins[1])
self.tmargin.set_text("%.2f" % margins[2])
self.bmargin.set_text("%.2f" % margins[3])
self.paper_table.show_all()
self.paper_table.reparent(self)
self.units_changed(self.metric)
self.size_changed(None)
class EditUrl(EditSecondary):
def __init__(self, dbstate, uistate, track, name, url, callback):
EditSecondary.__init__(self, dbstate, uistate, track, url, callback)
def _local_init(self):
self.width_key = 'interface.url-width'
self.height_key = 'interface.url-height'
self.top = Glade()
self.jump = self.top.get_object('jump')
self.set_window(self.top.toplevel, self.top.get_object("title"),
_('Internet Address Editor'))
def _connect_signals(self):
self.jump.connect('clicked', self.jump_to)
self.define_cancel_button(self.top.get_object('button125'))
self.define_ok_button(self.top.get_object('button124'), self.save)
self.define_help_button(self.top.get_object('button130'))
def jump_to(self, obj):
if self.obj.get_path():
import GrampsDisplay
GrampsDisplay.url(self.obj.get_path())
def _setup_fields(self):
self.des = MonitoredEntry(self.top.get_object("url_des"),
self.obj.set_description,
self.obj.get_description, self.db.readonly)
self.addr = MonitoredEntry(self.top.get_object("url_addr"),
self.obj.set_path, self.obj.get_path,
self.db.readonly)
self.priv = PrivacyButton(self.top.get_object("priv"), self.obj,
self.db.readonly)
self.type_sel = MonitoredDataType(self.top.get_object("type"),
self.obj.set_type, self.obj.get_type,
self.db.readonly)
def build_menu_names(self, obj):
etitle = _('Internet Address Editor')
return (etitle, etitle)
def save(self, *obj):
self.callback(self.obj)
self.close()
def __init__(self, state, uistate, track, handle):
xml = Glade()
top = xml.toplevel
self.dbstate = state
ManagedWindow.ManagedWindow.__init__(self, uistate, track, self)
self.person = self.dbstate.db.get_person_from_handle(handle)
self.parent_list = self.person.get_parent_family_handle_list()
self.family_list = self.person.get_family_handle_list()
penable = len(self.parent_list) > 1
fenable = len(self.family_list) > 1
self.set_window(top, None, _("Reorder Relationships"))
self.ptree = xml.get_object('ptree')
self.pmodel = ListModel.ListModel(self.ptree, PARENT_TITLES)
self.ftree = xml.get_object('ftree')
self.fmodel = ListModel.ListModel(self.ftree, FAMILY_TITLES)
xml.get_object('ok').connect('clicked', self.ok_clicked)
xml.get_object('cancel').connect('clicked', self.cancel_clicked)
fup = xml.get_object('fup')
fup.connect('clicked', self.fup_clicked)
fup.set_sensitive(fenable)
fdown = xml.get_object('fdown')
fdown.connect('clicked', self.fdown_clicked)
fdown.set_sensitive(fenable)
pup = xml.get_object('pup')
pup.connect('clicked', self.pup_clicked)
pup.set_sensitive(penable)
pdown = xml.get_object('pdown')
pdown.connect('clicked', self.pdown_clicked)
pdown.set_sensitive(penable)
self.fill_data()
self.show()
def check_in(dbase, filename, callback, cursor_func=None):
"""
Checks in the specified file into RCS
"""
init = ["rcs", '-x,v', '-i', '-U', '-q', '-t-"Gramps database"']
ci_cmd = ["ci", '-x,v', "-q", "-f"]
archive_name = filename + ",v"
glade = Glade(toplevel='comment')
top = glade.toplevel
text = glade.get_object('description')
top.run()
comment = text.get_text()
top.destroy()
if not os.path.isfile(archive_name):
cmd = init + [archive_name]
proc = subprocess.Popen(cmd, stderr=subprocess.PIPE)
status = proc.wait()
message = "\n".join(proc.stderr.readlines())
proc.stderr.close()
del proc
if status != 0:
ErrorDialog(
_("Archiving failed"),
_("An attempt to create the archive failed "
"with the following message:\n\n%s") % message)
if cursor_func:
cursor_func(_("Creating data to be archived..."))
plugin_manager = GuiPluginManager.get_instance()
for plugin in plugin_manager.get_export_plugins():
if plugin.get_extension() == "gramps":
export_function = plugin.get_export_function()
export_function(dbase, filename, None, callback)
if cursor_func:
cursor_func(_("Saving archive..."))
cmd = ci_cmd + ['-m%s' % comment, filename, archive_name]
proc = subprocess.Popen(cmd, stderr=subprocess.PIPE)
status = proc.wait()
message = "\n".join(proc.stderr.readlines())
proc.stderr.close()
del proc
if status != 0:
ErrorDialog(
_("Archiving failed"),
_("An attempt to archive the data failed "
"with the following message:\n\n%s") % message)
def importData(database, filename, callback=None):
"""
Try to handle ANSEL encoded files that are not really ANSEL encoded
"""
if DbMixin not in database.__class__.__bases__:
database.__class__.__bases__ = (DbMixin,) + \
database.__class__.__bases__
try:
ifile = open(filename, "r")
except IOError:
return
ansel = False
gramps = False
for index in range(50):
line = ifile.readline().split()
if len(line) == 0:
break
if len(line) > 2 and line[1][0:4] == 'CHAR' and line[2] == "ANSEL":
ansel = True
if len(line) > 2 and line[1][0:4] == 'SOUR' and line[2] == "GRAMPS":
gramps = True
ifile.close()
if not gramps and ansel:
top = Glade()
code = top.get_object('codeset')
code.set_active(0)
dialog = top.toplevel
dialog.run()
enc = ['ANSEL', 'ANSEL', 'ANSI', 'ASCII', 'UTF-8']
code_set = enc[code.get_active()]
dialog.destroy()
else:
code_set = ""
assert (isinstance(code_set, basestring))
try:
ifile = open(filename, "rU")
stage_one = libgedcom.GedcomStageOne(ifile)
stage_one.parse()
if code_set:
stage_one.set_encoding(code_set)
ifile.seek(0)
gedparse = libgedcom.GedcomParser(
database, ifile, filename, callback, stage_one,
config.get('preferences.default-source'))
except IOError, msg:
ErrorDialog(_("%s could not be opened\n") % filename, str(msg))
return
def __init__(self, uistate):
ManagedWindow.ManagedWindow.__init__(self, uistate, [], self)
xml = Glade()
window = xml.toplevel
self.set_window(window,
xml.get_object("title"),
_("Tip of the Day"),
_("Tip of the Day"))
self.tip = xml.get_object("tip")
self.use = xml.get_object('usetips')
self.use.set_active(config.get('behavior.use-tips'))
image = xml.get_object('image')
image.set_from_file(os.path.join(const.IMAGE_DIR, 'splash.jpg'))
next = xml.get_object('next')
next.connect("clicked", self.next_tip_cb)
close = xml.get_object('close')
close.connect("clicked", self.close_cb)
try:
tparser = TipParser()
except (IOError,ExpatError), e:
self.close()
ErrorDialog(
_("Failed to display tip of the day"),
_("Unable to read the tips from external file.\n\n%s")%e)
return
class OptionDialog(object):
def __init__(self,
msg1,
msg2,
btnmsg1,
task1,
btnmsg2,
task2,
parent=None):
self.xml = Glade(toplevel='optiondialog')
self.top = self.xml.toplevel
self.top.set_icon(ICON)
self.top.set_title("%s - Gramps" % msg1)
label1 = self.xml.get_object('od_label1')
label1.set_text('<span weight="bold" size="larger">%s</span>' % msg1)
label1.set_use_markup(True)
label2 = self.xml.get_object('od_label2')
label2.set_text(msg2)
label2.set_use_markup(True)
self.xml.get_object('option1').set_label(btnmsg1)
self.xml.get_object('option2').set_label(btnmsg2)
if parent:
self.top.set_transient_for(parent)
self.top.show()
self.response = self.top.run()
if self.response == gtk.RESPONSE_NO:
if task1:
task1()
else:
if task2:
task2()
self.top.destroy()
def get_response(self):
return self.response
def run(self):
top = Glade(toplevel="mergecitations")
# retrieve options
fields = self.options.handler.options_dict['fields']
dont_merge_notes = self.options.handler.options_dict['dont_merge_notes']
my_menu = gtk.ListStore(str, object)
for val in sorted(_val2label):
my_menu.append([_val2label[val], val])
self.notes_obj = top.get_object("notes")
self.notes_obj.set_active(dont_merge_notes)
self.notes_obj.show()
self.menu = top.get_object("menu")
self.menu.set_model(my_menu)
self.menu.set_active(fields)
window = top.toplevel
window.show()
# self.set_window(window, top.get_object('title'),
# _('Merge citations'))
self.set_window(window, top.get_object('title2'),
_("Notes, media objects and data-items of matching "
"citations will be combined."))
top.connect_signals({
"on_merge_ok_clicked" : self.on_merge_ok_clicked,
"destroy_passed_object" : self.cancel,
"on_help_clicked" : self.on_help_clicked,
"on_delete_merge_event" : self.close,
"on_delete_event" : self.close,
})
self.show()
class MessageHideDialog(object):
def __init__(self, title, message, key, parent=None):
self.xml = Glade(toplevel='hidedialog')
self.top = self.xml.toplevel
self.top.set_icon(ICON)
self.top.set_title("%s - Gramps" % title)
dont_show = self.xml.get_object('dont_show')
dont_show.set_active(config.get(key))
title_label = self.xml.get_object('title')
title_label.set_text('<span size="larger" weight="bold">%s</span>' %
title)
title_label.set_use_markup(True)
self.xml.get_object('message').set_text(message)
dont_show.connect('toggled', self.update_checkbox, key)
self.top.run()
self.top.destroy()
def update_checkbox(self, obj, constant):
config.set(constant, obj.get_active())
config.save()
class WarnHandler(RotateHandler):
def __init__(self, capacity, button):
RotateHandler.__init__(self, capacity)
self.setLevel(logging.WARN)
self.button = button
button.on_clicked(self.display)
self.timer = None
self.last_line = '-1'
def emit(self, record):
if self.timer is None:
#check every 3 minutes if warn button can disappear
self.timer = gobject.timeout_add(3 * 60 * 1000, self._check_clear)
RotateHandler.emit(self, record)
self.button.show()
def _check_clear(self):
new_last_line = self.get_buffer()[-1]
if self.last_line == new_last_line:
#buffer has not changed for 3 minutes, let's clear it:
self._clear()
return False
else:
self.last_line = new_last_line
return True
def _clear(self):
self.button.hide()
self.set_capacity(self._capacity)
self.last_line = '-1'
self.timer = None
def display(self, obj):
obj.hide()
self.glade = Glade()
top = self.glade.toplevel
msg = self.glade.get_object('msg')
buf = msg.get_buffer()
for i in self.get_formatted_log():
buf.insert_at_cursor(i + '\n')
top.run()
top.destroy()
class DesBrowse(tool.ActivePersonTool, ManagedWindow.ManagedWindow):
def __init__(self, dbstate, uistate, options_class, name, callback=None):
tool.ActivePersonTool.__init__(self, dbstate, uistate, options_class,
name)
if self.fail:
return
self.dbstate = dbstate
active_handle = uistate.get_active('Person')
self.active = dbstate.db.get_person_from_handle(active_handle)
self.callback = callback
self.active_name = _("Descendant Browser: %s") % (
name_displayer.display(self.active)
)
ManagedWindow.ManagedWindow.__init__(self, uistate, [], self)
self.glade = Glade()
self.glade.connect_signals({
"destroy_passed_object" : self.close,
"on_help_clicked" : self.on_help_clicked,
"on_delete_event" : self.close,
})
window = self.glade.toplevel
self.set_window(window,self.glade.get_object('title'),
self.active_name)
self.tree = self.glade.get_object("tree1")
col = gtk.TreeViewColumn('',gtk.CellRendererText(),text=0)
self.tree.append_column(col)
self.tree.set_rules_hint(True)
self.tree.set_headers_visible(False)
self.tree.connect('event',self.button_press_event)
self.make_new_model()
self.show()
def build_menu_names(self, obj):
return (self.active_name,_("Descendant Browser tool"))
def make_new_model(self):
self.model = gtk.TreeStore(str, object)
self.tree.set_model(self.model)
self.add_to_tree(None, None, self.active.get_handle())
self.tree.expand_all()
def on_help_clicked(self, obj):
"""Display the relevant portion of GRAMPS manual"""
GrampsDisplay.help(webpage=WIKI_HELP_PAGE, section=WIKI_HELP_SEC)
def add_to_tree(self, parent_id, sib_id, person_handle):
item_id = self.model.insert_after(parent_id, sib_id)
person = self.db.get_person_from_handle(person_handle)
self.model.set(item_id, 0, name_displayer.display(person))
self.model.set(item_id, 1, person_handle)
prev_id = None
for family_handle in person.get_family_handle_list():
family = self.db.get_family_from_handle(family_handle)
for child_ref in family.get_child_ref_list():
prev_id = self.add_to_tree(item_id, prev_id, child_ref.ref)
return item_id
def button_press_event(self, obj,event):
if event.type == gtk.gdk._2BUTTON_PRESS and event.button == 1:
store, node = self.tree.get_selection().get_selected()
if node:
person_handle = store.get_value(node, 1)
person = self.db.get_person_from_handle(person_handle)
EditPerson(self.dbstate, self.uistate, self.track, person,
self.this_callback)
def this_callback(self, obj):
self.callback()
self.make_new_model()
class EditChildRef(EditSecondary):
"""
Displays a dialog that allows the user to edit an address.
"""
def __init__(self, name, dbstate, uistate, track, childref, callback):
"""
Displays the dialog box.
parent - The class that called the ChildRef editor.
addr - The address that is to be edited
"""
self.name = name
EditSecondary.__init__(self, dbstate, uistate, track, childref,
callback)
def _local_init(self):
self.width_key = 'interface.child-ref-width'
self.height_key = 'interface.child-ref-height'
self.top = Glade()
self.set_window(self.top.toplevel, self.top.get_object("title"),
self.name, _('Child Reference Editor'))
self.ok_button = self.top.get_object('ok')
self.edit_button = self.top.get_object('edit')
self.name_label = self.top.get_object('name')
self.name_label.set_text(self.name)
def _setup_fields(self):
self.frel = MonitoredDataType(self.top.get_object('frel'),
self.obj.set_father_relation,
self.obj.get_father_relation,
self.db.readonly,
self.db.get_child_reference_types())
self.mrel = MonitoredDataType(self.top.get_object('mrel'),
self.obj.set_mother_relation,
self.obj.get_mother_relation,
self.db.readonly,
self.db.get_child_reference_types())
self.priv = PrivacyButton(self.top.get_object("private"), self.obj,
self.db.readonly)
def _connect_signals(self):
self.define_help_button(self.top.get_object('help'))
self.define_cancel_button(self.top.get_object('cancel'))
self.define_ok_button(self.ok_button, self.save)
self.edit_button.connect('button-press-event', self.edit_child)
self.edit_button.connect('key-press-event', self.edit_child)
def _connect_db_signals(self):
"""
Connect any signals that need to be connected.
Called by the init routine of the base class (_EditPrimary).
"""
self._add_db_signal('person-update', self.person_change)
self._add_db_signal('person-rebuild', self.close)
self._add_db_signal('person-delete', self.check_for_close)
def _create_tabbed_pages(self):
"""
Create the notebook tabs and inserts them into the main
window.
"""
notebook = gtk.Notebook()
self.srcref_list = CitationEmbedList(self.dbstate, self.uistate,
self.track,
self.obj.get_citation_list())
self._add_tab(notebook, self.srcref_list)
self.track_ref_for_deletion("srcref_list")
self.note_tab = NoteTab(self.dbstate,
self.uistate,
self.track,
self.obj.get_note_list(),
notetype=NoteType.CHILDREF)
self._add_tab(notebook, self.note_tab)
self.track_ref_for_deletion("note_tab")
self._setup_notebook_tabs(notebook)
notebook.show_all()
self.top.get_object('vbox').pack_start(notebook, True)
def _post_init(self):
self.ok_button.grab_focus()
def build_menu_names(self, obj):
return (_('Child Reference'), _('Child Reference Editor'))
def edit_child(self, obj, event):
if button_activated(event, _LEFT_BUTTON):
from editperson import EditPerson
handle = self.obj.ref
try:
person = self.db.get_person_from_handle(handle)
EditPerson(self.dbstate, self.uistate, self.track, person)
except Errors.WindowActiveError:
pass
def person_change(self, handles):
# check to see if the handle matches the current object
if self.obj.ref in handles:
p = self.dbstate.db.get_person_from_handle(self.obj.ref)
self.name = name_displayer.display(p)
self.name_label.set_text(self.name)
def save(self, *obj):
"""
Called when the OK button is pressed. Gets data from the
form and updates the ChildRef data structure.
"""
if self.callback:
self.callback(self.obj)
self.close()
def check_for_close(self, handles):
"""
Callback method for delete signals.
If there is a delete signal of the primary object we are editing, the
editor (and all child windows spawned) should be closed
"""
if self.obj.ref in handles:
self.close()
class EventComparison(tool.Tool, ManagedWindow.ManagedWindow):
def __init__(self, dbstate, uistate, options_class, name, callback=None):
self.dbstate = dbstate
self.uistate = uistate
tool.Tool.__init__(self, dbstate, options_class, name)
ManagedWindow.ManagedWindow.__init__(self, uistate, [], self)
self.qual = 0
self.filterDialog = Glade(toplevel="filters")
self.filterDialog.connect_signals({
"on_apply_clicked": self.on_apply_clicked,
"on_editor_clicked": self.filter_editor_clicked,
"on_help_clicked": self.on_help_clicked,
"destroy_passed_object": self.close,
"on_write_table": self.__dummy,
})
window = self.filterDialog.toplevel
window.show()
self.filters = self.filterDialog.get_object("filter_list")
self.label = _('Event comparison filter selection')
self.set_window(window, self.filterDialog.get_object('title'),
self.label)
self.on_filters_changed('Person')
uistate.connect('filters-changed', self.on_filters_changed)
self.show()
def __dummy(self, obj):
"""dummy callback, needed because widget is in same glade file
as another widget, so callbacks must be defined to avoid warnings.
"""
pass
def on_filters_changed(self, name_space):
if name_space == 'Person':
all_filter = GenericFilter()
all_filter.set_name(_("Entire Database"))
all_filter.add_rule(Rules.Person.Everyone([]))
self.filter_model = build_filter_model('Person', [all_filter])
self.filters.set_model(self.filter_model)
self.filters.set_active(0)
def on_help_clicked(self, obj):
"""Display the relevant portion of GRAMPS manual"""
GrampsDisplay.help(webpage=WIKI_HELP_PAGE, section=WIKI_HELP_SEC)
def build_menu_names(self, obj):
return (_("Filter selection"), _("Event Comparison tool"))
def filter_editor_clicked(self, obj):
try:
FilterEditor('Person', const.CUSTOM_FILTERS, self.dbstate,
self.uistate)
except Errors.WindowActiveError:
pass
def on_apply_clicked(self, obj):
cfilter = self.filter_model[self.filters.get_active()][1]
progress_bar = ProgressMeter(_('Comparing events'), '')
progress_bar.set_pass(_('Selecting people'), 1)
plist = cfilter.apply(self.db, self.db.iter_person_handles())
progress_bar.step()
progress_bar.close()
self.options.handler.options_dict['filter'] = self.filters.get_active()
# Save options
self.options.handler.save_options()
if len(plist) == 0:
WarningDialog(_("No matches were found"))
else:
DisplayChart(self.dbstate, self.uistate, plist, self.track)
class DisplayChart(ManagedWindow.ManagedWindow):
def __init__(self, dbstate, uistate, people_list, track):
self.dbstate = dbstate
self.uistate = uistate
ManagedWindow.ManagedWindow.__init__(self, uistate, track, self)
self.db = dbstate.db
self.my_list = people_list
self.row_data = []
self.save_form = None
self.topDialog = Glade()
self.topDialog.connect_signals({
"on_write_table": self.on_write_table,
"destroy_passed_object": self.close,
"on_help_clicked": self.on_help_clicked,
"on_apply_clicked": self.__dummy,
"on_editor_clicked": self.__dummy,
})
window = self.topDialog.toplevel
window.show()
self.set_window(window, self.topDialog.get_object('title'),
_('Event Comparison Results'))
self.eventlist = self.topDialog.get_object('treeview')
self.sort = Sort.Sort(self.db)
self.my_list.sort(self.sort.by_last_name)
self.event_titles = self.make_event_titles()
self.table_titles = [_("Person"), _("ID")]
for event_name in self.event_titles:
self.table_titles.append(
_("%(event_name)s Date") % {'event_name': event_name})
self.table_titles.append('sort') # This won't be shown in a tree
self.table_titles.append(
_("%(event_name)s Place") % {'event_name': event_name})
self.build_row_data()
self.draw_display()
self.show()
def __dummy(self, obj):
"""dummy callback, needed because widget is in same glade file
as another widget, so callbacks must be defined to avoid warnings.
"""
pass
def on_help_clicked(self, obj):
"""Display the relevant portion of GRAMPS manual"""
GrampsDisplay.help(webpage=WIKI_HELP_PAGE, section=WIKI_HELP_SEC)
def build_menu_names(self, obj):
return (_("Event Comparison Results"), None)
def draw_display(self):
model_index = 0
tree_index = 0
mylist = []
renderer = gtk.CellRendererText()
for title in self.table_titles:
mylist.append(str)
if title == 'sort':
# This will override the previously defined column
self.eventlist.get_column(tree_index -
1).set_sort_column_id(model_index)
else:
column = gtk.TreeViewColumn(title, renderer, text=model_index)
column.set_sort_column_id(model_index)
self.eventlist.append_column(column)
# This one numbers the tree columns: increment on new column
tree_index += 1
# This one numbers the model columns: always increment
model_index += 1
model = gtk.ListStore(*mylist)
self.eventlist.set_model(model)
self.progress_bar.set_pass(_('Building display'), len(self.row_data))
for data in self.row_data:
model.append(row=list(data))
self.progress_bar.step()
self.progress_bar.close()
def build_row_data(self):
self.progress_bar = ProgressMeter(_('Comparing Events'), '')
self.progress_bar.set_pass(_('Building data'), len(self.my_list))
for individual_id in self.my_list:
individual = self.db.get_person_from_handle(individual_id)
name = individual.get_primary_name().get_name()
gid = individual.get_gramps_id()
the_map = defaultdict(list)
for ievent_ref in individual.get_event_ref_list():
ievent = self.db.get_event_from_handle(ievent_ref.ref)
event_name = str(ievent.get_type())
the_map[event_name].append(ievent_ref.ref)
first = True
done = False
while not done:
added = False
tlist = [name, gid] if first else ["", ""]
for ename in self.event_titles:
if ename in the_map and len(the_map[ename]) > 0:
event_handle = the_map[ename][0]
del the_map[ename][0]
date = place = ""
if event_handle:
event = self.db.get_event_from_handle(event_handle)
date = DateHandler.get_date(event)
sortdate = "%09d" % (
event.get_date_object().get_sort_value())
place_handle = event.get_place_handle()
if place_handle:
place = self.db.get_place_from_handle(
place_handle).get_title()
tlist += [date, sortdate, place]
added = True
else:
tlist += [""] * 3
if first:
first = False
self.row_data.append(tlist)
elif not added:
done = True
else:
self.row_data.append(tlist)
self.progress_bar.step()
def make_event_titles(self):
"""
Create the list of unique event types, along with the person's
name, birth, and death.
This should be the column titles of the report.
"""
the_map = defaultdict(int)
for individual_id in self.my_list:
individual = self.db.get_person_from_handle(individual_id)
for event_ref in individual.get_event_ref_list():
event = self.db.get_event_from_handle(event_ref.ref)
name = str(event.get_type())
if not name:
break
the_map[name] += 1
unsort_list = sorted([(d, k) for k, d in the_map.iteritems()],
by_value)
sort_list = [item[1] for item in unsort_list]
## Presently there's no Birth and Death. Instead there's Birth Date and
## Birth Place, as well as Death Date and Death Place.
## # Move birth and death to the begining of the list
## if _("Death") in the_map:
## sort_list.remove(_("Death"))
## sort_list = [_("Death")] + sort_list
## if _("Birth") in the_map:
## sort_list.remove(_("Birth"))
## sort_list = [_("Birth")] + sort_list
return sort_list
def on_write_table(self, obj):
f = gtk.FileChooserDialog(_("Select filename"),
action=gtk.FILE_CHOOSER_ACTION_SAVE,
buttons=(gtk.STOCK_CANCEL,
gtk.RESPONSE_CANCEL, gtk.STOCK_SAVE,
gtk.RESPONSE_OK))
f.set_current_folder(os.getcwd())
status = f.run()
f.hide()
if status == gtk.RESPONSE_OK:
name = Utils.get_unicode_path_from_file_chooser(f.get_filename())
doc = ODSTab(len(self.row_data))
doc.creator(self.db.get_researcher().get_name())
spreadsheet = TableReport(name, doc)
new_titles = []
skip_columns = []
index = 0
for title in self.table_titles:
if title == 'sort':
skip_columns.append(index)
else:
new_titles.append(title)
index += 1
spreadsheet.initialize(len(new_titles))
spreadsheet.write_table_head(new_titles)
index = 0
for top in self.row_data:
spreadsheet.set_row(index % 2)
index += 1
spreadsheet.write_table_data(top, skip_columns)
spreadsheet.finalize()
f.destroy()
class EditLocation(EditSecondary):
def __init__(self, dbstate, uistate, track, location, callback):
EditSecondary.__init__(self, dbstate, uistate, track, location,
callback)
def _local_init(self):
self.width_key = 'interface.location-width'
self.height_key = 'interface.location-height'
self.top = Glade()
self.set_window(self.top.toplevel, None, _('Location Editor'))
def _setup_fields(self):
self.street = MonitoredEntry(self.top.get_object("street"),
self.obj.set_street, self.obj.get_street,
self.db.readonly)
self.locality = MonitoredEntry(self.top.get_object("locality"),
self.obj.set_locality,
self.obj.get_locality, self.db.readonly)
self.city = MonitoredEntry(self.top.get_object("city"),
self.obj.set_city, self.obj.get_city,
self.db.readonly)
self.state = MonitoredEntry(self.top.get_object("state"),
self.obj.set_state, self.obj.get_state,
self.db.readonly)
self.postal = MonitoredEntry(self.top.get_object("postal"),
self.obj.set_postal_code,
self.obj.get_postal_code,
self.db.readonly)
self.phone = MonitoredEntry(self.top.get_object("phone"),
self.obj.set_phone, self.obj.get_phone,
self.db.readonly)
self.parish = MonitoredEntry(self.top.get_object("parish"),
self.obj.set_parish, self.obj.get_parish,
self.db.readonly)
self.county = MonitoredEntry(self.top.get_object("county"),
self.obj.set_county, self.obj.get_county,
self.db.readonly)
self.country = MonitoredEntry(self.top.get_object("country"),
self.obj.set_country,
self.obj.get_country, self.db.readonly)
def _connect_signals(self):
self.define_cancel_button(self.top.get_object('button119'))
self.define_ok_button(self.top.get_object('button118'), self.save)
self.define_help_button(self.top.get_object('button128'))
def save(self, *obj):
if self.callback:
self.callback(self.obj)
self.close()
class DbManager(CLIDbManager):
"""
Database Manager. Opens a database manager window that allows users to
create, rename, delete and open databases.
"""
ICON_MAP = {
CLIDbManager.ICON_NONE: '',
CLIDbManager.ICON_RECOVERY: gtk.STOCK_DIALOG_ERROR,
CLIDbManager.ICON_LOCK: 'gramps-lock',
CLIDbManager.ICON_OPEN: gtk.STOCK_OPEN,
}
ERROR = ErrorDialog
def __init__(self, dbstate, parent=None):
"""
Create the top level window from the glade description, and extracts
the GTK widgets that are needed.
"""
CLIDbManager.__init__(self, dbstate)
self.glade = Glade()
self.top = self.glade.toplevel
if parent:
self.top.set_transient_for(parent)
for attr in [
'connect', 'cancel', 'new', 'remove', 'dblist', 'rename',
'repair', 'rcs', 'msg'
]:
setattr(self, attr, self.glade.get_object(attr))
self.model = None
self.column = None
self.lock_file = None
self.data_to_delete = None
self.selection = self.dblist.get_selection()
self.dblist.set_rules_hint(True)
self.__connect_signals()
self.__build_interface()
self._populate_model()
def __connect_signals(self):
"""
Connects the signals to the buttons on the interface.
"""
ddtargets = [DdTargets.URI_LIST.target()]
self.top.drag_dest_set(gtk.DEST_DEFAULT_ALL, ddtargets, ACTION_COPY)
self.remove.connect('clicked', self.__remove_db)
self.new.connect('clicked', self.__new_db)
self.rename.connect('clicked', self.__rename_db)
self.repair.connect('clicked', self.__repair_db)
self.selection.connect('changed', self.__selection_changed)
self.dblist.connect('button-press-event', self.__button_press)
self.dblist.connect('key-press-event', self.__key_press)
self.top.connect('drag_data_received', self.__drag_data_received)
self.top.connect('drag_motion', drag_motion)
self.top.connect('drag_drop', drop_cb)
if _RCS_FOUND:
self.rcs.connect('clicked', self.__rcs)
def __button_press(self, obj, event):
"""
Checks for a double click event. In the tree view, we want to
treat a double click as if it was OK button press. However, we have
to make sure that an item was selected first.
"""
if event.type == gtk.gdk._2BUTTON_PRESS and event.button == 1:
if self.connect.get_property('sensitive'):
self.top.response(gtk.RESPONSE_OK)
return True
return False
def __key_press(self, obj, event):
"""
Grab ENTER so it does not start editing the cell, but behaves
like double click instead
"""
if event.keyval in (_RETURN, _KP_ENTER):
if self.connect.get_property('sensitive'):
self.top.response(gtk.RESPONSE_OK)
return True
return False
def __selection_changed(self, selection):
"""
Called when the selection is changed in the TreeView.
"""
self.__update_buttons(selection)
def __update_buttons(self, selection):
"""
What we are trying to detect is the selection or unselection of a row.
When a row is unselected, the Open, Rename, and Remove buttons
are set insensitive. If a row is selected, the rename and remove
buttons are disabled, and the Open button is disabled if the
row represents a open database.
"""
# Get the current selection
store, node = selection.get_selected()
# if nothing is selected
if not node:
self.connect.set_sensitive(False)
self.rename.set_sensitive(False)
self.rcs.set_sensitive(False)
self.repair.set_sensitive(False)
self.remove.set_sensitive(False)
return
path = self.model.get_path(node)
if path is None:
return
is_rev = len(path) > 1
self.rcs.set_label(RCS_BUTTON[is_rev])
if store.get_value(node, STOCK_COL) == gtk.STOCK_OPEN:
self.connect.set_sensitive(False)
if _RCS_FOUND:
self.rcs.set_sensitive(True)
else:
self.connect.set_sensitive(not is_rev)
if _RCS_FOUND and is_rev:
self.rcs.set_sensitive(True)
else:
self.rcs.set_sensitive(False)
if store.get_value(node, STOCK_COL) == gtk.STOCK_DIALOG_ERROR:
path = get_unicode_path_from_env_var(
store.get_value(node, PATH_COL))
backup = os.path.join(path, "person.gbkp")
self.repair.set_sensitive(os.path.isfile(backup))
else:
self.repair.set_sensitive(False)
self.rename.set_sensitive(True)
self.remove.set_sensitive(True)
def __build_interface(self):
"""
Builds the columns for the TreeView. The columns are:
Icon, Database Name, Last Modified
The Icon column gets its data from column 6 of the database model.
It is expecting either None, or a GTK stock icon name
The Database Name column is an editable column. We connect to the
'edited' signal, so that we can change the name when the user changes
the column.
The last accessed column simply displays the last time famtree was
opened.
"""
# build the database name column
render = gtk.CellRendererText()
render.set_property('ellipsize', pango.ELLIPSIZE_END)
render.connect('edited', self.__change_name)
render.connect('editing-canceled', self.__stop_edit)
render.connect('editing-started', self.__start_edit)
self.column = gtk.TreeViewColumn(_('Family tree name'),
render,
text=NAME_COL)
self.column.set_sort_column_id(NAME_COL)
self.column.set_resizable(True)
self.column.set_min_width(275)
self.dblist.append_column(self.column)
self.name_renderer = render
# build the icon column
render = gtk.CellRendererPixbuf()
icon_column = gtk.TreeViewColumn(_('Status'),
render,
stock_id=STOCK_COL)
self.dblist.append_column(icon_column)
# build the last accessed column
render = gtk.CellRendererText()
column = gtk.TreeViewColumn(_('Last accessed'), render, text=DATE_COL)
column.set_sort_column_id(DSORT_COL)
self.dblist.append_column(column)
# set the rules hit
self.dblist.set_rules_hint(True)
def __populate(self):
"""
Builds the data and the display model.
"""
self._populate_cli()
self._populate_model()
def _populate_model(self):
"""
Builds the display model.
"""
self.model = gtk.TreeStore(str, str, str, str, int, bool, str)
#use current names to set up the model
for items in self.current_names:
data = list(items[:7])
node = self.model.append(None, data)
for rdata in find_revisions(os.path.join(items[1], ARCHIVE_V)):
data = [rdata[2], rdata[0], items[1], rdata[1], 0, False, ""]
self.model.append(node, data)
self.dblist.set_model(self.model)
def existing_name(self, name, skippath=None):
"""
Return true if a name is present in the model already.
If skippath given, the name of skippath is not considered
"""
iter = self.model.get_iter_first()
while (iter):
path = self.model.get_path(iter)
if path == skippath:
continue
itername = self.model.get_value(iter, NAME_COL)
if itername.strip() == name.strip():
return True
iter = self.model.iter_next(iter)
return False
def run(self):
"""
Runs the dialog, returning None if nothing has been chosen,
or the path and name if something has been selected
"""
while True:
value = self.top.run()
if value == gtk.RESPONSE_OK:
store, node = self.selection.get_selected()
# don't open a locked file
if store.get_value(node, STOCK_COL) == 'gramps-lock':
self.__ask_to_break_lock(store, node)
continue
# don't open a version
if len(store.get_path(node)) > 1:
continue
if node:
self.top.destroy()
del self.selection
del self.name_renderer
path = get_unicode_path_from_env_var(
store.get_value(node, PATH_COL))
return (path, store.get_value(node, NAME_COL))
else:
self.top.destroy()
del self.selection
del self.name_renderer
return None
def __ask_to_break_lock(self, store, node):
"""
Prompts the user for permission to break the lock file that another
process has set on the file.
"""
path = store.get_path(node)
self.lock_file = store[path][PATH_COL]
QuestionDialog(
_("Break the lock on the '%s' database?") % store[path][0],
_("Gramps believes that someone else is actively editing "
"this database. You cannot edit this database while it "
"is locked. If no one is editing the database you may "
"safely break the lock. However, if someone else is editing "
"the database and you break the lock, you may corrupt the "
"database."), _("Break lock"), self.__really_break_lock)
def __really_break_lock(self):
"""
Deletes the lock file associated with the selected database, then updates
the display appropriately.
"""
try:
self.break_lock(self.lock_file)
store, node = self.selection.get_selected()
dbpath = get_unicode_path_from_env_var(
store.get_value(node, PATH_COL))
(tval, last) = time_val(dbpath)
store.set_value(node, OPEN_COL, 0)
store.set_value(node, STOCK_COL, "")
store.set_value(node, DATE_COL, last)
store.set_value(node, DSORT_COL, tval)
except IOError:
return
def __stop_edit(self, *args):
self.name_renderer.set_property('editable', False)
self.__update_buttons(self.selection)
def __start_edit(self, *args):
"""
Do no allow to click Load while changing name, to force users to finish
the action of renaming. Hack around the fact that clicking button
sends a 'editing-canceled' signal loosing the new name
"""
self.connect.set_sensitive(False)
self.rename.set_sensitive(False)
def __change_name(self, renderer_sel, path, new_text):
"""
Change the name of the database. This is a callback from the
column, which has been marked as editable.
If the new string is empty, do nothing. Otherwise, renaming the
database is simply changing the contents of the name file.
"""
if len(new_text) > 0:
node = self.model.get_iter(path)
old_text = self.model.get_value(node, NAME_COL)
if not old_text.strip() == new_text.strip():
#If there is a ":" in path, then it as revision
if ":" in path:
self.__rename_revision(path, new_text)
else:
self.__rename_database(path, new_text)
self.name_renderer.set_property('editable', False)
self.__update_buttons(self.selection)
def __rename_revision(self, path, new_text):
"""
Renames the RCS revision using the rcs command. The rcs command
is in the format of:
rcs -mREV:NEW_NAME archive
"""
node = self.model.get_iter(path)
db_dir = self.model.get_value(node, FILE_COL)
rev = self.model.get_value(node, PATH_COL)
archive = os.path.join(db_dir, ARCHIVE_V)
cmd = ["rcs", "-x,v", "-m%s:%s" % (rev, new_text), archive]
proc = subprocess.Popen(cmd, stderr=subprocess.PIPE)
status = proc.wait()
message = "\n".join(proc.stderr.readlines())
proc.stderr.close()
del proc
if status != 0:
DbManager.ERROR(
_("Rename failed"),
_("An attempt to rename a version failed "
"with the following message:\n\n%s") % message)
else:
self.model.set_value(node, NAME_COL, new_text)
def __rename_database(self, path, new_text):
"""
Renames the database by writing the new value to the name.txt file
"""
new_text = new_text.strip()
node = self.model.get_iter(path)
filename = self.model.get_value(node, FILE_COL)
if self.existing_name(new_text, skippath=path):
DbManager.ERROR(
_("Could not rename the Family Tree."),
_("Family Tree already exists, choose a unique name."))
return
old_text, new_text = self.rename_database(filename, new_text)
if not (old_text is None):
RecentFiles.rename_filename(old_text, new_text)
self.model.set_value(node, NAME_COL, new_text)
def __rcs(self, obj):
"""
Callback for the RCS button. If the tree path is > 1, then we are
on an RCS revision, in which case we can check out. If not, then
we can only check in.
"""
store, node = self.selection.get_selected()
tree_path = store.get_path(node)
if len(tree_path) > 1:
parent_node = store.get_iter((tree_path[0], ))
parent_name = store.get_value(parent_node, NAME_COL)
name = store.get_value(node, NAME_COL)
revision = store.get_value(node, PATH_COL)
db_path = store.get_value(node, FILE_COL)
self.__checkout_copy(parent_name, name, revision, db_path)
else:
base_path = self.dbstate.db.get_save_path()
archive = os.path.join(base_path, ARCHIVE)
check_in(self.dbstate.db, archive, None, self.__start_cursor)
self.__end_cursor()
self.__populate()
def __checkout_copy(self, parent_name, name, revision, db_path):
"""
Create a new database, then extracts a revision from RCS and
imports it into the db
"""
new_path, newname = self._create_new_db("%s : %s" %
(parent_name, name))
self.__start_cursor(_("Extracting archive..."))
dbclass = DbBsddb
dbase = dbclass()
dbase.load(new_path, None)
self.__start_cursor(_("Importing archive..."))
check_out(dbase, revision, db_path, None)
self.__end_cursor()
dbase.close()
def __remove_db(self, obj):
"""
Callback associated with the Remove button. Get the selected
row and data, then call the verification dialog.
"""
store, node = self.selection.get_selected()
path = store.get_path(node)
self.data_to_delete = store[path]
if len(path) == 1:
QuestionDialog(
_("Remove the '%s' family tree?") % self.data_to_delete[0],
_("Removing this family tree will permanently destroy the data."
), _("Remove family tree"), self.__really_delete_db)
else:
rev = self.data_to_delete[0]
parent = store[(path[0], )][0]
QuestionDialog(
_("Remove the '%(revision)s' version of '%(database)s'") % {
'revision': rev,
'database': parent
},
_("Removing this version will prevent you from "
"extracting it in the future."), _("Remove version"),
self.__really_delete_version)
def __really_delete_db(self):
"""
Delete the selected database. If the database is open, close it first.
Then scan the database directory, deleting the files, and finally
removing the directory.
"""
# close the database if the user has requested to delete the
# active database
if self.data_to_delete[PATH_COL] == self.active:
self.dbstate.no_database()
store, node = self.selection.get_selected()
path = store.get_path(node)
node = self.model.get_iter(path)
filename = self.model.get_value(node, FILE_COL)
try:
name_file = open(filename, "r")
file_name_to_delete = name_file.read()
name_file.close()
RecentFiles.remove_filename(file_name_to_delete)
for (top, dirs, files) in os.walk(self.data_to_delete[1]):
for filename in files:
os.unlink(os.path.join(top, filename))
os.rmdir(self.data_to_delete[1])
except (IOError, OSError), msg:
DbManager.ERROR(_("Could not delete family tree"), str(msg))
# rebuild the display
self.__populate()
class BookListDisplay(object):
"""
Interface into a dialog with the list of available books.
Allows the user to select and/or delete a book from the list.
"""
def __init__(self, booklist, nodelete=0, dosave=0):
"""
Create a BookListDisplay object that displays the books in BookList.
booklist: books that are displayed
nodelete: if not 0 then the Delete button is hidden
dosave: if 1 then the book list is saved on hitting OK
"""
self.booklist = booklist
self.dosave = dosave
self.xml = Glade()
self.top = self.xml.toplevel
self.unsaved_changes = False
ManagedWindow.set_titles(self.top, self.xml.get_object('title'),
_('Available Books'))
if nodelete:
delete_button = self.xml.get_object("delete_button")
delete_button.hide()
self.xml.connect_signals({
"on_booklist_cancel_clicked": self.on_booklist_cancel_clicked,
"on_booklist_ok_clicked": self.on_booklist_ok_clicked,
"on_booklist_delete_clicked": self.on_booklist_delete_clicked,
"on_book_ok_clicked": self.do_nothing,
"destroy_passed_object": self.do_nothing,
"on_setup_clicked": self.do_nothing,
"on_down_clicked": self.do_nothing,
"on_up_clicked": self.do_nothing,
"on_remove_clicked": self.do_nothing,
"on_add_clicked": self.do_nothing,
"on_edit_clicked": self.do_nothing,
"on_open_clicked": self.do_nothing,
"on_save_clicked": self.do_nothing,
"on_clear_clicked": self.do_nothing
})
title_label = self.xml.get_object('title')
title_label.set_text(Utils.title(_('Book List')))
title_label.set_use_markup(True)
self.blist = ListModel.ListModel(
self.xml.get_object("list"),
[('Name', -1, 10)],
)
self.redraw()
self.selection = None
self.top.run()
def redraw(self):
"""Redraws the list of currently available books"""
self.blist.model.clear()
names = self.booklist.get_book_names()
if not len(names):
return
for name in names:
the_iter = self.blist.add([name])
if the_iter:
self.blist.selection.select_iter(the_iter)
def on_booklist_ok_clicked(self, obj):
"""Return selected book. Saves the current list into xml file."""
store, the_iter = self.blist.get_selected()
if the_iter:
data = self.blist.get_data(the_iter, [0])
self.selection = self.booklist.get_book(unicode(data[0]))
if self.dosave:
self.booklist.save()
def on_booklist_delete_clicked(self, obj):
"""
Deletes selected book from the list.
This change is not final. OK button has to be clicked to save the list.
"""
store, the_iter = self.blist.get_selected()
if not the_iter:
return
data = self.blist.get_data(the_iter, [0])
self.booklist.delete_book(unicode(data[0]))
self.blist.remove(the_iter)
self.unsaved_changes = True
self.top.run()
def on_booklist_cancel_clicked(self, obj):
if self.unsaved_changes:
from QuestionDialog import QuestionDialog2
q = QuestionDialog2(
_('Discard Unsaved Changes'),
_('You have made changes which have not been saved.'),
_('Proceed'), _('Cancel'))
if q.run():
return
else:
self.top.run()
def do_nothing(self, object):
pass
class EditFamily(EditPrimary):
QR_CATEGORY = CATEGORY_QR_FAMILY
def __init__(self, dbstate, uistate, track, family, callback=None):
EditPrimary.__init__(self, dbstate, uistate, track, family,
dbstate.db.get_family_from_handle,
dbstate.db.get_family_from_gramps_id, callback)
# look for the scenerio of a child and no parents on a new
# family
if (self.added and not self.obj.get_father_handle()
and not self.obj.get_mother_handle()
and len(self.obj.get_child_ref_list()) == 1):
self.add_parent = True
if not config.get('preferences.family-warn'):
for i in self.hidden:
i.set_sensitive(False)
MessageHideDialog(
_("Adding parents to a person"),
_("It is possible to accidentally create multiple "
"families with the same parents. To help avoid "
"this problem, only the buttons to select parents "
"are available when you create a new family. The "
"remaining fields will become available after you "
"attempt to select a parent."),
'preferences.family-warn')
else:
self.add_parent = False
def _cleanup_on_exit(self):
"""Unset all things that can block garbage collection.
Finalize rest
"""
#FIXME, we rebind show_all below, this prevents garbage collection of
# the dialog, fix the rebind
self.window.show_all = None
EditPrimary._cleanup_on_exit(self)
def empty_object(self):
return gen.lib.Family()
def _local_init(self):
self.build_interface()
self.added = self.obj.handle is None
if self.added:
self.obj.handle = Utils.create_id()
self.load_data()
def _connect_db_signals(self):
"""
implement from base class DbGUIElement
Register the callbacks we need.
Note:
* we do not connect to person-delete, as a delete of a person in
the family outside of this editor will cause a family-update
signal of this family
"""
self.callman.register_handles({'family': [self.obj.get_handle()]})
self.callman.register_callbacks({
'family-update': self.check_for_family_change,
'family-delete': self.check_for_close,
'family-rebuild': self._do_close,
'event-update': self.topdata_updated, # change eg birth event fath
'event-rebuild': self.topdata_updated,
'event-delete': self.topdata_updated, # delete eg birth event fath
'person-update': self.topdata_updated, # change eg name of father
'person-rebuild': self._do_close,
})
self.callman.connect_all(keys=['family', 'event', 'person'])
def check_for_family_change(self, handles):
"""
Callback for family-update signal
1. This method checks to see if the family shown has been changed. This
is possible eg in the relationship view. If the family was changed,
the view is refreshed and a warning dialog shown to indicate all
changes have been lost.
If a source/note/event is deleted, this method is called too. This
is unfortunate as the displaytabs can track themself a delete and
correct the view for this. Therefore, these tabs are not rebuild.
Conclusion: this method updates so that remove/change of parent or
remove/change of children in relationship view reloads the family
from db.
2. Changes in other families are of no consequence to the family shown
"""
if self.obj.get_handle() in handles:
#rebuild data
## Todo: Gallery and note tab are not rebuild ??
objreal = self.dbstate.db.get_family_from_handle(
self.obj.get_handle())
#update selection of data that we obtain from database change:
maindatachanged = (
self.obj.gramps_id != objreal.gramps_id
or self.obj.father_handle != objreal.father_handle
or self.obj.mother_handle != objreal.mother_handle
or self.obj.private != objreal.private
or self.obj.type != objreal.type
or self.obj.get_tag_list() != objreal.get_tag_list()
or self.obj.child_ref_list != objreal.child_ref_list)
if maindatachanged:
self.obj.gramps_id = objreal.gramps_id
self.obj.father_handle = objreal.father_handle
self.obj.mother_handle = objreal.mother_handle
self.obj.private = objreal.private
self.obj.type = objreal.type
self.obj.set_tag_list(objreal.get_tag_list())
self.obj.child_ref_list = objreal.child_ref_list
self.reload_people()
# No matter why the family changed (eg delete of a source), we notify
# the user
WarningDialog(
_("Family has changed"),
_("The %(object)s you are editing has changed outside this editor."
" This can be due to a change in one of the main views, for "
"example a source used here is deleted in the source view.\n"
"To make sure the information shown is still correct, the "
"data shown has been updated. Some edits you have made may have"
" been lost.") % {'object': _('family')},
parent=self.window)
def topdata_updated(self, *obj):
"""
Callback method called if data shown in top part of family editor
(a parent, birth/death event of parent) changes
Note: person events shown in the event list are not tracked, the
tabpage itself tracks it
"""
self.load_data()
def show_buttons(self):
"""
Used to reshow hidden/showing buttons.
"""
fhandle = self.obj.get_father_handle()
self.update_father(fhandle)
mhandle = self.obj.get_mother_handle()
self.update_mother(mhandle)
def reload_people(self):
fhandle = self.obj.get_father_handle()
self.update_father(fhandle)
mhandle = self.obj.get_mother_handle()
self.update_mother(mhandle)
self.child_tab.rebuild()
def get_menu_title(self):
if self.obj and self.obj.get_handle():
dialog_title = Utils.family_name(self.obj, self.db,
_("New Family"))
dialog_title = _("Family") + ': ' + dialog_title
else:
dialog_title = _("New Family")
return dialog_title
def build_menu_names(self, family):
return (_('Edit Family'), self.get_menu_title())
def build_interface(self):
self.width_key = 'interface.family-width'
self.height_key = 'interface.family-height'
self.top = Glade()
self.set_window(self.top.toplevel, None, self.get_menu_title())
# HACK: how to prevent hidden items from showing
# when you use show_all?
# Consider using show() rather than show_all()?
# FIXME: remove if we can use show()
self.window.show_all = self.window.show
self.fbirth = self.top.get_object('fbirth')
self.fdeath = self.top.get_object('fdeath')
self.fbirth_label = self.top.get_object('label578')
self.fdeath_label = self.top.get_object('label579')
self.mbirth = self.top.get_object('mbirth')
self.mdeath = self.top.get_object('mdeath')
self.mbirth_label = self.top.get_object('label567')
self.mdeath_label = self.top.get_object('label568')
self.mname = self.top.get_object('mname')
self.fname = self.top.get_object('fname')
self.mbutton_index = self.top.get_object('mbutton_index')
self.mbutton_add = self.top.get_object('mbutton_add')
self.mbutton_del = self.top.get_object('mbutton_del')
self.mbutton_edit = self.top.get_object('mbutton_edit')
self.mbutton_index.set_tooltip_text(_("Select a person as the mother"))
self.mbutton_add.set_tooltip_text(_("Add a new person as the mother"))
self.mbutton_del.set_tooltip_text(_("Remove the person as the mother"))
self.mbutton_edit.connect('button-press-event', self.edit_mother)
self.mbutton_edit.connect('key-press-event', self.edit_mother)
self.mbutton_index.connect('clicked', self.sel_mother_clicked)
self.mbutton_del.connect('clicked', self.del_mother_clicked)
self.mbutton_add.connect('clicked', self.add_mother_clicked)
self.fbutton_index = self.top.get_object('fbutton_index')
self.fbutton_add = self.top.get_object('fbutton_add')
self.fbutton_del = self.top.get_object('fbutton_del')
self.fbutton_edit = self.top.get_object('fbutton_edit')
self.fbutton_index.set_tooltip_text(_("Select a person as the father"))
self.fbutton_add.set_tooltip_text(_("Add a new person as the father"))
self.fbutton_del.set_tooltip_text(_("Remove the person as the father"))
self.fbutton_edit.connect('button-press-event', self.edit_father)
self.fbutton_edit.connect('key-press-event', self.edit_father)
self.fbutton_index.connect('clicked', self.sel_father_clicked)
self.fbutton_del.connect('clicked', self.del_father_clicked)
self.fbutton_add.connect('clicked', self.add_father_clicked)
#allow for a context menu
self.set_contexteventbox(self.top.get_object("eventboxtop"))
#allow for drop:
ftable = self.top.get_object('ftable')
ftable.drag_dest_set(gtk.DEST_DEFAULT_MOTION | gtk.DEST_DEFAULT_DROP,
[DdTargets.PERSON_LINK.target()],
gtk.gdk.ACTION_COPY)
ftable.connect('drag_data_received', self.on_drag_fatherdata_received)
mtable = self.top.get_object('mtable')
mtable.drag_dest_set(gtk.DEST_DEFAULT_MOTION | gtk.DEST_DEFAULT_DROP,
[DdTargets.PERSON_LINK.target()],
gtk.gdk.ACTION_COPY)
mtable.connect('drag_data_received', self.on_drag_motherdata_received)
def _connect_signals(self):
self.define_ok_button(self.top.get_object('ok'), self.save)
self.define_cancel_button(self.top.get_object('cancel'))
self.define_help_button(self.top.get_object('button119'))
def _can_be_replaced(self):
pass
def _setup_fields(self):
self.private = PrivacyButton(self.top.get_object('private'), self.obj,
self.db.readonly)
self.gid = MonitoredEntry(self.top.get_object('gid'),
self.obj.set_gramps_id,
self.obj.get_gramps_id, self.db.readonly)
self.tags = MonitoredTagList(self.top.get_object("tag_label"),
self.top.get_object("tag_button"),
self.obj.set_tag_list,
self.obj.get_tag_list, self.db,
self.uistate, self.track,
self.db.readonly)
self.data_type = MonitoredDataType(
self.top.get_object('marriage_type'),
self.obj.set_relationship,
self.obj.get_relationship,
self.db.readonly,
self.db.get_family_relation_types(),
)
def load_data(self):
"""
Show top data of family editor: father and mother info
and set self.phandles with all person handles in the family
"""
fhandle = self.obj.get_father_handle()
self.update_father(fhandle)
mhandle = self.obj.get_mother_handle()
self.update_mother(mhandle)
self.phandles = [mhandle, fhandle]
self.phandles.extend(x.ref for x in self.obj.get_child_ref_list())
self.phandles = filter(None, self.phandles)
def _create_tabbed_pages(self):
notebook = gtk.Notebook()
self.child_list = ChildEmbedList(self.dbstate, self.uistate,
self.track, self.obj)
self.child_tab = self._add_tab(notebook, self.child_list)
self.track_ref_for_deletion("child_list")
self.track_ref_for_deletion("child_tab")
self.event_list = EventEmbedList(self.dbstate, self.uistate,
self.track, self.obj)
self._add_tab(notebook, self.event_list)
self.track_ref_for_deletion("event_list")
self.citation_list = CitationEmbedList(self.dbstate, self.uistate,
self.track,
self.obj.get_citation_list(),
self.get_menu_title())
self._add_tab(notebook, self.citation_list)
self.track_ref_for_deletion("citation_list")
self.attr_list = FamilyAttrEmbedList(self.dbstate, self.uistate,
self.track,
self.obj.get_attribute_list())
self._add_tab(notebook, self.attr_list)
self.track_ref_for_deletion("attr_list")
self.note_tab = NoteTab(self.dbstate,
self.uistate,
self.track,
self.obj.get_note_list(),
self.get_menu_title(),
notetype=gen.lib.NoteType.FAMILY)
self._add_tab(notebook, self.note_tab)
self.track_ref_for_deletion("note_tab")
self.gallery_tab = GalleryTab(self.dbstate, self.uistate, self.track,
self.obj.get_media_list())
self._add_tab(notebook, self.gallery_tab)
self.track_ref_for_deletion("gallery_tab")
self.lds_embed = FamilyLdsEmbedList(self.dbstate, self.uistate,
self.track,
self.obj.get_lds_ord_list())
self._add_tab(notebook, self.lds_embed)
self.track_ref_for_deletion("lds_embed")
self._setup_notebook_tabs(notebook)
notebook.show_all()
self.hidden = (notebook, self.top.get_object('info'))
self.top.get_object('vbox').pack_start(notebook, True)
def update_father(self, handle):
self.load_parent(handle, self.fname, self.fbirth, self.fbirth_label,
self.fdeath, self.fdeath_label, self.fbutton_index,
self.fbutton_add, self.fbutton_del, self.fbutton_edit)
def update_mother(self, handle):
self.load_parent(handle, self.mname, self.mbirth, self.mbirth_label,
self.mdeath, self.mdeath_label, self.mbutton_index,
self.mbutton_add, self.mbutton_del, self.mbutton_edit)
def add_mother_clicked(self, obj):
person = gen.lib.Person()
person.set_gender(gen.lib.Person.FEMALE)
autoname = config.get('behavior.surname-guessing')
#_("Father's surname"),
#_("None"),
#_("Combination of mother's and father's surname"),
#_("Icelandic style"),
if autoname == 2:
name = self.latin_american_child("mother")
else:
name = self.no_name()
person.set_primary_name(name)
EditPerson(self.dbstate, self.uistate, self.track, person,
self.new_mother_added)
def add_father_clicked(self, obj):
person = gen.lib.Person()
person.set_gender(gen.lib.Person.MALE)
autoname = config.get('behavior.surname-guessing')
#_("Father's surname"),
#_("None"),
#_("Combination of mother's and father's surname"),
#_("Icelandic style"),
if autoname == 0:
name = self.north_american_child()
elif autoname == 2:
name = self.latin_american_child("father")
else:
name = self.no_name()
person.set_primary_name(name)
EditPerson(self.dbstate, self.uistate, self.track, person,
self.new_father_added)
def new_mother_added(self, person):
for i in self.hidden:
i.set_sensitive(True)
self.obj.set_mother_handle(person.handle)
self.update_mother(person.handle)
def new_father_added(self, person):
for i in self.hidden:
i.set_sensitive(True)
self.obj.set_father_handle(person.handle)
self.update_father(person.handle)
def del_mother_clicked(self, obj):
for i in self.hidden:
i.set_sensitive(True)
self.obj.set_mother_handle(None)
self.update_mother(None)
def sel_mother_clicked(self, obj):
for i in self.hidden:
i.set_sensitive(True)
data_filter = FastFemaleFilter(self.dbstate.db)
sel = SelectPerson(self.dbstate,
self.uistate,
self.track,
_("Select Mother"),
filter=data_filter,
skip=[x.ref for x in self.obj.get_child_ref_list()])
person = sel.run()
if person:
self.check_for_existing_family(self.obj.get_father_handle(),
person.handle, self.obj.handle)
self.obj.set_mother_handle(person.handle)
self.update_mother(person.handle)
def on_change_father(self, selector_window, obj):
if obj.__class__ == gen.lib.Person:
try:
person = obj
self.obj.set_father_handle(person.get_handle())
self.update_father(person.get_handle())
except:
log.warn("Failed to update father: \n"
"obj returned from selector was: %s\n" %
(repr(obj), ))
raise
else:
log.warn("Object selector returned obj.__class__ = %s, it should "
"have been of type %s." %
(obj.__class__.__name__, gen.lib.Person.__name__))
selector_window.close()
def del_father_clicked(self, obj):
for i in self.hidden:
i.set_sensitive(True)
self.obj.set_father_handle(None)
self.update_father(None)
def sel_father_clicked(self, obj):
for i in self.hidden:
i.set_sensitive(True)
data_filter = FastMaleFilter(self.dbstate.db)
sel = SelectPerson(self.dbstate,
self.uistate,
self.track,
_("Select Father"),
filter=data_filter,
skip=[x.ref for x in self.obj.get_child_ref_list()])
person = sel.run()
if person:
self.check_for_existing_family(person.handle,
self.obj.get_mother_handle(),
self.obj.handle)
self.obj.set_father_handle(person.handle)
self.update_father(person.handle)
def check_for_existing_family(self, father_handle, mother_handle,
family_handle):
if father_handle:
father = self.dbstate.db.get_person_from_handle(father_handle)
ffam = set(father.get_family_handle_list())
if mother_handle:
mother = self.dbstate.db.get_person_from_handle(mother_handle)
mfam = set(mother.get_family_handle_list())
common = list(mfam.intersection(ffam))
if len(common) > 0:
if self.add_parent or self.obj.handle not in common:
WarningDialog(
_('Duplicate Family'),
_('A family with these parents already exists '
'in the database. If you save, you will create '
'a duplicate family. It is recommended that '
'you cancel the editing of this window, and '
'select the existing family'),
parent=self.window)
def edit_father(self, obj, event):
handle = self.obj.get_father_handle()
return self.edit_person(obj, event, handle)
def edit_mother(self, obj, event):
handle = self.obj.get_mother_handle()
return self.edit_person(obj, event, handle)
def edit_person(self, obj, event, handle):
if button_activated(event, _LEFT_BUTTON):
try:
person = self.db.get_person_from_handle(handle)
EditPerson(self.dbstate, self.uistate, self.track, person)
except Errors.WindowActiveError:
pass
def load_parent(self, handle, name_obj, birth_obj, birth_label, death_obj,
death_label, btn_index, btn_add, btn_del, btn_edit):
# is a parent used here:
is_used = handle is not None
# now we display the area:
if is_used:
db = self.db
person = db.get_person_from_handle(handle)
name = "%s [%s]" % (name_displayer.display(person),
person.gramps_id)
birth = get_birth_or_fallback(db, person)
self.callman.register_handles({'person': [handle]})
if birth:
#if event changes it view needs to update
self.callman.register_handles({'event': [birth.get_handle()]})
birth_label.set_label("%s:" % birth.get_type())
death = get_death_or_fallback(db, person)
if death:
#if event changes it view needs to update
self.callman.register_handles({'event': [death.get_handle()]})
death_label.set_label("%s:" % death.get_type())
btn_edit.set_tooltip_text(_('Edit %s') % name)
btn_index.hide()
btn_add.hide()
btn_del.show()
btn_edit.show()
else:
name = ""
birth = None
death = None
btn_index.show()
btn_add.show()
btn_del.hide()
btn_edit.hide()
if name_obj:
name_obj.set_text(name)
if birth:
birth_str = DateHandler.displayer.display(birth.get_date_object())
else:
birth_str = ""
birth_obj.set_text(birth_str)
if death:
death_str = DateHandler.displayer.display(death.get_date_object())
else:
death_str = ""
death_obj.set_text(death_str)
def fix_parent_handles(self, orig_handle, new_handle, trans):
if orig_handle != new_handle:
if orig_handle:
person = self.db.get_person_from_handle(orig_handle)
person.family_list.remove(self.obj.handle)
self.db.commit_person(person, trans)
if new_handle:
person = self.db.get_person_from_handle(new_handle)
person.family_list.append(self.obj.handle)
self.db.commit_person(person, trans)
def on_drag_fatherdata_received(self, widget, context, x, y, sel_data,
info, time):
"""
Handle the standard gtk interface for drag_data_received.
"""
if self.obj.get_father_handle():
return
for i in self.hidden:
i.set_sensitive(True)
if sel_data and sel_data.data:
(drag_type, idval, handle, val) = pickle.loads(sel_data.data)
person = self.db.get_person_from_handle(handle)
if person:
self.check_for_existing_family(person.handle,
self.obj.get_mother_handle(),
self.obj.handle)
self.obj.set_father_handle(person.handle)
self.update_father(person.handle)
def on_drag_motherdata_received(self, widget, context, x, y, sel_data,
info, time):
"""
Handle the standard gtk interface for drag_data_received.
"""
if self.obj.get_mother_handle():
return
for i in self.hidden:
i.set_sensitive(True)
if sel_data and sel_data.data:
(drag_type, idval, handle, val) = pickle.loads(sel_data.data)
person = self.db.get_person_from_handle(handle)
if person:
self.check_for_existing_family(self.obj.get_father_handle(),
person.handle, self.obj.handle)
self.obj.set_mother_handle(person.handle)
self.update_mother(person.handle)
def object_is_empty(self):
return (not self.obj.get_father_handle()
and not self.obj.get_mother_handle()
and len(self.obj.get_child_ref_list()) == 0)
def save(self, *obj):
try:
self.__do_save()
except bsddb_db.DBRunRecoveryError, msg:
RunDatabaseRepair(msg[1])
class BookReportSelector(ManagedWindow.ManagedWindow):
"""
Interface into a dialog setting up the book.
Allows the user to add/remove/reorder/setup items for the current book
and to clear/load/save/edit whole books.
"""
def __init__(self, dbstate, uistate):
self.db = dbstate.db
self.dbstate = dbstate
self.uistate = uistate
self.title = _('Book Report')
self.file = "books.xml"
ManagedWindow.ManagedWindow.__init__(self, uistate, [], self.__class__)
self.xml = Glade(toplevel="top")
window = self.xml.toplevel
title_label = self.xml.get_object('title')
self.set_window(window, title_label, self.title)
window.show()
self.xml.connect_signals({
"on_add_clicked": self.on_add_clicked,
"on_remove_clicked": self.on_remove_clicked,
"on_up_clicked": self.on_up_clicked,
"on_down_clicked": self.on_down_clicked,
"on_setup_clicked": self.on_setup_clicked,
"on_clear_clicked": self.on_clear_clicked,
"on_save_clicked": self.on_save_clicked,
"on_open_clicked": self.on_open_clicked,
"on_edit_clicked": self.on_edit_clicked,
"on_book_ok_clicked": self.on_book_ok_clicked,
"destroy_passed_object": self.close,
# Insert dummy handlers for second top level in the glade file
"on_booklist_ok_clicked": lambda _: None,
"on_booklist_delete_clicked": lambda _: None,
"on_booklist_cancel_clicked": lambda _: None,
"on_booklist_ok_clicked": lambda _: None,
"on_booklist_ok_clicked": lambda _: None,
})
self.avail_tree = self.xml.get_object("avail_tree")
self.book_tree = self.xml.get_object("book_tree")
self.avail_tree.connect('button-press-event', self.avail_button_press)
self.book_tree.connect('button-press-event', self.book_button_press)
self.name_entry = self.xml.get_object("name_entry")
self.name_entry.set_text(_('New Book'))
avail_label = self.xml.get_object('avail_label')
avail_label.set_text("<b>%s</b>" % _("_Available items"))
avail_label.set_use_markup(True)
avail_label.set_use_underline(True)
book_label = self.xml.get_object('book_label')
book_label.set_text("<b>%s</b>" % _("Current _book"))
book_label.set_use_underline(True)
book_label.set_use_markup(True)
avail_titles = [(_('Name'), 0, 230), (_('Type'), 1, 80), ('', -1, 0)]
book_titles = [(_('Item name'), -1, 230), (_('Type'), -1, 80),
('', -1, 0), (_('Subject'), -1, 50)]
self.avail_nr_cols = len(avail_titles)
self.book_nr_cols = len(book_titles)
self.avail_model = ListModel.ListModel(self.avail_tree, avail_titles)
self.book_model = ListModel.ListModel(self.book_tree, book_titles)
self.draw_avail_list()
self.book = Book()
def build_menu_names(self, obj):
return (_("Book selection list"), self.title)
def draw_avail_list(self):
"""
Draw the list with the selections available for the book.
The selections are read from the book item registry.
"""
pmgr = GuiPluginManager.get_instance()
regbi = pmgr.get_reg_bookitems()
if not regbi:
return
available_reports = []
for pdata in regbi:
category = _UNSUPPORTED
if pdata.supported and pdata.category in book_categories:
category = book_categories[pdata.category]
available_reports.append([pdata.name, category, pdata.id])
for data in sorted(available_reports):
new_iter = self.avail_model.add(data)
self.avail_model.connect_model()
if new_iter:
self.avail_model.selection.select_iter(new_iter)
path = self.avail_model.model.get_path(new_iter)
col = self.avail_tree.get_column(0)
self.avail_tree.scroll_to_cell(path, col, 1, 1, 0.0)
def open_book(self, book):
"""
Open the book: set the current set of selections to this book's items.
book: the book object to load.
"""
if book.get_dbname() == self.db.get_save_path():
same_db = 1
else:
same_db = 0
WarningDialog(
_('Different database'),
_('This book was created with the references to database '
'%s.\n\n This makes references to the central person '
'saved in the book invalid.\n\n'
'Therefore, the central person for each item is being set '
'to the active person of the currently opened database.') %
book.get_dbname())
self.book.clear()
self.book_model.clear()
for saved_item in book.get_item_list():
name = saved_item.get_name()
item = BookItem(self.db, name)
item.option_class = saved_item.option_class
# The option values were loaded magically by the book parser.
# But they still need to be applied to the menu options.
opt_dict = item.option_class.handler.options_dict
menu = item.option_class.menu
for optname in opt_dict:
menu_option = menu.get_option_by_name(optname)
if menu_option:
menu_option.set_value(opt_dict[optname])
_initialize_options(item.option_class, self.dbstate, self.uistate)
item.set_style_name(saved_item.get_style_name())
self.book.append_item(item)
data = [
item.get_translated_name(),
item.get_category(),
item.get_name()
]
data[2] = _get_subject(item.option_class, self.db)
self.book_model.add(data)
def on_add_clicked(self, obj):
"""
Add an item to the current selections.
Use the selected available item to get the item's name in the registry.
"""
store, the_iter = self.avail_model.get_selected()
if not the_iter:
return
data = self.avail_model.get_data(the_iter, range(self.avail_nr_cols))
item = BookItem(self.db, data[2])
_initialize_options(item.option_class, self.dbstate, self.uistate)
data[2] = _get_subject(item.option_class, self.db)
self.book_model.add(data)
self.book.append_item(item)
def on_remove_clicked(self, obj):
"""
Remove the item from the current list of selections.
"""
store, the_iter = self.book_model.get_selected()
if not the_iter:
return
row = self.book_model.get_selected_row()
self.book.pop_item(row)
self.book_model.remove(the_iter)
def on_clear_clicked(self, obj):
"""
Clear the whole current book.
"""
self.book_model.clear()
self.book.clear()
def on_up_clicked(self, obj):
"""
Move the currently selected item one row up in the selection list.
"""
row = self.book_model.get_selected_row()
if not row or row == -1:
return
store, the_iter = self.book_model.get_selected()
data = self.book_model.get_data(the_iter, range(self.book_nr_cols))
self.book_model.remove(the_iter)
self.book_model.insert(row - 1, data, None, 1)
item = self.book.pop_item(row)
self.book.insert_item(row - 1, item)
def on_down_clicked(self, obj):
"""
Move the currently selected item one row down in the selection list.
"""
row = self.book_model.get_selected_row()
if row + 1 >= self.book_model.count or row == -1:
return
store, the_iter = self.book_model.get_selected()
data = self.book_model.get_data(the_iter, range(self.book_nr_cols))
self.book_model.remove(the_iter)
self.book_model.insert(row + 1, data, None, 1)
item = self.book.pop_item(row)
self.book.insert_item(row + 1, item)
def on_setup_clicked(self, obj):
"""
Configure currently selected item.
"""
store, the_iter = self.book_model.get_selected()
if not the_iter:
WarningDialog(_('No selected book item'),
_('Please select a book item to configure.'))
return
data = self.book_model.get_data(the_iter, range(self.book_nr_cols))
row = self.book_model.get_selected_row()
item = self.book.get_item(row)
option_class = item.option_class
option_class.handler.set_default_stylesheet_name(item.get_style_name())
item.is_from_saved_book = bool(self.book.get_name())
item_dialog = BookItemDialog(self.dbstate, self.uistate, item,
self.track)
while True:
response = item_dialog.window.run()
if response == gtk.RESPONSE_OK:
# dialog will be closed by connect, now continue work while
# rest of dialog is unresponsive, release when finished
style = option_class.handler.get_default_stylesheet_name()
item.set_style_name(style)
subject = _get_subject(option_class, self.db)
self.book_model.model.set_value(the_iter, 2, subject)
self.book.set_item(row, item)
item_dialog.close()
break
elif response == gtk.RESPONSE_CANCEL:
item_dialog.close()
break
elif response == gtk.RESPONSE_DELETE_EVENT:
#just stop, in ManagedWindow, delete-event is already coupled to
#correct action.
break
def book_button_press(self, obj, event):
"""
Double-click on the current book selection is the same as setup.
Right click evokes the context menu.
"""
if event.type == gtk.gdk._2BUTTON_PRESS and event.button == 1:
self.on_setup_clicked(obj)
elif gui.utils.is_right_click(event):
self.build_book_context_menu(event)
def avail_button_press(self, obj, event):
"""
Double-click on the available selection is the same as add.
Right click evokes the context menu.
"""
if event.type == gtk.gdk._2BUTTON_PRESS and event.button == 1:
self.on_add_clicked(obj)
elif gui.utils.is_right_click(event):
self.build_avail_context_menu(event)
def build_book_context_menu(self, event):
"""Builds the menu with item-centered and book-centered options."""
store, the_iter = self.book_model.get_selected()
if the_iter:
sensitivity = 1
else:
sensitivity = 0
entries = [
(gtk.STOCK_GO_UP, self.on_up_clicked, sensitivity),
(gtk.STOCK_GO_DOWN, self.on_down_clicked, sensitivity),
(_("Setup"), self.on_setup_clicked, sensitivity),
(gtk.STOCK_REMOVE, self.on_remove_clicked, sensitivity),
(None, None, 0),
(gtk.STOCK_CLEAR, self.on_clear_clicked, 1),
(gtk.STOCK_SAVE, self.on_save_clicked, 1),
(gtk.STOCK_OPEN, self.on_open_clicked, 1),
(_("Edit"), self.on_edit_clicked, 1),
]
menu = gtk.Menu()
menu.set_title(_('Book Menu'))
for stock_id, callback, sensitivity in entries:
item = gtk.ImageMenuItem(stock_id)
if callback:
item.connect("activate", callback)
item.set_sensitive(sensitivity)
item.show()
menu.append(item)
menu.popup(None, None, None, event.button, event.time)
def build_avail_context_menu(self, event):
"""Builds the menu with the single Add option."""
store, the_iter = self.avail_model.get_selected()
if the_iter:
sensitivity = 1
else:
sensitivity = 0
entries = [
(gtk.STOCK_ADD, self.on_add_clicked, sensitivity),
]
menu = gtk.Menu()
menu.set_title(_('Available Items Menu'))
for stock_id, callback, sensitivity in entries:
item = gtk.ImageMenuItem(stock_id)
if callback:
item.connect("activate", callback)
item.set_sensitive(sensitivity)
item.show()
menu.append(item)
menu.popup(None, None, None, event.button, event.time)
def on_book_ok_clicked(self, obj):
"""
Run final BookReportDialog with the current book.
"""
if self.book.item_list:
BookReportDialog(self.dbstate, self.uistate, self.book,
BookOptions)
else:
WarningDialog(_('No items'), _('This book has no items.'))
return
self.close()
def on_save_clicked(self, obj):
"""
Save the current book in the xml booklist file.
"""
self.book_list = BookList(self.file, self.db)
name = unicode(self.name_entry.get_text())
if not name:
WarningDialog(
_('No book name'),
_('You are about to save away a book with no name.\n\n'
'Please give it a name before saving it away.'))
return
if name in self.book_list.get_book_names():
from QuestionDialog import QuestionDialog2
q = QuestionDialog2(
_('Book name already exists'),
_('You are about to save away a '
'book with a name which already exists.'), _('Proceed'),
_('Cancel'))
if q.run():
self.book.set_name(name)
else:
return
else:
self.book.set_name(name)
self.book.set_dbname(self.db.get_save_path())
self.book_list.set_book(name, self.book)
self.book_list.save()
def on_open_clicked(self, obj):
"""
Run the BookListDisplay dialog to present the choice of books to open.
"""
self.book_list = BookList(self.file, self.db)
booklistdisplay = BookListDisplay(self.book_list, 1, 0)
booklistdisplay.top.destroy()
book = booklistdisplay.selection
if book:
self.open_book(book)
self.name_entry.set_text(book.get_name())
self.book.set_name(book.get_name())
def on_edit_clicked(self, obj):
"""
Run the BookListDisplay dialog to present the choice of books to delete.
"""
self.book_list = BookList(self.file, self.db)
booklistdisplay = BookListDisplay(self.book_list, 0, 1)
booklistdisplay.top.destroy()
class EditPlace(EditPrimary):
def __init__(self, dbstate, uistate, track, place, callback=None):
EditPrimary.__init__(self, dbstate, uistate, track, place,
dbstate.db.get_place_from_handle,
dbstate.db.get_place_from_gramps_id, callback)
def empty_object(self):
return gen.lib.Place()
def _local_init(self):
self.width_key = 'interface.place-width'
self.height_key = 'interface.place-height'
self.top = Glade()
self.set_window(self.top.toplevel, None,
self.get_menu_title())
tblmloc = self.top.get_object('table19')
notebook = self.top.get_object('notebook3')
#recreate start page as GrampsTab
notebook.remove_page(0)
self.mloc = MainLocTab(self.dbstate, self.uistate, self.track,
_('_Location'), tblmloc)
self.track_ref_for_deletion("mloc")
def get_menu_title(self):
if self.obj and self.obj.get_handle():
title = self.obj.get_title()
dialog_title = _('Place: %s') % title
else:
dialog_title = _('New Place')
return dialog_title
def _connect_signals(self):
self.define_ok_button(self.top.get_object('ok'), self.save)
self.define_cancel_button(self.top.get_object('cancel'))
self.define_help_button(self.top.get_object('help'))
def _connect_db_signals(self):
"""
Connect any signals that need to be connected.
Called by the init routine of the base class (_EditPrimary).
"""
self._add_db_signal('place-rebuild', self._do_close)
self._add_db_signal('place-delete', self.check_for_close)
def _setup_fields(self):
mloc = self.obj.get_main_location()
self.title = MonitoredEntry(self.top.get_object("place_title"),
self.obj.set_title, self.obj.get_title,
self.db.readonly)
self.street = MonitoredEntry(self.top.get_object("street"),
mloc.set_street, mloc.get_street,
self.db.readonly)
self.locality = MonitoredEntry(self.top.get_object("locality"),
mloc.set_locality, mloc.get_locality,
self.db.readonly)
self.city = MonitoredEntry(self.top.get_object("city"),
mloc.set_city, mloc.get_city,
self.db.readonly)
self.gid = MonitoredEntry(self.top.get_object("gid"),
self.obj.set_gramps_id,
self.obj.get_gramps_id, self.db.readonly)
self.privacy = PrivacyButton(self.top.get_object("private"), self.obj,
self.db.readonly)
self.parish = MonitoredEntry(self.top.get_object("parish"),
mloc.set_parish, mloc.get_parish,
self.db.readonly)
self.county = MonitoredEntry(self.top.get_object("county"),
mloc.set_county, mloc.get_county,
self.db.readonly)
self.state = MonitoredEntry(self.top.get_object("state"),
mloc.set_state, mloc.get_state,
self.db.readonly)
self.phone = MonitoredEntry(self.top.get_object("phone"),
mloc.set_phone, mloc.get_phone,
self.db.readonly)
self.postal = MonitoredEntry(self.top.get_object("postal"),
mloc.set_postal_code,
mloc.get_postal_code, self.db.readonly)
self.country = MonitoredEntry(self.top.get_object("country"),
mloc.set_country, mloc.get_country,
self.db.readonly)
self.longitude = MonitoredEntry(
self.top.get_object("lon_entry"),
self.obj.set_longitude, self.obj.get_longitude,
self.db.readonly)
self.longitude.connect("validate", self._validate_coordinate, "lon")
#force validation now with initial entry
self.top.get_object("lon_entry").validate(force=True)
self.latitude = MonitoredEntry(
self.top.get_object("lat_entry"),
self.obj.set_latitude, self.obj.get_latitude,
self.db.readonly)
self.latitude.connect("validate", self._validate_coordinate, "lat")
#force validation now with initial entry
self.top.get_object("lat_entry").validate(force=True)
def _validate_coordinate(self, widget, text, typedeg):
if (typedeg == 'lat') and not conv_lat_lon(text, "0", "ISO-D"):
return ValidationError(_(u"Invalid latitude (syntax: 18\u00b09'") +
_('48.21"S, -18.2412 or -18:9:48.21)'))
elif (typedeg == 'lon') and not conv_lat_lon("0", text, "ISO-D"):
return ValidationError(_(u"Invalid longitude (syntax: 18\u00b09'") +
_('48.21"E, -18.2412 or -18:9:48.21)'))
def build_menu_names(self, place):
return (_('Edit Place'), self.get_menu_title())
def _create_tabbed_pages(self):
"""
Create the notebook tabs and inserts them into the main
window.
"""
notebook = self.top.get_object('notebook3')
self._add_tab(notebook, self.mloc)
self.loc_list = LocationEmbedList(self.dbstate,
self.uistate,
self.track,
self.obj.alt_loc)
self._add_tab(notebook, self.loc_list)
self.track_ref_for_deletion("loc_list")
self.citation_list = CitationEmbedList(self.dbstate,
self.uistate,
self.track,
self.obj.get_citation_list(),
self.get_menu_title())
self._add_tab(notebook, self.citation_list)
self.track_ref_for_deletion("citation_list")
self.note_tab = NoteTab(self.dbstate,
self.uistate,
self.track,
self.obj.get_note_list(),
self.get_menu_title(),
notetype=gen.lib.NoteType.PLACE)
self._add_tab(notebook, self.note_tab)
self.track_ref_for_deletion("note_tab")
self.gallery_tab = GalleryTab(self.dbstate,
self.uistate,
self.track,
self.obj.get_media_list())
self._add_tab(notebook, self.gallery_tab)
self.track_ref_for_deletion("gallery_tab")
self.web_list = WebEmbedList(self.dbstate,
self.uistate,
self.track,
self.obj.get_url_list())
self._add_tab(notebook, self.web_list)
self.track_ref_for_deletion("web_list")
self.backref_list = PlaceBackRefList(self.dbstate,
self.uistate,
self.track,
self.db.find_backlink_handles(self.obj.handle))
self.backref_tab = self._add_tab(notebook, self.backref_list)
self.track_ref_for_deletion("backref_list")
self.track_ref_for_deletion("backref_tab")
self._setup_notebook_tabs(notebook)
def save(self, *obj):
self.ok_button.set_sensitive(False)
if self.object_is_empty():
ErrorDialog(_("Cannot save place"),
_("No data exists for this place. Please "
"enter data or cancel the edit."))
self.ok_button.set_sensitive(True)
return
(uses_dupe_id, id) = self._uses_duplicate_id()
if uses_dupe_id:
prim_object = self.get_from_gramps_id(id)
name = prim_object.get_title()
msg1 = _("Cannot save place. ID already exists.")
msg2 = _("You have attempted to use the existing Gramps ID with "
"value %(id)s. This value is already used by '"
"%(prim_object)s'. Please enter a different ID or leave "
"blank to get the next available ID value.") % {
'id' : id, 'prim_object' : name }
ErrorDialog(msg1, msg2)
self.ok_button.set_sensitive(True)
return
with DbTxn('', self.db) as trans:
if not self.obj.get_handle():
self.db.add_place(self.obj, trans)
msg = _("Add Place (%s)") % self.obj.get_title()
else:
if not self.obj.get_gramps_id():
self.obj.set_gramps_id(self.db.find_next_place_gramps_id())
self.db.commit_place(self.obj, trans)
msg = _("Edit Place (%s)") % self.obj.get_title()
trans.set_description(msg)
self.close()
if self.callback:
self.callback(self.obj)
class ChangeNames(tool.BatchTool, ManagedWindow.ManagedWindow):
def __init__(self, dbstate, uistate, options_class, name, callback=None):
self.label = _('Capitalization changes')
self.cb = callback
ManagedWindow.ManagedWindow.__init__(self, uistate, [], self.__class__)
self.set_window(gtk.Window(), gtk.Label(), '')
tool.BatchTool.__init__(self, dbstate, uistate, options_class, name)
if self.fail:
return
self.progress = ProgressMeter(_('Checking Family Names'), '')
self.progress.set_pass(_('Searching family names'),
len(self.db.get_surname_list()))
self.name_list = []
for name in self.db.get_surname_list():
name.strip()
namesplitSP = name.split()
lSP = len(namesplitSP)
namesplitHY = name.split('-')
lHY = len(namesplitHY)
if lSP == lHY == 1:
if name != name.capitalize():
# Single surname without hyphen(s)
self.name_list.append(name)
#if lSP == 1 and lHY > 1:
#print "LSP==1", name, name.capitalize()
#if name != name.capitalize():
# Single surname with hyphen(s)
#self.name_list.append(name)
if lSP > 1 and lHY == 1:
# more than one string in surname but no hyphen
# check if first string is in prefix_list, if so test for cap in rest
s1 = 0
if namesplitSP[0].lower() in prefix_list:
s1 = 1
for x in xrange(len(namesplitSP) - s1):
# check if any subsurname is not cap
notcap = False
if namesplitSP[s1 + x] != namesplitSP[s1 + x].capitalize():
notcap = True
break
if notcap:
# Multiple surnames possibly after prefix
self.name_list.append(name)
if lHY > 1:
# more than one string in surname but hyphen(s) exists
# check if first string is in prefix_list, if so test for cap
if namesplitSP[0].lower() in prefix_list:
namesplitHY[0] = namesplitHY[0].replace(
namesplitSP[0], '').strip()
for x in xrange(len(namesplitHY)):
# check if any subsurname is not cap
notcap = False
if namesplitHY[x] != namesplitHY[x].capitalize():
notcap = True
break
if notcap:
# Multiple surnames possibly after frefix
self.name_list.append(name)
if uistate:
self.progress.step()
if self.name_list:
self.display()
else:
self.progress.close()
self.close()
OkDialog(_('No modifications made'),
_("No capitalization changes were detected."),
parent=uistate.window)
def name_cap(self, name):
name.strip()
namesplitSP = name.split()
lSP = len(namesplitSP)
lHY = len(name.split('-'))
namesep = ' '
if lHY > 1:
namesep = '-'
namesplitSP = name.replace(namesep, ' ').split()
lSP = len(namesplitSP)
if lSP == lHY == 1:
#if name != name.capitalize():
# Single surname without space(s) or hyphen(s), normal case
return name.capitalize()
else:
# more than one string in surname but no hyphen
# check if first string is in prefix_list, if so CAP the rest
# Names like (von) Kohl(-)Brandt
result = ""
s1 = 0
if namesplitSP[0].lower() in prefix_list:
s1 = 1
result = namesplitSP[0].lower() + ' '
for x in range(lSP - s1):
# CAP all subsurnames
result = result + namesplitSP[s1 + x].capitalize() + namesep
return result[:-1]
def display(self):
self.top = Glade()
window = self.top.toplevel
self.top.connect_signals({
"destroy_passed_object": self.close,
"on_ok_clicked": self.on_ok_clicked,
"on_help_clicked": self.on_help_clicked,
"on_delete_event": self.close,
})
self.list = self.top.get_object("list")
self.set_window(window, self.top.get_object('title'), self.label)
self.model = gtk.ListStore(gobject.TYPE_BOOLEAN, gobject.TYPE_STRING,
gobject.TYPE_STRING)
r = gtk.CellRendererToggle()
r.connect('toggled', self.toggled)
c = gtk.TreeViewColumn(_('Select'), r, active=0)
self.list.append_column(c)
c = gtk.TreeViewColumn(_('Original Name'),
gtk.CellRendererText(),
text=1)
self.list.append_column(c)
c = gtk.TreeViewColumn(_('Capitalization Change'),
gtk.CellRendererText(),
text=2)
self.list.append_column(c)
self.list.set_model(self.model)
self.iter_list = []
self.progress.set_pass(_('Building display'), len(self.name_list))
for name in self.name_list:
handle = self.model.append()
self.model.set_value(handle, 0, True)
self.model.set_value(handle, 1, name)
namecap = self.name_cap(name)
self.model.set_value(handle, 2, namecap)
self.iter_list.append(handle)
self.progress.step()
self.progress.close()
self.show()
def toggled(self, cell, path_string):
path = tuple(map(int, path_string.split(':')))
row = self.model[path]
row[0] = not row[0]
def build_menu_names(self, obj):
return (self.label, None)
def on_help_clicked(self, obj):
"""Display the relevant portion of GRAMPS manual"""
GrampsDisplay.help(WIKI_HELP_PAGE, WIKI_HELP_SEC)
def on_ok_clicked(self, obj):
with DbTxn(_("Capitalization changes"), self.db,
batch=True) as self.trans:
self.db.disable_signals()
changelist = set(
self.model.get_value(node, 1) for node in self.iter_list
if self.model.get_value(node, 0))
#with self.db.get_person_cursor(update=True, commit=True) as cursor:
# for handle, data in cursor:
for handle in self.db.get_person_handles(False):
person = self.db.get_person_from_handle(handle)
#person = Person(data)
change = False
for name in [person.get_primary_name()
] + person.get_alternate_names():
sname = find_surname_name(handle, name.serialize())
if sname in changelist:
change = True
for surn in name.get_surname_list():
sname = self.name_cap(surn.get_surname())
surn.set_surname(sname)
if change:
#cursor.update(handle, person.serialize())
self.db.commit_person(person, transaction=self.trans)
self.db.enable_signals()
self.db.request_rebuild()
# FIXME: this probably needs to be removed, and bookmarks
# should always be rebuilt on a commit_person via signals
# self.parent.bookmarks.redraw()
self.close()
self.cb()
