class InfoDialog: # parent-OK
"""
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()
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.ResponseType.NO:
if task1:
task1()
else:
if task2:
task2()
self.top.destroy()
def get_response(self):
return self.response
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()
class MessageHideDialog: # parent-OK
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)
if parent:
self.top.set_transient_for(parent)
self.top.run()
self.top.destroy()
def update_checkbox(self, obj, constant):
config.set(constant, obj.get_active())
config.save()
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()
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.ResponseType.NO:
self.task1()
elif response == Gtk.ResponseType.YES:
self.task2()
config.set('interface.dont-ask', self.dontask.get_active())
self.top.destroy()
def __init__(self, dbstate, user, options_class, name, callback=None):
uistate = user.uistate
self.dbstate = dbstate
self.uistate = uistate
tool.Tool.__init__(self, dbstate, options_class, name)
ManagedWindow.__init__(self, uistate, [], self)
self.qual = 0
self.filterDialog = Glade(toplevel="filters", also_load=["liststore1"])
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
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.setup_configs('interface.eventcomparison', 640, 220)
self.on_filters_changed('Person')
uistate.connect('filters-changed', self.on_filters_changed)
self.show()
class QuestionDialog: # parent-OK
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.ResponseType.ACCEPT:
task()
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.ResponseType.ACCEPT:
task()
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.ResponseType.NO:
self.task1()
elif response == Gtk.ResponseType.YES:
self.task2()
config.set('interface.dont-ask', self.dontask.get_active())
self.top.destroy()
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 init_gui(self):
# Draw dialog and make it handle everything
self.glade = Glade()
self.auto1 = self.glade.get_object("original")
self.auto2 = self.glade.get_object("new")
# Need to display localized event names
etype = EventType()
event_names = sorted(etype.get_standard_names(), key=glocale.sort_key)
fill_combo(self.auto1, event_names)
fill_combo(self.auto2, event_names)
etype.set_from_xml_str(self.options.handler.options_dict['fromtype'])
self.auto1.get_child().set_text(str(etype))
etype.set_from_xml_str(self.options.handler.options_dict['totype'])
self.auto2.get_child().set_text(str(etype))
window = self.glade.toplevel
self.set_window(window, self.glade.get_object('title'), self.title)
self.glade.connect_signals({
"on_close_clicked": self.close,
"on_apply_clicked": self.on_apply_clicked,
"on_delete_event": self.close,
})
self.show()
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.ResponseType.NO:
if task1:
task1()
else:
if task2:
task2()
self.top.destroy()
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.ResponseType.ACCEPT)
class MissingMediaDialog:
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)
parent_modal = parent.get_modal()
if parent_modal:
parent.set_modal(False)
self.top.show()
self.top.connect('delete_event', self.warn)
response = Gtk.ResponseType.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.ResponseType.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()
if parent and parent_modal:
parent.set_modal(True)
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"),
parent=self.top)
return True
class MissingMediaDialog:
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)
parent_modal = parent.get_modal()
if parent_modal:
parent.set_modal(False)
self.top.show()
self.top.connect('delete_event', self.warn)
response = Gtk.ResponseType.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.ResponseType.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()
if parent and parent_modal:
parent.set_modal(True)
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"),
parent=self.top)
return True
def __init__(self, dbstate, user, options_class, name, callback=None):
uistate = user.uistate
self.label = _('Sources Index')
self.base = os.path.dirname(__file__)
ManagedWindow.__init__(self, uistate, [], self.__class__)
self.set_window(Gtk.Window(), Gtk.Label(), '')
tool.Tool.__init__(self, dbstate, options_class, name)
glade_file = os.path.join(USER_PLUGINS, "SourceIndex", "death.glade")
if gramps.gen.constfunc.lin():
import locale
locale.setlocale(locale.LC_ALL, '')
# This is needed to make gtk.Builder work by specifying the
# translations directory
locale.bindtextdomain("addon", self.base + "/locale")
self.glade = Gtk.Builder()
self.glade.set_translation_domain("addon")
self.glade.add_from_file(glade_file)
from gi.repository import GObject
GObject.GObject.__init__(self.glade)
window = self.glade.get_object('edit_death')
self.set_window(window, self.glade.get_object('title'), self.label)
#self.wit_button = self.glade.get_object('add_wit')
self.ok_button = self.glade.get_object('ok')
self.quit_button = self.glade.get_object('cancel')
else:
# Glade class from gui/glade.py and gui/managedwindow.py
self.top = Glade()
window = self.top.toplevel
self.set_window(window, None, glade_file)
#self.wit_button = self.top.get_object('add_wit')
self.ok_button = self.top.get_object('ok')
self.quit_button = self.top.get_object('cancel')
#self.wit_button.connect('clicked', GtkHandlers.on_witness_clicked)
self.ok_button.connect('clicked', self.close)
self.quit_button.connect('clicked', self.close)
self.window.show()
# tests
filename = os.path.join(USER_PLUGINS, 'SourceIndex', 'test_death.xml')
self.write_xml(filename, 'D0001', 'DATE', 'NOM')
self.parse_xml(filename)
def birth_editor(self, widget, data=None):
"""
Experimental call of the birth editor (see rather 'birth.py')
"""
glade_file = os.path.join(USER_PLUGINS, "SourceIndex", "birth.glade")
if gramps.gen.constfunc.lin():
import locale
locale.setlocale(locale.LC_ALL, '')
# This is needed to make gtk.Builder work by specifying the
# translations directory
locale.bindtextdomain("addon", self.base + "/locale")
self.glade = Gtk.Builder()
self.glade.set_translation_domain("addon")
self.glade.add_from_file(glade_file)
from gi.repository import GObject
GObject.GObject.__init__(self.glade)
b = self.glade.get_object('edit_birth')
self.set_window(b, self.glade.get_object('title'), self.label)
#self.wit_button = self.glade.get_object('add_wit')
self.ok_button = self.glade.get_object('ok')
self.quit_button = self.glade.get_object('cancel')
else:
# Glade class from gui/glade.py and gui/managedwindow.py
top = Glade(glade_file)
b = top.toplevel
self.set_window(b, title=None, text=glade_file)
#self.wit_button = top.get_object('add_wit')
self.ok_button = top.get_object('ok')
self.quit_button = top.get_object('cancel')
#self.wit_button.connect('clicked', GtkHandlers.on_witness_clicked)
self.ok_button.connect('clicked', self.close)
self.quit_button.connect('clicked', self.close)
#add_item()
#close_item()
#close_track()
#b.connect('delete-event', GladeHandlers.on_quit_clicked)
#b.hide()
b.show()
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.setup_configs('interface.changenames', 500, 450)
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 __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)
if parent:
self.top.set_transient_for(parent)
parent_modal = parent.get_modal()
if parent_modal:
parent.set_modal(False)
self.top.run()
self.top.destroy()
if parent and parent_modal:
parent.set_modal(True)
def init_gui(self):
# Draw dialog and make it handle everything
self.glade = Glade()
self.auto1 = self.glade.get_object("original")
self.auto2 = self.glade.get_object("new")
# Need to display localized event names
etype = EventType()
event_names = sorted(etype.get_standard_names(), key=glocale.sort_key)
fill_combo(self.auto1,event_names)
fill_combo(self.auto2,event_names)
etype.set_from_xml_str(self.options.handler.options_dict['fromtype'])
self.auto1.get_child().set_text(str(etype))
etype.set_from_xml_str(self.options.handler.options_dict['totype'])
self.auto2.get_child().set_text(str(etype))
window = self.glade.toplevel
self.set_window(window,self.glade.get_object('title'),self.title)
self.glade.connect_signals({
"on_close_clicked" : self.close,
"on_apply_clicked" : self.on_apply_clicked,
"on_delete_event" : self.close,
})
self.show()
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)
self.parent = parent
if parent:
self.top.set_transient_for(parent)
self.parent_modal = parent.get_modal()
if self.parent_modal:
parent.set_modal(False)
self.top.show()
def __init__(self, dbstate, user, options_class, name, callback=None):
uistate = user.uistate
self.dbstate = dbstate
self.uistate = uistate
tool.Tool.__init__(self, dbstate, options_class, name)
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
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 __init__(self, dbstate, user, options_class, name, callback=None):
uistate = user.uistate
self.label = _("Sources Index")
self.base = os.path.dirname(__file__)
ManagedWindow.__init__(self, uistate, [], self.__class__)
self.set_window(Gtk.Window(), Gtk.Label(), "")
tool.Tool.__init__(self, dbstate, options_class, name)
glade_file = os.path.join(USER_PLUGINS, "SourceIndex", "death.glade")
if gramps.gen.constfunc.lin():
import locale
locale.setlocale(locale.LC_ALL, "")
# This is needed to make gtk.Builder work by specifying the
# translations directory
locale.bindtextdomain("addon", self.base + "/locale")
self.glade = Gtk.Builder()
self.glade.set_translation_domain("addon")
self.glade.add_from_file(glade_file)
from gi.repository import GObject
GObject.GObject.__init__(self.glade)
window = self.glade.get_object("edit_death")
self.set_window(window, self.glade.get_object("title"), self.label)
# self.wit_button = self.glade.get_object('add_wit')
self.ok_button = self.glade.get_object("ok")
self.quit_button = self.glade.get_object("cancel")
else:
# Glade class from gui/glade.py and gui/managedwindow.py
self.top = Glade()
window = self.top.toplevel
self.set_window(window, None, glade_file)
# self.wit_button = self.top.get_object('add_wit')
self.ok_button = self.top.get_object("ok")
self.quit_button = self.top.get_object("cancel")
# self.wit_button.connect('clicked', GtkHandlers.on_witness_clicked)
self.ok_button.connect("clicked", self.close)
self.quit_button.connect("clicked", self.close)
self.window.show()
# tests
filename = os.path.join(USER_PLUGINS, "SourceIndex", "test_death.xml")
self.write_xml(filename, "D0001", "DATE", "NOM")
self.parse_xml(filename)
def display(self):
top_dialog = Glade()
top_dialog.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,
})
window = top_dialog.toplevel
self.set_window(window, top_dialog.get_object('title'), self.label)
self.setup_configs('interface.changenames', 500, 450)
self.clear_button = top_dialog.get_object('checkbutton1')
self.copy_button = top_dialog.get_object('checkbutton2')
self.tag_button = top_dialog.get_object('checkbutton3')
self.treeview = top_dialog.get_object("list")
self.r = Gtk.CellRendererToggle()
self.r.set_property('activatable', True)
self.r.set_property('radio', True)
self.r.connect('toggled', self.toggled)
c = Gtk.TreeViewColumn(_('Select'), self.r, active=1)
self.treeview.append_column(c)
c = Gtk.TreeViewColumn(_('Database'),
Gtk.CellRendererText(),text=2)
self.treeview.append_column(c)
c = Gtk.TreeViewColumn(_('Display'),
Gtk.CellRendererText(),text=3)
self.treeview.append_column(c)
self.selection = self.treeview.get_selection()
self.model = Gtk.ListStore(str, bool, str, str)
self.treeview.set_model(self.model)
self.progress.set_pass(_('Building display'), len(self.name_list))
for handle, title, descr in self.name_list:
self.model.append([handle, title == descr, title, descr])
self.progress.step()
self.progress.close()
self.show()
def census_editor(self, widget, data=None):
"""
Experimental call of the census editor (see rather 'census.py')
"""
glade_file = os.path.join(USER_PLUGINS, "SourceIndex", "census.glade")
if gramps.gen.constfunc.lin():
import locale
locale.setlocale(locale.LC_ALL, '')
# This is needed to make gtk.Builder work by specifying the
# translations directory
locale.bindtextdomain("addon", self.base + "/locale")
self.glade = Gtk.Builder()
self.glade.set_translation_domain("addon")
self.glade.add_from_file(glade_file)
from gi.repository import GObject
GObject.GObject.__init__(self.glade)
c = self.glade.get_object('edit_census')
self.set_window(c, self.glade.get_object('title'), self.label)
self.ok_button = self.glade.get_object('ok')
self.quit_button = self.glade.get_object('cancel')
else:
# Glade class from gui/glade.py and gui/managedwindow.py
top = Glade(glade_file)
c = top.toplevel
self.set_window(c, title=None, text=glade_file)
self.ok_button = top.get_object('ok')
self.quit_button = top.get_object('cancel')
self.ok_button.connect('clicked', self.close)
self.quit_button.connect('clicked', self.close)
#c.hide()
c.show()
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.ResponseType.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.ResponseType.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 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"))
self.setup_configs('interface.ownereditor', 500, 400)
# 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
})
# fetch the popup menu
self.menu = topDialog.get_object("popup_menu")
self.track_ref_for_deletion("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()
def __init__(self, dbstate, uistate, people_list, track):
self.dbstate = dbstate
self.uistate = uistate
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(toplevel="eventcmp")
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
self.set_window(window, self.topDialog.get_object('title'),
_('Event Comparison Results'))
self.setup_configs('interface.eventcomparisonresults', 750, 400)
self.eventlist = self.topDialog.get_object('treeview')
self.sort = Sort(self.db)
self.my_list.sort(key=self.sort.by_last_name_key)
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 __init__(self, dbstate, uistate, track, the_list, the_map, callback):
ManagedWindow.__init__(self,uistate,track,self.__class__)
self.dellist = {}
self.list = the_list
self.map = the_map
self.length = len(self.list)
self.update = callback
self.db = dbstate.db
self.dbstate = dbstate
self.uistate = uistate
top = Glade(toplevel="mergelist")
window = top.toplevel
self.set_window(window, top.get_object('title'),
_('Potential Merges'))
self.setup_configs('interface.duplicatepeopletoolmatches', 500, 350)
self.mlist = top.get_object("mlist")
top.connect_signals({
"destroy_passed_object" : self.close,
"on_do_merge_clicked" : self.on_do_merge_clicked,
"on_help_show_clicked" : self.on_help_clicked,
"on_delete_show_event" : self.close,
"on_merge_ok_clicked" : self.__dummy,
"on_help_clicked" : self.__dummy,
"on_delete_merge_event" : self.__dummy,
"on_delete_event" : self.__dummy,
})
mtitles = [
(_('Rating'),3,75),
(_('First Person'),1,200),
(_('Second Person'),2,200),
('',-1,0)
]
self.list = ListModel(self.mlist,mtitles,
event_func=self.on_do_merge_clicked)
self.redraw()
self.show()
def display(self):
top_dialog = Glade()
top_dialog.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,
})
window = top_dialog.toplevel
self.set_window(window, top_dialog.get_object('title'), self.label)
self.setup_configs('interface.changenames', 500, 450)
self.clear_button = top_dialog.get_object('checkbutton1')
self.copy_button = top_dialog.get_object('checkbutton2')
self.tag_button = top_dialog.get_object('checkbutton3')
self.treeview = top_dialog.get_object("list")
self.r = Gtk.CellRendererToggle()
self.r.set_property('activatable', True)
self.r.set_property('radio', True)
self.r.connect('toggled', self.toggled)
c = Gtk.TreeViewColumn(_('Select'), self.r, active=1)
self.treeview.append_column(c)
c = Gtk.TreeViewColumn(_('Database'),
Gtk.CellRendererText(),text=2)
self.treeview.append_column(c)
c = Gtk.TreeViewColumn(_('Display'),
Gtk.CellRendererText(),text=3)
self.treeview.append_column(c)
self.selection = self.treeview.get_selection()
self.model = Gtk.ListStore(str, bool, str, str)
self.treeview.set_model(self.model)
self.progress.set_pass(_('Building display'), len(self.name_list))
for handle, title, descr in self.name_list:
self.model.append([handle, title == descr, title, descr])
self.progress.step()
self.progress.close()
self.show()
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"))
self.setup_configs('interface.ownereditor', 500, 400)
# 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})
# fetch the popup menu
self.menu = topDialog.get_object("popup_menu")
self.track_ref_for_deletion("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()
def __init__(self, dbstate, user, options_class, name, callback=None):
uistate = user.uistate
tool.Tool.__init__(self, dbstate, options_class, name)
ManagedWindow.__init__(self, uistate, [],
self.__class__)
self.dbstate = dbstate
self.uistate = uistate
self.map = {}
self.list = []
self.index = 0
self.merger = None
self.mergee = None
self.removed = {}
self.update = callback
self.use_soundex = 1
top = Glade(toplevel="finddupes", also_load=["liststore1"])
# retrieve options
threshold = self.options.handler.options_dict['threshold']
use_soundex = self.options.handler.options_dict['soundex']
my_menu = Gtk.ListStore(str, object)
for val in sorted(_val2label):
my_menu.append([_val2label[val], val])
self.soundex_obj = top.get_object("soundex")
self.soundex_obj.set_active(use_soundex)
self.soundex_obj.show()
self.menu = top.get_object("menu")
self.menu.set_model(my_menu)
self.menu.set_active(0)
window = top.toplevel
self.set_window(window, top.get_object('title'),
_('Find Possible Duplicate People'))
self.setup_configs('interface.duplicatepeopletool', 350, 220)
top.connect_signals({
"on_do_merge_clicked" : self.__dummy,
"on_help_show_clicked" : self.__dummy,
"on_delete_show_event" : self.__dummy,
"on_merge_ok_clicked" : self.on_merge_ok_clicked,
"destroy_passed_object" : self.close,
"on_help_clicked" : self.on_help_clicked,
"on_delete_merge_event" : self.close,
"on_delete_event" : self.close,
})
self.show()
class QuestionDialog2:
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)
self.parent = parent
if parent:
self.top.set_transient_for(parent)
self.parent_modal = parent.get_modal()
if self.parent_modal:
parent.set_modal(False)
self.top.show()
def run(self):
response = self.top.run()
self.top.destroy()
if self.parent and self.parent_modal:
self.parent.set_modal(True)
return (response == Gtk.ResponseType.ACCEPT)
def __init__(self, dbstate, user, options_class, name, callback=None):
uistate = user.uistate
self.label = _('Sources Index')
self.base = os.path.dirname(__file__)
ManagedWindow.__init__(self, uistate,[], self.__class__)
self.set_window(Gtk.Window(),Gtk.Label(),'')
tool.Tool.__init__(self, dbstate, options_class, name)
glade_file = os.path.join(USER_PLUGINS, "SourceIndex", "witness.glade")
if gramps.gen.constfunc.lin():
import locale
locale.setlocale(locale.LC_ALL, '')
# This is needed to make gtk.Builder work by specifying the
# translations directory
locale.bindtextdomain("addon", self.base + "/locale")
self.glade = Gtk.Builder()
self.glade.set_translation_domain("addon")
self.glade.add_from_file(glade_file)
from gi.repository import GObject
GObject.GObject.__init__(self.glade)
window = self.glade.get_object('witness_editor')
self.set_window(window, self.glade.get_object('title'), self.label)
self.ok_button = self.glade.get_object('ok')
self.quit_button = self.glade.get_object('cancel')
else:
# Glade class from gui/glade.py and gui/managedwindow.py
self.top = Glade()
window = self.top.toplevel
self.set_window(window, None, glade_file)
self.ok_button = self.top.get_object('ok')
self.quit_button = self.top.get_object('cancel')
self.ok_button.connect('clicked', self.close)
self.quit_button.connect('clicked', self.close)
self.window.show()
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 __init__(self, database):
self.db = database
self.url = None
self.connector = None
top = Glade("phpgedview.glade")
self.url_entry = top.get_object('url_entry')
self.version_label = top.get_object('version_label')
self.version_label.set_text("")
self.file_combo = top.get_object('file_combo')
self.file_combo.hide()
self.username_entry = top.get_object('username_entry')
self.username_entry.hide()
self.password_entry = top.get_object('password_entry')
self.password_entry.hide()
self.ok_button = top.get_object('ok_button')
self.ok_button.connect("activate", self.on_next_pressed_cb)
self.ok_button.connect("button_release_event", self.on_next_pressed_cb)
self.progressbar = top.get_object('progressbar')
self.dialog = top.toplevel
self.dialog.show()
def init(self):
g = Glade()
top = g.get_object('top')
self.gui.get_container_widget().remove(self.gui.textview)
self.gui.get_container_widget().add_with_viewport(top)
self.person1_label = g.get_object('person1_label')
self.person2_label = g.get_object('person2_label')
"""
button_start = g.get_object('button_start')
button_pause = g.get_object('button_pause')
button_continue = g.get_object('button_continue')
button_swap = g.get_object('button_swap')
button_copy = g.get_object('button_copy')
button_start.connect("clicked", self.cb_search)
button_start.set_sensitive(False)
button_pause.connect("clicked", self.interrupt)
button_pause.set_sensitive(False)
button_continue.connect("clicked", self.resume)
button_continue.set_sensitive(False)
button_swap.connect("clicked", self.cb_swap)
button_swap.set_sensitive(False)
button_copy.connect("clicked", lambda widget: \
self.gui.pane.pageview.copy_to_clipboard('Person', self.selected_handles))
button_copy.set_sensitive(False)
self.buttons1 = [
button_start,
button_swap,
]
self.buttons2 = [
button_pause,
button_continue,
button_copy,
]
button_person2.connect("clicked", self.cb_select2)
button_person1.connect("clicked", self.cb_select1)
"""
button_fetch_plugin_list = g.get_object('button_fetch_plugin_list')
button_fetch_plugin_list.connect("clicked", self.cb_fetch_plugin_list)
self.status_msg = g.get_object('status_msg')
top.show_all()
self.top = top
self.g = g
self.cb_fetch_plugin_list(None)
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.setup_configs('interface.changenames', 500, 450)
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 __init__(self, dbstate, user, options_class, name, callback=None):
uistate = user.uistate
tool.Tool.__init__(self, dbstate, options_class, name)
ManagedWindow.__init__(self, uistate, [],
self.__class__)
self.dbstate = dbstate
self.uistate = uistate
self.map = {}
self.list = []
self.index = 0
self.merger = None
self.mergee = None
self.removed = {}
self.update = callback
self.use_soundex = 1
top = Glade()
# retrieve options
threshold = self.options.handler.options_dict['threshold']
use_soundex = self.options.handler.options_dict['soundex']
my_menu = Gtk.ListStore(str, object)
for val in sorted(_val2label):
my_menu.append([_val2label[val], val])
self.soundex_obj = top.get_object("soundex")
self.soundex_obj.set_active(use_soundex)
self.soundex_obj.show()
self.menu = top.get_object("menu")
self.menu.set_model(my_menu)
self.menu.set_active(0)
window = top.toplevel
self.set_window(window, top.get_object('title'),
_('Find Possible Duplicate People'))
self.setup_configs('interface.duplicatepeopletool', 350, 220)
top.connect_signals({
"on_do_merge_clicked" : self.__dummy,
"on_help_show_clicked" : self.__dummy,
"on_delete_show_event" : self.__dummy,
"on_merge_ok_clicked" : self.on_merge_ok_clicked,
"destroy_passed_object" : self.close,
"on_help_clicked" : self.on_help_clicked,
"on_delete_merge_event" : self.close,
"on_delete_event" : self.close,
})
self.show()
def __init__(self,dbstate,uistate,people_list,track):
self.dbstate = dbstate
self.uistate = uistate
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
self.set_window(window, self.topDialog.get_object('title'),
_('Event Comparison Results'))
self.setup_configs('interface.eventcomparisonresults', 750, 400)
self.eventlist = self.topDialog.get_object('treeview')
self.sort = Sort(self.db)
self.my_list.sort(key=self.sort.by_last_name_key)
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 __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.ResponseType.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.ResponseType.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 __init__(self, database):
self.db = database
self.url = None
self.connector = None
top = Glade("phpgedview.glade")
self.url_entry = top.get_object('url_entry')
self.version_label = top.get_object('version_label')
self.version_label.set_text("")
self.file_combo = top.get_object('file_combo')
self.file_combo.hide()
self.username_entry = top.get_object('username_entry')
self.username_entry.hide()
self.password_entry = top.get_object('password_entry')
self.password_entry.hide()
self.ok_button = top.get_object('ok_button')
self.ok_button.connect("activate", self.on_next_pressed_cb)
self.ok_button.connect("button_release_event", self.on_next_pressed_cb)
self.progressbar = top.get_object('progressbar')
self.dialog = top.toplevel
self.dialog.show()
def run(self):
top = Glade(toplevel="mergecitations", also_load=["liststore1"])
# 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.set_transient_for(self.user.uistate.window)
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."))
self.setup_configs('interface.mergecitations', 700, 230)
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()
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 __init__(self, dbstate, uistate, track, the_list, the_map, callback):
ManagedWindow.__init__(self,uistate,track,self.__class__)
self.dellist = set()
self.list = the_list
self.map = the_map
self.length = len(self.list)
self.update = callback
self.db = dbstate.db
self.dbstate = dbstate
self.uistate = uistate
top = Glade(toplevel="mergelist")
window = top.toplevel
self.set_window(window, top.get_object('title'),
_('Potential Merges'))
self.setup_configs('interface.duplicatepeopletoolmatches', 500, 350)
self.mlist = top.get_object("mlist")
top.connect_signals({
"destroy_passed_object" : self.close,
"on_do_merge_clicked" : self.on_do_merge_clicked,
"on_help_show_clicked" : self.on_help_clicked,
"on_delete_show_event" : self.close,
"on_merge_ok_clicked" : self.__dummy,
"on_help_clicked" : self.__dummy,
"on_delete_merge_event" : self.__dummy,
"on_delete_event" : self.__dummy,
})
self.db.connect("person-delete", self.person_delete)
mtitles = [
(_('Rating'),3,75),
(_('First Person'),1,200),
(_('Second Person'),2,200),
('',-1,0)
]
self.list = ListModel(self.mlist,mtitles,
event_func=self.on_do_merge_clicked)
self.redraw()
self.show()
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.set_transient_for(self.user.uistate.window)
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."))
self.setup_configs('interface.mergecitations', 700, 230)
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 RelCalc(tool.Tool, ManagedWindow):
def __init__(self, dbstate, user, options_class, name, callback=None):
uistate = user.uistate
"""
Relationship calculator class.
"""
tool.Tool.__init__(self, dbstate, options_class, name)
ManagedWindow.__init__(self,uistate,[],self.__class__)
#set the columns to see
for data in BasePersonView.CONFIGSETTINGS:
if data[0] == 'columns.rank':
colord = data[1]
elif data[0] == 'columns.visible':
colvis = data[1]
elif data[0] == 'columns.size':
colsize = data[1]
self.colord = []
for col, size in zip(colord, colsize):
if col in colvis:
self.colord.append((1, col, size))
else:
self.colord.append((0, col, size))
self.dbstate = dbstate
self.relationship = get_relationship_calculator(glocale)
self.relationship.connect_db_signals(dbstate)
self.glade = Glade()
self.person = self.db.get_person_from_handle(
uistate.get_active('Person'))
name = ''
if self.person:
name = name_displayer.display(self.person)
self.title = _('Relationship calculator: %(person_name)s'
) % {'person_name' : name}
window = self.glade.toplevel
self.titlelabel = self.glade.get_object('title')
self.set_window(window, self.titlelabel,
_('Relationship to %(person_name)s'
) % {'person_name' : name},
self.title)
self.setup_configs('interface.relcalc', 600, 400)
self.tree = self.glade.get_object("peopleList")
self.text = self.glade.get_object("text1")
self.textbuffer = Gtk.TextBuffer()
self.text.set_buffer(self.textbuffer)
self.model = PersonTreeModel(self.db, uistate)
self.tree.set_model(self.model)
self.tree.connect('key-press-event', self._key_press)
self.selection = self.tree.get_selection()
self.selection.set_mode(Gtk.SelectionMode.SINGLE)
#keep reference of column so garbage collection works
self.columns = []
for pair in self.colord:
if not pair[0]:
continue
name = column_names[pair[1]]
column = Gtk.TreeViewColumn(name, Gtk.CellRendererText(),
markup=pair[1])
column.set_resizable(True)
column.set_min_width(60)
column.set_sizing(Gtk.TreeViewColumnSizing.GROW_ONLY)
self.tree.append_column(column)
#keep reference of column so garbage collection works
self.columns.append(column)
self.sel = self.tree.get_selection()
self.changedkey = self.sel.connect('changed',self.on_apply_clicked)
self.closebtn = self.glade.get_object("button5")
self.closebtn.connect('clicked', self.close)
if not self.person:
self.window.hide()
ErrorDialog(_('Active person has not been set'),
_('You must select an active person for this '
'tool to work properly.'),
parent=uistate.window)
self.close()
return
self.show()
def close(self, *obj):
""" Close relcalc tool. Remove non-gtk connections so garbage
collection can do its magic.
"""
self.relationship.disconnect_db_signals(self.dbstate)
self.sel.disconnect(self.changedkey)
ManagedWindow.close(self, *obj)
def build_menu_names(self, obj):
return (_("Relationship Calculator tool"),None)
def on_apply_clicked(self, obj):
model, iter_ = self.tree.get_selection().get_selected()
if not iter_:
return
other_person = None
handle = model.get_handle_from_iter(iter_)
if handle:
other_person = self.db.get_person_from_handle(handle)
if other_person is None:
self.textbuffer.set_text("")
return
#now determine the relation, and print it out
rel_strings, common_an = self.relationship.get_all_relationships(
self.db, self.person, other_person)
p1 = name_displayer.display(self.person)
p2 = name_displayer.display(other_person)
text = []
if other_person is None:
pass
elif self.person.handle == other_person.handle:
rstr = _("%(person)s and %(active_person)s are the same person.") % {
'person': p1,
'active_person': p2
}
text.append((rstr, ""))
elif len(rel_strings) == 0:
rstr = _("%(person)s and %(active_person)s are not related.") % {
'person': p2,
'active_person': p1
}
text.append((rstr, ""))
for rel_string, common in zip(rel_strings, common_an):
rstr = _("%(person)s is the %(relationship)s of %(active_person)s."
) % {'person': p2,
'relationship': rel_string,
'active_person': p1
}
length = len(common)
if length == 1:
person = self.db.get_person_from_handle(common[0])
if common[0] in [other_person.handle, self.person.handle]:
commontext = ''
else :
name = name_displayer.display(person)
commontext = " " + _("Their common ancestor is %s.") % name
elif length == 2:
p1c = self.db.get_person_from_handle(common[0])
p2c = self.db.get_person_from_handle(common[1])
p1str = name_displayer.display(p1c)
p2str = name_displayer.display(p2c)
commontext = " " + _("Their common ancestors are %(ancestor1)s and %(ancestor2)s.") % {
'ancestor1': p1str,
'ancestor2': p2str
}
elif length > 2:
index = 0
commontext = " " + _("Their common ancestors are: ")
for person_handle in common:
person = self.db.get_person_from_handle(person_handle)
if index:
# TODO for Arabic, should the next comma be translated?
commontext += ", "
commontext += name_displayer.display(person)
index += 1
commontext += "."
else:
commontext = ""
text.append((rstr, commontext))
textval = ""
for val in text:
textval += "%s %s\n" % (val[0], val[1])
self.textbuffer.set_text(textval)
def _key_press(self, obj, event):
if event.keyval in (Gdk.KEY_Return, Gdk.KEY_KP_Enter):
store, paths = self.selection.get_selected_rows()
if paths and len(paths[0]) == 1 :
if self.tree.row_expanded(paths[0]):
self.tree.collapse_row(paths[0])
else:
self.tree.expand_row(paths[0], 0)
return True
return False
class ChangeNames(tool.BatchTool, ManagedWindow):
def __init__(self, dbstate, user, options_class, name, callback=None):
uistate = user.uistate
self.label = _('Capitalization changes')
self.cb = callback
ManagedWindow.__init__(self,uistate,[],self.__class__)
self.set_window(Gtk.Window(),Gtk.Label(),'')
tool.BatchTool.__init__(self, dbstate, user, 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 range(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 range(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"""
display_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()
class RemoveUnused(tool.Tool, ManagedWindow, UpdateCallback):
MARK_COL = 0
OBJ_ID_COL = 1
OBJ_NAME_COL = 2
OBJ_TYPE_COL = 3
OBJ_HANDLE_COL = 4
def __init__(self, dbstate, user, options_class, name, callback=None):
uistate = user.uistate
self.title = _('Unused Objects')
tool.Tool.__init__(self, dbstate, options_class, name)
if self.db.readonly:
return
ManagedWindow.__init__(self, uistate,[], self.__class__)
UpdateCallback.__init__(self, self.uistate.pulse_progressbar)
self.dbstate = dbstate
self.uistate = uistate
self.tables = {
'events' : {'get_func': self.db.get_event_from_handle,
'remove' : self.db.remove_event,
'get_text': self.get_event_text,
'editor' : 'EditEvent',
'icon' : 'gramps-event',
'name_ix' : 4},
'sources' : {'get_func': self.db.get_source_from_handle,
'remove' : self.db.remove_source,
'get_text': None,
'editor' : 'EditSource',
'icon' : 'gramps-source',
'name_ix' : 2},
'places' : {'get_func': self.db.get_place_from_handle,
'remove' : self.db.remove_place,
'get_text': None,
'editor' : 'EditPlace',
'icon' : 'gramps-place',
'name_ix' : 2},
'media' : {'get_func': self.db.get_object_from_handle,
'remove' : self.db.remove_object,
'get_text': None,
'editor' : 'EditMedia',
'icon' : 'gramps-media',
'name_ix' : 4},
'repos' : {'get_func': self.db.get_repository_from_handle,
'remove' : self.db.remove_repository,
'get_text': None,
'editor' : 'EditRepository',
'icon' : 'gramps-repository',
'name_ix' : 3},
'notes' : {'get_func': self.db.get_note_from_handle,
'remove' : self.db.remove_note,
'get_text': self.get_note_text,
'editor' : 'EditNote',
'icon' : 'gramps-notes',
'name_ix' : 2},
}
self.init_gui()
def init_gui(self):
self.top = Glade()
window = self.top.toplevel
self.set_window(window, self.top.get_object('title'), self.title)
self.events_box = self.top.get_object('events_box')
self.sources_box = self.top.get_object('sources_box')
self.places_box = self.top.get_object('places_box')
self.media_box = self.top.get_object('media_box')
self.repos_box = self.top.get_object('repos_box')
self.notes_box = self.top.get_object('notes_box')
self.find_button = self.top.get_object('find_button')
self.remove_button = self.top.get_object('remove_button')
self.events_box.set_active(self.options.handler.options_dict['events'])
self.sources_box.set_active(
self.options.handler.options_dict['sources'])
self.places_box.set_active(
self.options.handler.options_dict['places'])
self.media_box.set_active(self.options.handler.options_dict['media'])
self.repos_box.set_active(self.options.handler.options_dict['repos'])
self.notes_box.set_active(self.options.handler.options_dict['notes'])
self.warn_tree = self.top.get_object('warn_tree')
self.warn_tree.connect('button_press_event', self.double_click)
self.selection = self.warn_tree.get_selection()
self.mark_button = self.top.get_object('mark_button')
self.mark_button.connect('clicked', self.mark_clicked)
self.unmark_button = self.top.get_object('unmark_button')
self.unmark_button.connect('clicked', self.unmark_clicked)
self.invert_button = self.top.get_object('invert_button')
self.invert_button.connect('clicked', self.invert_clicked)
self.real_model = Gtk.ListStore(GObject.TYPE_BOOLEAN,
GObject.TYPE_STRING,
GObject.TYPE_STRING,
GObject.TYPE_STRING,
GObject.TYPE_STRING)
self.sort_model = self.real_model.sort_new_with_model()
self.warn_tree.set_model(self.sort_model)
self.renderer = Gtk.CellRendererText()
self.img_renderer = Gtk.CellRendererPixbuf()
self.bool_renderer = Gtk.CellRendererToggle()
self.bool_renderer.connect('toggled', self.selection_toggled)
# Add mark column
mark_column = Gtk.TreeViewColumn(_('Mark'), self.bool_renderer,
active=RemoveUnused.MARK_COL)
mark_column.set_sort_column_id(RemoveUnused.MARK_COL)
self.warn_tree.append_column(mark_column)
# Add image column
img_column = Gtk.TreeViewColumn(None, self.img_renderer )
img_column.set_cell_data_func(self.img_renderer, self.get_image)
self.warn_tree.append_column(img_column)
# Add column with object gramps_id
id_column = Gtk.TreeViewColumn(_('ID'), self.renderer,
text=RemoveUnused.OBJ_ID_COL)
id_column.set_sort_column_id(RemoveUnused.OBJ_ID_COL)
self.warn_tree.append_column(id_column)
# Add column with object name
name_column = Gtk.TreeViewColumn(_('Name'), self.renderer,
text=RemoveUnused.OBJ_NAME_COL)
name_column.set_sort_column_id(RemoveUnused.OBJ_NAME_COL)
self.warn_tree.append_column(name_column)
self.top.connect_signals({
"destroy_passed_object" : self.close,
"on_remove_button_clicked": self.do_remove,
"on_find_button_clicked" : self.find,
"on_delete_event" : self.close,
})
self.dc_label = self.top.get_object('dc_label')
self.sensitive_list = [self.warn_tree, self.mark_button,
self.unmark_button, self.invert_button,
self.dc_label, self.remove_button]
for item in self.sensitive_list:
item.set_sensitive(False)
self.show()
def build_menu_names(self, obj):
return (self.title, None)
def find(self, obj):
self.options.handler.options_dict.update(
events = self.events_box.get_active(),
sources = self.sources_box.get_active(),
places = self.places_box.get_active(),
media = self.media_box.get_active(),
repos = self.repos_box.get_active(),
notes = self.notes_box.get_active(),
)
for item in self.sensitive_list:
item.set_sensitive(True)
self.uistate.set_busy_cursor(True)
self.uistate.progress.show()
self.window.get_window().set_cursor(Gdk.Cursor.new(Gdk.CursorType.WATCH))
self.real_model.clear()
self.collect_unused()
self.uistate.progress.hide()
self.uistate.set_busy_cursor(False)
self.window.get_window().set_cursor(None)
self.reset()
# Save options
self.options.handler.save_options()
def collect_unused(self):
# Run through all requested tables and check all objects
# for being referenced some place. If not, add_results on them.
db = self.db
tables = (
('events', db.get_event_cursor, db.get_number_of_events),
('sources', db.get_source_cursor, db.get_number_of_sources),
('places', db.get_place_cursor, db.get_number_of_places),
('media', db.get_media_cursor, db.get_number_of_media_objects),
('repos', db.get_repository_cursor, db.get_number_of_repositories),
('notes', db.get_note_cursor, db.get_number_of_notes),
)
for (the_type, cursor_func, total_func) in tables:
if not self.options.handler.options_dict[the_type]:
# This table was not requested. Skip it.
continue
with cursor_func() as cursor:
self.set_total(total_func())
fbh = db.find_backlink_handles
for handle, data in cursor:
if not any(h for h in fbh(handle)):
self.add_results((the_type, handle.decode('utf-8'),
data))
self.update()
self.reset()
def do_remove(self, obj):
with DbTxn(_("Remove unused objects"), self.db, batch=False) as trans:
self.db.disable_signals()
for row_num in range(len(self.real_model)-1, -1, -1):
path = (row_num,)
row = self.real_model[path]
if not row[RemoveUnused.MARK_COL]:
continue
the_type = row[RemoveUnused.OBJ_TYPE_COL]
handle = row[RemoveUnused.OBJ_HANDLE_COL]
remove_func = self.tables[the_type]['remove']
remove_func(handle, trans)
self.real_model.remove(row.iter)
self.db.enable_signals()
self.db.request_rebuild()
def selection_toggled(self, cell, path_string):
sort_path = tuple(map(int, path_string.split(':')))
real_path = self.sort_model.convert_path_to_child_path(Gtk.TreePath(sort_path))
row = self.real_model[real_path]
row[RemoveUnused.MARK_COL] = not row[RemoveUnused.MARK_COL]
self.real_model.row_changed(real_path, row.iter)
def mark_clicked(self, mark_button):
for row_num in range(len(self.real_model)):
path = (row_num,)
row = self.real_model[path]
row[RemoveUnused.MARK_COL] = True
def unmark_clicked(self, unmark_button):
for row_num in range(len(self.real_model)):
path = (row_num,)
row = self.real_model[path]
row[RemoveUnused.MARK_COL] = False
def invert_clicked(self, invert_button):
for row_num in range(len(self.real_model)):
path = (row_num,)
row = self.real_model[path]
row[RemoveUnused.MARK_COL] = not row[RemoveUnused.MARK_COL]
def double_click(self, obj, event):
if event.type == Gdk.EventType._2BUTTON_PRESS and event.button == 1:
(model, node) = self.selection.get_selected()
if not node:
return
sort_path = self.sort_model.get_path(node)
real_path = self.sort_model.convert_path_to_child_path(sort_path)
row = self.real_model[real_path]
the_type = row[RemoveUnused.OBJ_TYPE_COL]
handle = row[RemoveUnused.OBJ_HANDLE_COL]
self.call_editor(the_type, handle)
def call_editor(self, the_type, handle):
try:
obj = self.tables[the_type]['get_func'](handle)
editor_str = 'from gramps.gui.editors import %s as editor' % (
self.tables[the_type]['editor']
)
exec(editor_str, globals())
editor(self.dbstate, self.uistate, [], obj)
except WindowActiveError:
pass
def get_image(self, column, cell, model, iter, user_data=None):
the_type = model.get_value(iter, RemoveUnused.OBJ_TYPE_COL)
the_icon = self.tables[the_type]['icon']
cell.set_property('icon-name', the_icon)
def add_results(self, results):
(the_type, handle, data) = results
gramps_id = data[1]
# if we have a function that will return to us some type
# of text summary, then we should use it; otherwise we'll
# use the generic field index provided in the tables above
if self.tables[the_type]['get_text']:
text = self.tables[the_type]['get_text'](the_type, handle, data)
else:
# grab the text field index we know about, and hope
# it represents something useful to the user
name_ix = self.tables[the_type]['name_ix']
text = data[name_ix]
# insert a new row into the table
self.real_model.append(row=[False, gramps_id, text, the_type, handle])
def get_event_text(self, the_type, handle, data):
"""
Come up with a short line of text that we can use as
a summary to represent this event.
"""
# get the event:
event = self.tables[the_type]['get_func'](handle)
# first check to see if the event has a descriptive name
text = event.get_description() # (this is rarely set for events)
# if we don't have a description...
if text == '':
# ... then we merge together several fields
# get the event type (marriage, birth, death, etc.)
text = str(event.get_type())
# see if there is a date
date = _dd.display(event.get_date_object())
if date != '':
text += '; %s' % date
# see if there is a place
if event.get_place_handle():
text += '; %s' % _pd.display_event(self.db, event)
return text
def get_note_text(self, the_type, handle, data):
"""
We need just the first few words of a note as a summary.
"""
# get the note object
note = self.tables[the_type]['get_func'](handle)
# get the note text; this ignores (discards) formatting
text = note.get()
# convert whitespace to a single space
text = " ".join(text.split())
# if the note is too long, truncate it
if len(text) > 80:
text = text[:80] + "..."
return text
def init_gui(self):
self.top = Glade()
window = self.top.toplevel
self.set_window(window, self.top.get_object('title'), self.title)
self.events_box = self.top.get_object('events_box')
self.sources_box = self.top.get_object('sources_box')
self.places_box = self.top.get_object('places_box')
self.media_box = self.top.get_object('media_box')
self.repos_box = self.top.get_object('repos_box')
self.notes_box = self.top.get_object('notes_box')
self.find_button = self.top.get_object('find_button')
self.remove_button = self.top.get_object('remove_button')
self.events_box.set_active(self.options.handler.options_dict['events'])
self.sources_box.set_active(
self.options.handler.options_dict['sources'])
self.places_box.set_active(
self.options.handler.options_dict['places'])
self.media_box.set_active(self.options.handler.options_dict['media'])
self.repos_box.set_active(self.options.handler.options_dict['repos'])
self.notes_box.set_active(self.options.handler.options_dict['notes'])
self.warn_tree = self.top.get_object('warn_tree')
self.warn_tree.connect('button_press_event', self.double_click)
self.selection = self.warn_tree.get_selection()
self.mark_button = self.top.get_object('mark_button')
self.mark_button.connect('clicked', self.mark_clicked)
self.unmark_button = self.top.get_object('unmark_button')
self.unmark_button.connect('clicked', self.unmark_clicked)
self.invert_button = self.top.get_object('invert_button')
self.invert_button.connect('clicked', self.invert_clicked)
self.real_model = Gtk.ListStore(GObject.TYPE_BOOLEAN,
GObject.TYPE_STRING,
GObject.TYPE_STRING,
GObject.TYPE_STRING,
GObject.TYPE_STRING)
self.sort_model = self.real_model.sort_new_with_model()
self.warn_tree.set_model(self.sort_model)
self.renderer = Gtk.CellRendererText()
self.img_renderer = Gtk.CellRendererPixbuf()
self.bool_renderer = Gtk.CellRendererToggle()
self.bool_renderer.connect('toggled', self.selection_toggled)
# Add mark column
mark_column = Gtk.TreeViewColumn(_('Mark'), self.bool_renderer,
active=RemoveUnused.MARK_COL)
mark_column.set_sort_column_id(RemoveUnused.MARK_COL)
self.warn_tree.append_column(mark_column)
# Add image column
img_column = Gtk.TreeViewColumn(None, self.img_renderer )
img_column.set_cell_data_func(self.img_renderer, self.get_image)
self.warn_tree.append_column(img_column)
# Add column with object gramps_id
id_column = Gtk.TreeViewColumn(_('ID'), self.renderer,
text=RemoveUnused.OBJ_ID_COL)
id_column.set_sort_column_id(RemoveUnused.OBJ_ID_COL)
self.warn_tree.append_column(id_column)
# Add column with object name
name_column = Gtk.TreeViewColumn(_('Name'), self.renderer,
text=RemoveUnused.OBJ_NAME_COL)
name_column.set_sort_column_id(RemoveUnused.OBJ_NAME_COL)
self.warn_tree.append_column(name_column)
self.top.connect_signals({
"destroy_passed_object" : self.close,
"on_remove_button_clicked": self.do_remove,
"on_find_button_clicked" : self.find,
"on_delete_event" : self.close,
})
self.dc_label = self.top.get_object('dc_label')
self.sensitive_list = [self.warn_tree, self.mark_button,
self.unmark_button, self.invert_button,
self.dc_label, self.remove_button]
for item in self.sensitive_list:
item.set_sensitive(False)
self.show()
def draw_window(self):
"""Draw the dialog box."""
# Copied from PlaceCleanup:
# Found out that Glade does not support translations for plugins, so
# have to do it manually.
import os
import locale
import ctypes
from gramps.gen.constfunc import win
base = os.path.dirname(__file__)
glade_file = base + os.sep + "nameeditortool.glade"
# This is needed to make gtk.Builder work by specifying the
# translations directory in a separate 'domain'
try:
localedomain = "addon"
localepath = base + os.sep + "locale"
if hasattr(locale, 'bindtextdomain'):
libintl = locale
elif win(): # apparently wants strings in bytes
localedomain = localedomain.encode('utf-8')
localepath = localepath.encode('utf-8')
libintl = ctypes.cdll.LoadLibrary('libintl-8.dll')
else: # mac, No way for author to test this
libintl = ctypes.cdll.LoadLibrary('libintl.dylib')
libintl.bindtextdomain(localedomain, localepath)
libintl.textdomain(localedomain)
libintl.bind_textdomain_codeset(localedomain, "UTF-8")
# and finally, tell Gtk Builder to use that domain
self.top.set_translation_domain("addon")
except (OSError, AttributeError):
# Will leave it in English
print("Localization of PlaceCleanup failed!")
glade = Glade()
self.glade = glade
self.top = glade.toplevel
columns = [
(_('Id'), 0, 80),
(_('Gender'), 1, 100),
(_('Prefix'), 2, 100),
(_('Surname'), 3, 200),
(_('First name'), 4, 200),
(_('Suffix'), 5, 200),
(_('Title'), 6, 300),
(_('Type'), 7, 100),
]
# ('',-1,0)]
self.namelist = MyTreeView()
self.namemodel = MyListModel(self.namelist,
columns,
event_func=self.cb_double_click)
find = glade.get_child_object("find")
find.connect('clicked', self.find_clicked)
reset = glade.get_child_object("reset")
reset.connect('clicked', self.reset_clicked)
self.searchtext = glade.get_child_object("searchtext")
self.searchtext.connect("key-press-event", self.keypress)
slist = glade.get_child_object("slist")
slist.add(self.namelist)
#self.namelist.connect('button-release-event', self.__button_release)
select = self.namelist.get_selection()
select.connect("changed", self.on_selection_changed)
self.replace_button = glade.get_child_object("replace")
self.replace_button.connect('clicked', self.replace_clicked)
button_undo = glade.get_child_object("button_undo")
button_undo.connect('clicked', self.undo_clicked)
clear_button = glade.get_child_object("clear_button")
clear_button.connect('clicked', self.clear_form)
editgrid = self.glade.get_child_object('editgrid')
self.special_prefix = self.build_combobox()
self.special_surname = self.build_combobox()
self.special_firstname = self.build_combobox()
self.special_suffix = self.build_combobox()
self.special_title = self.build_combobox()
self.old_prefix = self.glade.get_child_object("old_prefix")
self.old_surname = self.glade.get_child_object("old_surname")
self.old_firstname = self.glade.get_child_object("old_firstname")
self.old_suffix = self.glade.get_child_object("old_suffix")
self.old_title = self.glade.get_child_object("old_title")
self.new_prefix = self.glade.get_child_object('new_prefix')
self.new_surname = self.glade.get_child_object('new_surname')
self.new_firstname = self.glade.get_child_object('new_firstname')
self.new_suffix = self.glade.get_child_object('new_suffix')
self.new_title = self.glade.get_child_object("new_title")
editgrid.attach(self.special_prefix, 2, 1, 1, 1)
editgrid.attach(self.special_surname, 2, 2, 1, 1)
editgrid.attach(self.special_firstname, 2, 3, 1, 1)
editgrid.attach(self.special_suffix, 2, 4, 1, 1)
editgrid.attach(self.special_title, 2, 5, 1, 1)
self.use_special = glade.get_child_object("use_special")
self.use_special.connect('clicked', self.use_special_clicked)
self.use_regex_checkbox = self.glade.get_child_object("use_regex")
self.find_use_regex = self.glade.get_child_object("find_regex")
self.find_all = self.glade.get_child_object("find_all")
self.find_prefix = self.glade.get_child_object("find_prefix")
self.find_surname = self.glade.get_child_object("find_surname")
self.find_firstname = self.glade.get_child_object("find_firstname")
self.find_suffix = self.glade.get_child_object("find_suffix")
self.find_title = self.glade.get_child_object("find_title")
self.find_type = self.glade.get_child_object("find_type")
self.fill_typecombo(self.find_type)
self.old_nametype = self.glade.get_child_object("old_nametype")
self.fill_typecombo(self.old_nametype)
self.new_nametype = self.glade.get_child_object("new_nametype")
self.fill_typecombo(self.new_nametype)
self.type_primary = self.glade.get_child_object("type_primary")
self.type_alternate = self.glade.get_child_object("type_alternate")
self.find_all.connect('clicked', self.find_all_clicked)
self.gender_all = self.glade.get_child_object("gender_all")
self.gender_male = self.glade.get_child_object("gender_male")
self.gender_female = self.glade.get_child_object("gender_female")
self.gender_unknown = self.glade.get_child_object("gender_unknown")
self.label_count = self.glade.get_child_object("label_count")
self.help_button = self.glade.get_child_object("help_button")
self.help_button.connect("clicked", self.show_help)
self.find_in_progress = True
self.reset_clicked(None)
self.find_in_progress = False
return self.top
def __build_window(self):
"""Build the window from Glade.
"""
from gramps.gui.glade import Glade
glade_xml = Glade()
self._window = glade_xml.toplevel
self._window.set_transient_for(self._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)
self._drawing_area.connect("draw", self.on_drawingarea_draw_event)
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, 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(_('ID'), Gtk.CellRendererText(), text=1)
self.list.append_column(c)
c = Gtk.TreeViewColumn(_('Type'), Gtk.CellRendererText(), text=2)
self.list.append_column(c)
c = Gtk.TreeViewColumn(_('Value'), Gtk.CellRendererText(), text=3)
self.list.append_column(c)
c = Gtk.TreeViewColumn(_('Current Name'),
Gtk.CellRendererText(),
text=4)
self.list.append_column(c)
self.list.set_model(self.model)
self.nick_hash = {}
self.title_hash = {}
self.prefix1_hash = {}
self.compound_hash = {}
self.progress.set_pass(_('Building display'),
len(list(self.handle_to_action.keys())))
for key, data in self.handle_to_action.items():
p = self.db.get_person_from_handle(key)
gid = p.get_gramps_id()
if self.nickid in data:
given, nick = data[self.nickid]
handle = self.model.append()
self.model.set_value(handle, 0, 1)
self.model.set_value(handle, 1, gid)
self.model.set_value(handle, 2, _('Nickname'))
self.model.set_value(handle, 3, nick)
self.model.set_value(handle, 4,
p.get_primary_name().get_name())
self.nick_hash[key] = handle
if self.titleid in data:
title, given = data[self.titleid]
handle = self.model.append()
self.model.set_value(handle, 0, 1)
self.model.set_value(handle, 1, gid)
self.model.set_value(handle, 2, _('Person|Title'))
self.model.set_value(handle, 3, title)
self.model.set_value(handle, 4,
p.get_primary_name().get_name())
self.title_hash[key] = handle
if self.pref1id in data:
given, prefixtotal, new_prefix = data[self.pref1id]
handle = self.model.append()
self.model.set_value(handle, 0, 1)
self.model.set_value(handle, 1, gid)
self.model.set_value(handle, 2, _('Prefix in given name'))
self.model.set_value(handle, 3, prefixtotal)
self.model.set_value(handle, 4,
p.get_primary_name().get_name())
self.prefix1_hash[key] = handle
if self.compid in data:
surn_list, pref_list, con_list, prims, origs = data[
self.compid]
handle = self.model.append()
self.model.set_value(handle, 0, 1)
self.model.set_value(handle, 1, gid)
self.model.set_value(handle, 2, _('Compound surname'))
newval = ''
for sur, pre, con in zip(surn_list, pref_list, con_list):
if newval:
newval += '-['
else:
newval = '['
newval += pre + ',' + sur
if con:
newval += ',' + con + ']'
else:
newval += ']'
self.model.set_value(handle, 3, newval)
self.model.set_value(handle, 4,
p.get_primary_name().get_name())
self.compound_hash[key] = handle
self.progress.step()
self.progress.close()
self.show()
class PatchNames(tool.BatchTool, ManagedWindow):
titleid = 1
nickid = 2
pref1id = 3
compid = 4
def __init__(self, dbstate, user, options_class, name, callback=None):
uistate = user.uistate
self.label = _('Name and title extraction tool')
ManagedWindow.__init__(self, uistate, [], self.__class__)
self.set_window(Gtk.Window(), Gtk.Label(), '')
tool.BatchTool.__init__(self, dbstate, user, options_class, name)
if self.fail:
return
winprefix = Gtk.Dialog(
_("Default prefix and connector settings"), self.uistate.window,
Gtk.DialogFlags.MODAL | Gtk.DialogFlags.DESTROY_WITH_PARENT,
(_('_OK'), Gtk.ResponseType.ACCEPT))
winprefix.vbox.set_spacing(5)
hboxpref = Gtk.Box()
label = Gtk.Label(label=_('Prefixes to search for:'))
hboxpref.pack_start(label, False, False, 5)
self.prefixbox = Gtk.Entry()
self.prefixbox.set_text(', '.join(PREFIX_LIST))
hboxpref.pack_start(self.prefixbox, True, True, 0)
winprefix.vbox.pack_start(hboxpref, True, True, 0)
hboxcon = Gtk.Box()
label = Gtk.Label(label=_('Connectors splitting surnames:'))
hboxcon.pack_start(label, False, False, 5)
self.conbox = Gtk.Entry()
self.conbox.set_text(', '.join(CONNECTOR_LIST))
hboxcon.pack_start(self.conbox, True, True, 0)
winprefix.vbox.pack_start(hboxcon, True, True, 0)
hboxconns = Gtk.Box()
label = Gtk.Label(label=_('Connectors not splitting surnames:'))
hboxconns.pack_start(label, False, False, 5)
self.connsbox = Gtk.Entry()
self.connsbox.set_text(', '.join(CONNECTOR_LIST_NONSPLIT))
hboxconns.pack_start(self.connsbox, True, True, 0)
winprefix.vbox.pack_start(hboxconns, True, True, 0)
winprefix.show_all()
winprefix.resize(700, 100)
response = winprefix.run()
self.prefix_list = self.prefixbox.get_text().split(',')
self.prefix_list = list(map(strip, self.prefix_list))
self.prefixbox = None
self.connector_list = self.conbox.get_text().split(',')
self.connector_list = list(map(strip, self.connector_list))
self.conbox = None
self.connector_list_nonsplit = self.connsbox.get_text().split(',')
self.connector_list_nonsplit = list(
map(strip, self.connector_list_nonsplit))
self.connsbox = None
# Find a prefix in the first_name
self._fn_prefix_re = re.compile(
"(\S+)\s+(%s)\s*$" % '|'.join(self.prefix_list), re.IGNORECASE)
# Find a prefix in the surname
self._sn_prefix_re = re.compile(
"^\s*(%s)\s+(.+)" % '|'.join(self.prefix_list), re.IGNORECASE)
# Find a connector in the surname
self._sn_con_re = re.compile(
"^\s*(.+)\s+(%s)\s+(.+)" % '|'.join(self.connector_list),
re.IGNORECASE)
winprefix.destroy()
self.cb = callback
self.handle_to_action = {}
self.progress = ProgressMeter( # parent-OK
_('Extracting Information from Names'),
'',
parent=self.uistate.window)
self.progress.set_pass(_('Analyzing names'),
self.db.get_number_of_people())
for person in self.db.iter_people():
key = person.handle
name = person.get_primary_name()
first = name.get_first_name()
sname = name.get_surname()
old_prefix = []
old_surn = []
old_con = []
old_prim = []
old_orig = []
for surn in name.get_surname_list():
old_prefix.append(surn.get_prefix())
old_surn.append(surn.get_surname())
old_con.append(surn.get_connector())
old_prim.append(surn.get_primary())
old_orig.append(surn.get_origintype())
if name.get_title():
old_title = [name.get_title()]
else:
old_title = []
new_title = []
match = _title_re.match(first)
while match:
groups = match.groups()
first = groups[1]
new_title.append(groups[0])
match = _title_re.match(first)
matchnick = _nick_re.match(first)
if new_title:
titleval = (" ".join(old_title + new_title), first)
if key in self.handle_to_action:
self.handle_to_action[key][self.titleid] = titleval
else:
self.handle_to_action[key] = {self.titleid: titleval}
elif matchnick:
# we check for nick, which changes given name like title
groups = matchnick.groups()
nickval = (groups[0], groups[1])
if key in self.handle_to_action:
self.handle_to_action[key][self.nickid] = nickval
else:
self.handle_to_action[key] = {self.nickid: nickval}
else:
# Try to find the name prefix in the given name, also this
# changes given name
match = self._fn_prefix_re.match(first)
if match:
groups = match.groups()
if old_prefix[0]:
# Put the found prefix before the old prefix
new_prefix = " ".join([groups[1], old_prefix[0]])
else:
new_prefix = groups[1]
pref1val = (groups[0], new_prefix, groups[1])
if key in self.handle_to_action:
self.handle_to_action[key][self.pref1id] = pref1val
else:
self.handle_to_action[key] = {self.pref1id: pref1val}
#check for Gedcom import of compound surnames
if len(old_surn) == 1 and old_con[0] == '':
prefixes = old_prefix[0].split(',')
surnames = old_surn[0].split(',')
if len(prefixes) > 1 and len(prefixes) == len(surnames):
#assume a list of prefix and a list of surnames
prefixes = list(map(strip, prefixes))
surnames = list(map(strip, surnames))
primaries = [False] * len(prefixes)
primaries[0] = True
origs = []
for ind in range(len(prefixes)):
origs.append(NameOriginType())
origs[0] = old_orig[0]
compoundval = (surnames, prefixes, [''] * len(prefixes),
primaries, origs)
if key in self.handle_to_action:
self.handle_to_action[key][self.compid] = compoundval
else:
self.handle_to_action[key] = {self.compid: compoundval}
#we cannot check compound surnames, so continue the loop
continue
# Next, try to split surname in compounds: prefix surname connector
found = False
new_prefix_list = []
new_surname_list = []
new_connector_list = []
new_prim_list = []
new_orig_list = []
ind = 0
cont = True
for pref, surn, con, prim, orig in zip(old_prefix, old_surn,
old_con, old_prim,
old_orig):
surnval = surn.split()
if surnval == []:
new_prefix_list.append(pref)
new_surname_list.append('')
new_connector_list.append(con)
new_prim_list.append(prim)
new_orig_list.append(orig)
cont = False
continue
val = surnval.pop(0)
while cont:
new_prefix_list.append(pref)
new_surname_list.append('')
new_connector_list.append(con)
new_prim_list.append(prim)
new_orig_list.append(orig)
while cont and (val.lower() in self.prefix_list):
found = True
if new_prefix_list[-1]:
new_prefix_list[-1] += ' ' + val
else:
new_prefix_list[-1] = val
try:
val = surnval.pop(0)
except IndexError:
val = ''
cont = False
#after prefix we have a surname
if cont:
new_surname_list[-1] = val
try:
val = surnval.pop(0)
except IndexError:
val = ''
cont = False
#if value after surname indicates continue, then continue
while cont and (val.lower()
in self.connector_list_nonsplit):
#add this val to the current surname
new_surname_list[-1] += ' ' + val
try:
val = surnval.pop(0)
except IndexError:
val = ''
cont = False
# if previous is non-splitting connector, then add new val to
# current surname
if cont and (new_surname_list[-1].split()[-1].lower()
in self.connector_list_nonsplit):
new_surname_list[-1] += ' ' + val
try:
val = surnval.pop(0)
except IndexError:
val = ''
cont = False
#if next is a connector, add it to the surname
if cont and val.lower() in self.connector_list:
found = True
if new_connector_list[-1]:
new_connector_list[-1] = ' ' + val
else:
new_connector_list[-1] = val
try:
val = surnval.pop(0)
except IndexError:
val = ''
cont = False
#initialize for a next surname in case there are still
#val
if cont:
found = True # we split surname
pref = ''
con = ''
prim = False
orig = NameOriginType()
ind += 1
if found:
compoundval = (new_surname_list, new_prefix_list,
new_connector_list, new_prim_list,
new_orig_list)
if key in self.handle_to_action:
self.handle_to_action[key][self.compid] = compoundval
else:
self.handle_to_action[key] = {self.compid: compoundval}
self.progress.step()
if self.handle_to_action:
self.display()
else:
self.progress.close()
self.close()
OkDialog(
_('No modifications made'), # parent-OK
_("No titles, nicknames or prefixes were found"),
parent=self.uistate.window)
def build_menu_names(self, obj):
return (self.label, None)
def toggled(self, cell, path_string):
path = tuple(map(int, path_string.split(':')))
row = self.model[path]
row[0] = not row[0]
self.model.row_changed(path, row.iter)
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, 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(_('ID'), Gtk.CellRendererText(), text=1)
self.list.append_column(c)
c = Gtk.TreeViewColumn(_('Type'), Gtk.CellRendererText(), text=2)
self.list.append_column(c)
c = Gtk.TreeViewColumn(_('Value'), Gtk.CellRendererText(), text=3)
self.list.append_column(c)
c = Gtk.TreeViewColumn(_('Current Name'),
Gtk.CellRendererText(),
text=4)
self.list.append_column(c)
self.list.set_model(self.model)
self.nick_hash = {}
self.title_hash = {}
self.prefix1_hash = {}
self.compound_hash = {}
self.progress.set_pass(_('Building display'),
len(list(self.handle_to_action.keys())))
for key, data in self.handle_to_action.items():
p = self.db.get_person_from_handle(key)
gid = p.get_gramps_id()
if self.nickid in data:
given, nick = data[self.nickid]
handle = self.model.append()
self.model.set_value(handle, 0, 1)
self.model.set_value(handle, 1, gid)
self.model.set_value(handle, 2, _('Nickname'))
self.model.set_value(handle, 3, nick)
self.model.set_value(handle, 4,
p.get_primary_name().get_name())
self.nick_hash[key] = handle
if self.titleid in data:
title, given = data[self.titleid]
handle = self.model.append()
self.model.set_value(handle, 0, 1)
self.model.set_value(handle, 1, gid)
self.model.set_value(handle, 2, _('Person|Title'))
self.model.set_value(handle, 3, title)
self.model.set_value(handle, 4,
p.get_primary_name().get_name())
self.title_hash[key] = handle
if self.pref1id in data:
given, prefixtotal, new_prefix = data[self.pref1id]
handle = self.model.append()
self.model.set_value(handle, 0, 1)
self.model.set_value(handle, 1, gid)
self.model.set_value(handle, 2, _('Prefix in given name'))
self.model.set_value(handle, 3, prefixtotal)
self.model.set_value(handle, 4,
p.get_primary_name().get_name())
self.prefix1_hash[key] = handle
if self.compid in data:
surn_list, pref_list, con_list, prims, origs = data[
self.compid]
handle = self.model.append()
self.model.set_value(handle, 0, 1)
self.model.set_value(handle, 1, gid)
self.model.set_value(handle, 2, _('Compound surname'))
newval = ''
for sur, pre, con in zip(surn_list, pref_list, con_list):
if newval:
newval += '-['
else:
newval = '['
newval += pre + ',' + sur
if con:
newval += ',' + con + ']'
else:
newval += ']'
self.model.set_value(handle, 3, newval)
self.model.set_value(handle, 4,
p.get_primary_name().get_name())
self.compound_hash[key] = handle
self.progress.step()
self.progress.close()
self.show()
def on_help_clicked(self, obj):
"""Display the relevant portion of GRAMPS manual"""
display_help(webpage=WIKI_HELP_PAGE, section=WIKI_HELP_SEC)
def on_ok_clicked(self, obj):
with DbTxn(_("Extract information from names"), self.db,
batch=True) as trans:
self.db.disable_signals()
for key, data in self.handle_to_action.items():
p = self.db.get_person_from_handle(key)
if self.nickid in data:
modelhandle = self.nick_hash[key]
val = self.model.get_value(modelhandle, 0)
if val:
given, nick = data[self.nickid]
name = p.get_primary_name()
name.set_first_name(given.strip())
name.set_nick_name(nick.strip())
if self.titleid in data:
modelhandle = self.title_hash[key]
val = self.model.get_value(modelhandle, 0)
if val:
title, given = data[self.titleid]
name = p.get_primary_name()
name.set_first_name(given.strip())
name.set_title(title.strip())
if self.pref1id in data:
modelhandle = self.prefix1_hash[key]
val = self.model.get_value(modelhandle, 0)
if val:
given, prefixtotal, prefix = data[self.pref1id]
name = p.get_primary_name()
name.set_first_name(given.strip())
oldpref = name.get_surname_list()[0].get_prefix(
).strip()
if oldpref == '' or oldpref == prefix.strip():
name.get_surname_list()[0].set_prefix(prefix)
else:
name.get_surname_list()[0].set_prefix(
'%s %s' % (prefix, oldpref))
if self.compid in data:
modelhandle = self.compound_hash[key]
val = self.model.get_value(modelhandle, 0)
if val:
surns, prefs, cons, prims, origs = data[self.compid]
name = p.get_primary_name()
new_surn_list = []
for surn, pref, con, prim, orig in zip(
surns, prefs, cons, prims, origs):
new_surn_list.append(Surname())
new_surn_list[-1].set_surname(surn.strip())
new_surn_list[-1].set_prefix(pref.strip())
new_surn_list[-1].set_connector(con.strip())
new_surn_list[-1].set_primary(prim)
new_surn_list[-1].set_origintype(orig)
name.set_surname_list(new_surn_list)
self.db.commit_person(p, trans)
self.db.enable_signals()
self.db.request_rebuild()
self.close()
self.cb()
def __init__(self, dbstate, user, options_class, name, callback=None):
uistate = user.uistate
tool.ActivePersonTool.__init__(self, dbstate, uistate, options_class,
name)
if self.fail: # bug #2709 -- fail if we have no active person
return
person_handle = uistate.get_active('Person')
person = dbstate.db.get_person_from_handle(person_handle)
self.name = person.get_primary_name().get_regular_name()
self.title = _('Not related to "%s"') % self.name
ManagedWindow.__init__(self, uistate, [], self.__class__)
self.dbstate = dbstate
self.uistate = uistate
self.db = dbstate.db
topDialog = Glade()
topDialog.connect_signals({
"destroy_passed_object": self.close,
"on_help_clicked": self.on_help_clicked,
"on_delete_event": self.close,
})
window = topDialog.toplevel
title = topDialog.get_object("title")
self.set_window(window, title, self.title)
self.tagcombo = topDialog.get_object("tagcombo")
tagmodel = Gtk.ListStore(str)
self.tagcombo.set_model(tagmodel)
self.tagcombo.set_entry_text_column(0)
tagmodel.append((_('ToDo'), ))
tagmodel.append((_('NotRelated'), ))
self.tagcombo.set_sensitive(False)
self.tagapply = topDialog.get_object("tagapply")
self.tagapply.set_sensitive(False)
self.tagapply.connect('clicked', self.applyTagClicked)
# start the progress indicator
self.progress = ProgressMeter(self.title,
_('Starting'),
parent=self.window)
# setup the columns
self.model = Gtk.TreeStore(
GObject.TYPE_STRING, # 0==name
GObject.TYPE_STRING, # 1==person gid
GObject.TYPE_STRING, # 2==parents
GObject.TYPE_STRING, # 3==tags
GObject.TYPE_STRING) # 4==family gid (not shown to user)
# note -- don't assign the model to the tree until it has been populated,
# otherwise the screen updates are terribly slow while names are appended
self.treeView = topDialog.get_object("treeview")
col1 = Gtk.TreeViewColumn(_('Name'), Gtk.CellRendererText(), text=0)
col2 = Gtk.TreeViewColumn(_('ID'), Gtk.CellRendererText(), text=1)
col3 = Gtk.TreeViewColumn(_('Parents'), Gtk.CellRendererText(), text=2)
col4 = Gtk.TreeViewColumn(_('Tags'), Gtk.CellRendererText(), text=3)
col1.set_resizable(True)
col2.set_resizable(True)
col3.set_resizable(True)
col4.set_resizable(True)
col1.set_sizing(Gtk.TreeViewColumnSizing.AUTOSIZE)
col2.set_sizing(Gtk.TreeViewColumnSizing.AUTOSIZE)
col3.set_sizing(Gtk.TreeViewColumnSizing.AUTOSIZE)
col4.set_sizing(Gtk.TreeViewColumnSizing.AUTOSIZE)
col1.set_sort_column_id(0)
# col2.set_sort_column_id(1)
# col3.set_sort_column_id(2)
col4.set_sort_column_id(3)
self.treeView.append_column(col1)
self.treeView.append_column(col2)
self.treeView.append_column(col3)
self.treeView.append_column(col4)
self.treeSelection = self.treeView.get_selection()
self.treeSelection.set_mode(Gtk.SelectionMode.MULTIPLE)
self.treeSelection.set_select_function(self.selectIsAllowed, None)
self.treeSelection.connect('changed', self.rowSelectionChanged)
self.treeView.connect('row-activated', self.rowActivated)
# initialize a few variables we're going to need
self.numberOfPeopleInDatabase = self.db.get_number_of_people()
self.numberOfRelatedPeople = 0
self.numberOfUnrelatedPeople = 0
# create the sets used to track related and unrelated people
self.handlesOfPeopleToBeProcessed = set()
self.handlesOfPeopleAlreadyProcessed = set()
self.handlesOfPeopleNotRelated = set()
# build a set of all people related to the selected person
self.handlesOfPeopleToBeProcessed.add(person.get_handle())
self.findRelatedPeople()
# now that we have our list of related people, find everyone
# in the database who isn't on our list
self.findUnrelatedPeople()
# populate the treeview model with the names of unrelated people
if self.numberOfUnrelatedPeople == 0:
# feature request 2356: avoid genitive form
title.set_text(
_('Everyone in the database is related to %s') % self.name)
else:
self.populateModel()
self.model.set_sort_column_id(0, Gtk.SortType.ASCENDING)
self.treeView.set_model(self.model)
# self.treeView.set_row_separator_func(self.iterIsSeparator, None)
self.treeView.expand_all()
# done searching through the database, so close the progress bar
self.progress.close()
self.show()
def __init__(self, dbstate, user, options_class, name, callback=None):
uistate = user.uistate
"""
Relationship calculator class.
"""
tool.Tool.__init__(self, dbstate, options_class, name)
ManagedWindow.__init__(self,uistate,[],self.__class__)
#set the columns to see
for data in BasePersonView.CONFIGSETTINGS:
if data[0] == 'columns.rank':
colord = data[1]
elif data[0] == 'columns.visible':
colvis = data[1]
elif data[0] == 'columns.size':
colsize = data[1]
self.colord = []
for col, size in zip(colord, colsize):
if col in colvis:
self.colord.append((1, col, size))
else:
self.colord.append((0, col, size))
self.dbstate = dbstate
self.relationship = get_relationship_calculator(glocale)
self.relationship.connect_db_signals(dbstate)
self.glade = Glade()
self.person = self.db.get_person_from_handle(
uistate.get_active('Person'))
name = ''
if self.person:
name = name_displayer.display(self.person)
self.title = _('Relationship calculator: %(person_name)s'
) % {'person_name' : name}
window = self.glade.toplevel
self.titlelabel = self.glade.get_object('title')
self.set_window(window, self.titlelabel,
_('Relationship to %(person_name)s'
) % {'person_name' : name},
self.title)
self.setup_configs('interface.relcalc', 600, 400)
self.tree = self.glade.get_object("peopleList")
self.text = self.glade.get_object("text1")
self.textbuffer = Gtk.TextBuffer()
self.text.set_buffer(self.textbuffer)
self.model = PersonTreeModel(self.db, uistate)
self.tree.set_model(self.model)
self.tree.connect('key-press-event', self._key_press)
self.selection = self.tree.get_selection()
self.selection.set_mode(Gtk.SelectionMode.SINGLE)
#keep reference of column so garbage collection works
self.columns = []
for pair in self.colord:
if not pair[0]:
continue
name = column_names[pair[1]]
column = Gtk.TreeViewColumn(name, Gtk.CellRendererText(),
markup=pair[1])
column.set_resizable(True)
column.set_min_width(60)
column.set_sizing(Gtk.TreeViewColumnSizing.GROW_ONLY)
self.tree.append_column(column)
#keep reference of column so garbage collection works
self.columns.append(column)
self.sel = self.tree.get_selection()
self.changedkey = self.sel.connect('changed',self.on_apply_clicked)
self.closebtn = self.glade.get_object("button5")
self.closebtn.connect('clicked', self.close)
if not self.person:
self.window.hide()
ErrorDialog(_('Active person has not been set'),
_('You must select an active person for this '
'tool to work properly.'),
parent=uistate.window)
self.close()
return
self.show()
def _display(self):
""" organize Glade 'Reorder IDs' window """
# get the main window from glade
self.top = Glade(toplevel="reorder-ids")
window = self.top.toplevel
# set gramps style title for the window
self.set_window(window, self.top.get_object("title"), \
_("Reorder Gramps IDs"))
# connect signals
self.top.connect_signals({
"on_object_button_clicked":
self.__on_object_button_clicked,
"on_object_button_toggled":
self.__on_object_button_toggled,
"on_format_button_clicked":
self.__on_format_button_clicked,
"on_start_button_clicked":
self.__on_start_button_clicked,
"on_step_button_clicked":
self.__on_step_button_clicked,
"on_keep_button_clicked":
self.__on_keep_button_clicked,
"on_change_button_clicked":
self.__on_change_button_clicked,
"on_change_button_toggled":
self.__on_change_button_toggled,
"on_format_entry_keyrelease":
self.__on_format_entry_keyrelease,
"on_format_entry_focusout":
self.__on_format_entry_focusout,
"on_start_entry_focusout":
self.__on_start_entry_focusout,
"on_help_button_clicked":
self.__on_help_button_clicked,
"on_cancel_button_clicked":
self.__on_cancel_button_clicked,
"on_ok_button_clicked":
self.__on_ok_button_clicked
})
# Calculate all entries and update Glade window
for prim_obj, tmp in self.xobjects:
# populate Object, Actual & Quantity fields with values
obj_active = self.top.get_object('%s_active' % prim_obj)
self.active_entries[prim_obj] = MonitoredCheckbox(
obj_active, obj_active, self.obj_values[prim_obj].set_active,
self.obj_values[prim_obj].get_active)
obj_actual = self.top.get_object('%s_actual' % prim_obj)
obj_actual.set_text('%s' % self.obj_values[prim_obj].last_id())
obj_quant = self.top.get_object('%s_quant' % prim_obj)
obj_quant.set_text('%s' % str(self.obj_values[prim_obj].quant_id))
# connect/populate Format, Start, Step, Keep & Change fields with GTK/values
obj_format = self.top.get_object('%s_format' % prim_obj)
self.format_entries[prim_obj] = MonitoredEntry(
obj_format, self.obj_values[prim_obj].set_fmt,
self.obj_values[prim_obj].get_fmt)
obj_change = self.top.get_object('%s_change' % prim_obj)
self.change_entries[prim_obj] = MonitoredCheckbox(
obj_change, obj_change, self.obj_values[prim_obj].set_change,
self.obj_values[prim_obj].get_change)
obj_start = self.top.get_object('%s_start' % prim_obj)
self.start_entries[prim_obj] = MonitoredEntry(
obj_start, self.obj_values[prim_obj].set_id,
self.obj_values[prim_obj].get_id)
obj_step = self.top.get_object('%s_step' % prim_obj)
self.step_entries[prim_obj] = MonitoredEntry(
obj_step,
self.obj_values[prim_obj].set_step,
self.obj_values[prim_obj].get_step,
changed=self.obj_values[prim_obj].change_step)
obj_keep = self.top.get_object('%s_keep' % prim_obj)
self.keep_entries[prim_obj] = MonitoredCheckbox(
obj_keep,
obj_keep,
self.obj_values[prim_obj].set_keep,
self.obj_values[prim_obj].get_keep,
readonly=True)
# fetch the popup menu
self.menu = self.top.get_object("popup_menu")
# ok, let's see what we've done
self.show()