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.callback = uistate.pulse_progressbar self.batch_ops = [] self.build_batch_ops() self.assistant = Gtk.Assistant() self.set_window(self.assistant, None, _('Media Manager')) self.setup_configs('interface.mediaman', 780, 600) self.assistant.connect('close', self.do_close) self.assistant.connect('cancel', self.do_close) self.assistant.connect('apply', self.run) self.assistant.connect('prepare', self.prepare) intro = IntroductionPage() self.add_page(intro, Gtk.AssistantPageType.INTRO, _('Introduction')) self.selection = SelectionPage(self.batch_ops) self.add_page(self.selection, Gtk.AssistantPageType.CONTENT, _('Selection')) self.settings = SettingsPage(self.batch_ops, self.assistant) self.add_page(self.settings, Gtk.AssistantPageType.CONTENT) self.confirmation = ConfirmationPage(self.batch_ops) self.add_page(self.confirmation, Gtk.AssistantPageType.CONFIRM, _('Final confirmation')) self.conclusion = ConclusionPage(self.assistant) self.add_page(self.conclusion, Gtk.AssistantPageType.SUMMARY) self.show() self.assistant.set_forward_page_func(self.forward_page, None)
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 __init__(self, dbstate, user, options_class, name, callback=None): uistate = user.uistate tool.Tool.__init__(self, dbstate, options_class, name) self.window_name = _('Media Verify Tool') ManagedWindow.__init__(self, uistate, [], self.__class__) self.dbstate = dbstate self.moved_files = [] self.titles = [_('Moved/Renamed Files'), _('Missing Files'), _('Duplicate Files'), _('Extra Files'), _('No md5 Generated'), _('Errors')] self.models = [] self.views = [] window = Gtk.Window() vbox = Gtk.VBox() self.notebook = Gtk.Notebook() self.notebook.set_scrollable(True) for title in self.titles: self.create_tab(title) vbox.pack_start(self.notebook, True, True, 5) bbox = Gtk.HButtonBox() vbox.pack_start(bbox, False, False, 5) close = Gtk.Button(_('Close')) close.set_tooltip_text(_('Close the Media Verify Tool')) close.connect('clicked', self.close) generate = Gtk.Button(_('Generate')) generate.set_tooltip_text(_('Generate md5 hashes for media objects')) generate.connect('clicked', self.generate_md5) verify = Gtk.Button(_('Verify')) verify.set_tooltip_text(_('Check media paths and report missing, ' 'duplicate and extra files')) verify.connect('clicked', self.verify_media) export = Gtk.Button(_('Export')) export.set_tooltip_text(_('Export the results to a text file')) export.connect('clicked', self.export_results) fix = Gtk.Button(_('Fix')) fix.set_tooltip_text(_('Fix media paths of moved and renamed files')) fix.connect('clicked', self.fix_media) bbox.add(close) bbox.add(generate) bbox.add(verify) bbox.add(export) bbox.add(fix) vbox.show_all() window.add(vbox) window.set_size_request(500, 300) window.set_position(Gtk.WindowPosition.CENTER_ON_PARENT) self.set_window(window, None, self.window_name) self.show() self.show_tabs()
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", "index.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) self.top = self.glade.get_object('edit_index') self.set_window(self.top, self.glade.get_object('title'), self.label) self.birth_button = self.glade.get_object('add_b') self.death_button = self.glade.get_object('add_d') self.marriage_button = self.glade.get_object('add_m') self.census_button = self.glade.get_object('add_c') self.birth_button.connect('clicked', self.birth_editor) self.death_button.connect('clicked', self.death_editor) self.marriage_button.connect('clicked', self.marriage_editor) self.census_button.connect('clicked', self.census_editor) else: # Glade class from gui/glade.py and gui/managedwindow.py self.define_glade('edit_index', glade_file) self.set_window(self._gladeobj.toplevel, None, text=None, msg='Index') self.connect_button('add_b', self.birth_editor) self.connect_button('add_m', self.marriage_editor) self.connect_button('add_d', self.death_editor) self.connect_button('add_c', self.census_editor) #self.window.connect('delete-event', GladeHandlers.on_quit_clicked) self.window.show()
def __init__(self, dbstate, user, options_class, name, callback=None): uistate = user.uistate self.label = _("Gender Statistics tool") tool.Tool.__init__(self, dbstate, options_class, name) stats_list = [] for name, value in dbstate.db.genderStats.stats.items(): stats_list.append( (name,) + value + (_GENDER[dbstate.db.genderStats.guess_gender(name)],) ) if uistate: ManagedWindow.__init__(self, uistate, [], self.__class__) titles = [(_('Name'), 0, 100), (_('Male'), 1, 70, INTEGER), (_('Female'), 2, 70, INTEGER), (_('Unknown'), 3, 90, INTEGER), (_('Guess'), 4, 70)] treeview = Gtk.TreeView() model = ListModel(treeview, titles) for entry in sorted(stats_list): model.add(entry, entry[0]) s = Gtk.ScrolledWindow() s.add(treeview) dialog = Gtk.Dialog() dialog.add_button(_('_Close'), Gtk.ResponseType.CLOSE) dialog.connect('response', self._response) dialog.vbox.pack_start(s, expand=True, fill=True, padding=0) self.set_window(dialog, None, self.label) self.setup_configs('interface.dumpgenderstats', 420, 300) self.show() else: if len(_('Name')) < 16: print('%s%s%s' % (_('Name'), " " * (16 - len(_('Name'))), _('Male')), '\t%s'*3 % (_('Female'), _('Unknown'), _('Guess'))) else: print(_('Name'), '\t%s'*4 % (_('Male'), _('Female'), _('Unknown'), _('Guess'))) print() for entry in sorted(stats_list): if len(entry[0]) < 16: print('%s%s%s' % (entry[0], " " * (16 - len(entry[0])), entry[1]), '\t%s'*3 % (entry[2:])) else: print(entry[0], '\t%s'*4 % (entry[1:]))
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__(self, dbstate, user, options_class, name, callback=None): self.uistate = user.uistate self.db = dbstate.db if self.uistate: tool.BatchTool.__init__(self, dbstate, user, options_class, name) if self.fail: return # user denied to modify Gramps IDs ManagedWindow.__init__(self, self.uistate, [], self.__class__) if not self.uistate: UpdateCallback.__init__(self, user.callback) self.object_status = True self.change_status = False self.start_zero = True self.step_cnt, self.step_list = 0, ['1', '2', '5', '10'] self.keep_status = True self.obj_values = {} # enable access to all internal values self.active_entries, self.format_entries = {}, {} self.change_entries = {} self.start_entries, self.step_entries = {}, {} self.keep_entries = {} self.prim_methods, self.obj_methods = {}, {} for prim_obj, prim_objs in self.xobjects: iter_handles = "iter_%s_handles" % prim_obj get_number_obj = "get_number_of_%s" % prim_objs prefix_fmt = "%s_prefix" % prim_obj get_from_id = "get_%s_from_gramps_id" % prim_obj get_from_handle = "get_%s_from_handle" % prim_obj next_from_id = "find_next_%s_gramps_id" % prim_obj commit = "commit_%s" % prim_obj self.prim_methods[prim_obj] = (getattr(self.db, prefix_fmt), getattr(self.db, get_number_obj)(), getattr(self.db, next_from_id)()) self.obj_methods[prim_obj] = (getattr(self.db, iter_handles), getattr(self.db, commit), getattr(self.db, get_from_id), getattr(self.db, get_from_handle), getattr(self.db, next_from_id)) object_fmt, quant_id, next_id = self.prim_methods[prim_obj] obj_value = ReorderEntry(object_fmt, quant_id, next_id, prim_obj) self.obj_values[prim_obj] = obj_value if self.uistate: self._display() else: self._execute()
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, user, options_class, name, callback=None): uistate = user.uistate ManagedWindow.__init__(self, uistate, [], self.__class__) self.dbstate = dbstate self.set_window(Gtk.Window(), Gtk.Label(), '') tool.BatchTool.__init__(self, dbstate, user, options_class, name) if not self.fail: uistate.set_busy_cursor(True) self.run() uistate.set_busy_cursor(False)
def __init__(self, dbstate, user, options_class, name, callback=None): self.uistate = user.uistate self.label = _('Extract Place data') ManagedWindow.__init__(self, self.uistate, [], self.__class__) self.set_window(Gtk.Window(), Gtk.Label(), '') tool.BatchTool.__init__(self, dbstate, user, options_class, name) if not self.fail: self.uistate.set_busy_cursor(True) self.run(dbstate.db) self.uistate.set_busy_cursor(False)
def __init__(self, dbstate, user, options_class, name, callback=None): uistate = user.uistate self.user = user ManagedWindow.__init__(self, uistate, [], self.__class__) self.dbstate = dbstate self.set_window(Gtk.Window(), Gtk.Label(), '') tool.BatchTool.__init__(self, dbstate, user, options_class, name) if not self.fail: uistate.set_busy_cursor(True) self.run() uistate.set_busy_cursor(False)
def __init__(self, dbstate, user, options_class, name, callback=None): uistate = user.uistate self.user = user tool.BatchTool.__init__(self, dbstate, user, options_class, name) if self.fail: return if uistate: self.title = _('Change Event Types') ManagedWindow.__init__(self, uistate, [], self.__class__) self.init_gui() else: self.run_tool()
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')) 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, track, citation, callback): self.dbstate = dbstate self.uistate = uistate self.track = track self.db = dbstate.db self.citation = citation self.event = find_form_event(self.db, self.citation) self.callback = callback ManagedWindow.__init__(self, uistate, track, citation) self.widgets = {} top = self.__create_gui() self.set_window(top, None, self.get_menu_title()) self.date_field = MonitoredDate(self.widgets['date_text'], self.widgets['date_button'], self.event.get_date_object(), self.uistate, self.track, self.db.readonly) self.place_field = PlaceEntry(self.dbstate, self.uistate, self.track, self.widgets['place_text'], self.widgets['place_event_box'], self.event.set_place_handle, self.event.get_place_handle, self.widgets['place_add'], self.widgets['place_share']) self.ref_field = MonitoredEntry( self.widgets['ref_entry'], self.citation.set_page, self.citation.get_page, self.db.readonly) self.__populate_gui(self.event) self.show() self._config = config.get_manager('form') width = self._config.get('interface.form-width') height = self._config.get('interface.form-height') self.window.resize(width, height) horiz_position = self._config.get('interface.form-horiz-position') vert_position = self._config.get('interface.form-vert-position') if horiz_position != -1: self.window.move(horiz_position, vert_position)
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, dbstate, user, options_class, name, callback=None): uistate = user.uistate self.label = _("Associations state tool") tool.Tool.__init__(self, dbstate, options_class, name) if uistate: ManagedWindow.__init__(self,uistate,[], self.__class__) stats_list = [] plist = dbstate.db.get_person_handles(sort_handles=True) for handle in plist: person = dbstate.db.get_person_from_handle(handle) name1 = name_displayer.display(person) refs = person.get_person_ref_list() if refs: for ref in person.serialize()[-1]: (a, b, c, two, value) = ref person2 = dbstate.db.get_person_from_handle(two) name2 = name_displayer.display(person2) stats_list.append((name1, value, name2)) if uistate: titles = [ (_('Name'), 0, 200), (_('Type of link'), 1, 200), (_('Of'), 2, 200), ] treeview = Gtk.TreeView() model = ListModel(treeview, titles) for entry in stats_list: model.add(entry, entry[0]) window = Gtk.Window() window.set_default_size(800, 600) s = Gtk.ScrolledWindow() s.add(treeview) window.add(s) window.show_all() self.set_window(window, None, self.label) self.show() else: print('\t%s'*3 % ('Name','Type of link','Of')) print() for entry in stats_list: print('\t%s'*3 % entry)
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, dbstate, user, options_class, name, callback=None): uistate = user.uistate self.user = user tool.BatchTool.__init__(self, dbstate, user, options_class, name) if self.fail: return if uistate: self.title = _('Change Event Types') ManagedWindow.__init__(self,uistate,[], self.__class__) self.init_gui() else: self.run_tool()
def __init__(self, dbstate, user, options_class, name, callback=None): set_det_id(True) uistate = user.uistate if not uistate: return tool.Tool.__init__(self, dbstate, options_class, name) self.window_name = _('Deterministic ID Tool') ManagedWindow.__init__(self, uistate, [], self.__class__) window = MyWindow(dbstate, self.uistate, []) self.set_window(window, None, self.window_name) WarningDialog(self.window_name, _("The ID and handles now start at 0x00000000, and increment by 0x100000001"), self.window) self.close()
def __init__(self, dbstate, user, options_class, name, callback=None): uistate = user.uistate self.label = _('Check Place title') tool.BatchTool.__init__(self, dbstate, user, options_class, name) if self.fail: return ManagedWindow.__init__(self, uistate, [], self.__class__) self.set_window(Gtk.Window(), Gtk.Label(), '') # retrieve options CLI? #copy = self.options.handler.options_dict['copy'] #clean = self.options.handler.options_dict['clean'] self.db = dbstate.db self.total = self.db.get_number_of_places() self.progress = ProgressMeter(_('Checking Place Titles'), '', parent=uistate.window) self.progress.set_pass(_('Looking for place fields'), self.total) self.name_list = [] count = 0 for handle in self.db.get_place_handles(True): self.progress.step() place = self.db.get_place_from_handle(handle) title = place.title descr = place_displayer.display(self.db, place) if title != (descr and ""): count += 1 if title != "": self.name_list.append((handle.decode('utf8'), title, descr)) self.progress.close() if self.name_list: self.display() OkDialog(_('Differences'), '%s/%s' % (count, self.total), parent=uistate.window) else: self.progress.close() self.close() OkDialog(_('No need modifications'), _("No changes need."), parent=uistate.window)
def __init__(self, dbstate, user, options_class, name, callback=None): uistate = user.uistate self.label = _('Check Place title') tool.BatchTool.__init__(self, dbstate, user, options_class, name) if self.fail: return ManagedWindow.__init__(self,uistate,[], self.__class__) self.set_window(Gtk.Window(),Gtk.Label(),'') # retrieve options CLI? #copy = self.options.handler.options_dict['copy'] #clean = self.options.handler.options_dict['clean'] self.db = dbstate.db self.total = self.db.get_number_of_places() self.progress = ProgressMeter(_('Checking Place Titles'), '', parent=uistate.window) self.progress.set_pass(_('Looking for place fields'), self.total) self.name_list = [] count = 0 for handle in self.db.get_place_handles(True): self.progress.step() place = self.db.get_place_from_handle(handle) title = place.title descr = place_displayer.display(self.db, place) if title != (descr and ""): count += 1 if title != "": self.name_list.append((handle.decode('utf8'), title, descr)) self.progress.close() if self.name_list: self.display() OkDialog(_('Differences'), '%s/%s' % (count, self.total), parent=uistate.window) else: self.progress.close() self.close() OkDialog(_('No need modifications'), _("No changes need."), parent=uistate.window)
def __init__(self, dbstate, uistate, track, citation, callback): self.dbstate = dbstate self.uistate = uistate self.track = track self.db = dbstate.db self.citation = citation self.event = find_form_event(self.db, self.citation) self.callback = callback ManagedWindow.__init__(self, uistate, track, citation) self.widgets = {} top = self.__create_gui() self.set_window(top, None, self.get_menu_title()) self.date_field = MonitoredDate(self.widgets['date_text'], self.widgets['date_button'], self.event.get_date_object(), self.uistate, self.track, self.db.readonly) self.place_field = PlaceEntry( self.dbstate, self.uistate, self.track, self.widgets['place_text'], self.widgets['place_event_box'], self.event.set_place_handle, self.event.get_place_handle, self.widgets['place_add'], self.widgets['place_share']) self.ref_field = MonitoredEntry(self.widgets['ref_entry'], self.citation.set_page, self.citation.get_page, self.db.readonly) self.__populate_gui(self.event) self.show() self._config = config.get_manager('form') width = self._config.get('interface.form-width') height = self._config.get('interface.form-height') self.window.resize(width, height) horiz_position = self._config.get('interface.form-horiz-position') vert_position = self._config.get('interface.form-vert-position') if horiz_position != -1: self.window.move(horiz_position, vert_position)
def __init__(self, dbstate, user, options_class, name, callback=None): uistate = user.uistate self.label = _("Download media") ManagedWindow.__init__(self, uistate, [], self.__class__) self.set_window(Gtk.Window(), Gtk.Label(), "") tool.Tool.__init__(self, dbstate, options_class, name) self.num_downloads = 0 dialog = self.display() response = dialog.run() dialog.destroy() if response == Gtk.ResponseType.ACCEPT: self.on_ok_clicked() OkDialog(_("Media downloaded"), _("%d media files downloaded") % self.num_downloads) self.close()
def __init__(self, dbstate, user, options_class, name, callback=None): uistate = user.uistate self.label = 'Populate sources and citations tool' ManagedWindow.__init__(self, uistate, [], self.__class__) self.set_window(Gtk.Window(), Gtk.Label(), '') tool.Tool.__init__(self, dbstate, options_class, name) dialog = self.display() response = dialog.run() dialog.destroy() if response == Gtk.ResponseType.ACCEPT: self.on_ok_clicked() OkDialog('Data generated', "The requested sources and citations were generated") self.close()
def __init__(self, dbstate, user, options_class, name, callback=None): uistate = user.uistate self.label = _('Download media') ManagedWindow.__init__(self, uistate, [], self.__class__) self.set_window(Gtk.Window(), Gtk.Label(), '') tool.Tool.__init__(self, dbstate, options_class, name) self.num_downloads = 0 dialog = self.display() response = dialog.run() dialog.destroy() if response == Gtk.ResponseType.ACCEPT: self.on_ok_clicked() OkDialog(_('Media downloaded'), _("%d media files downloaded") % self.num_downloads) self.close()
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, dbstate, user, options_class, name, callback=None): uistate = user.uistate self.label = _("Gender Statistics tool") tool.Tool.__init__(self, dbstate, options_class, name) if uistate: ManagedWindow.__init__(self,uistate,[], self.__class__) stats_list = [] for name, value in dbstate.db.genderStats.stats.items(): stats_list.append( (name,) + value + (_GENDER[dbstate.db.genderStats.guess_gender(name)],) ) if uistate: titles = [ (_('Name'),0,100), (_('Male'),1,70,INTEGER), (_('Female'),2,70,INTEGER), (_('Unknown'),3,70,INTEGER), (_('Guess'),4,70) ] treeview = Gtk.TreeView() model = ListModel(treeview, titles) for entry in stats_list: model.add(entry, entry[0]) window = Gtk.Window() window.set_default_size(400, 300) s = Gtk.ScrolledWindow() s.add(treeview) window.add(s) window.show_all() self.set_window(window, None, self.label) self.show() else: print('\t%s'*5 % ('Name','Male','Female','Unknown','Guess')) print() for entry in stats_list: print('\t%s'*5 % entry)
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 __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): self.uistate = uistate self.dbstate = dbstate self._show_builtins = None self._show_hidden = None self.options = PluginManagerOptions('pluginmanager') #tool.Tool.__init__(self, dbstate, options_class, 'pluginmanager') self.options.load_previous_values() self.options_dict = self.options.handler.options_dict self.window = Gtk.Dialog(title=TITLE) ManagedWindow.__init__(self, uistate, track, self.__class__) self.set_window(self.window, None, TITLE, None) self._pmgr = GuiPluginManager.get_instance() self._preg = PluginRegister.get_instance() #obtain hidden plugins from the pluginmanager self.hidden = self._pmgr.get_hidden_plugin_ids() self.setup_configs('interface.pluginstatus', 750, 400) help_btn = self.window.add_button( # pylint: disable=no-member _("_Help"), Gtk.ResponseType.HELP) update_btn = self.window.add_button( # pylint: disable=no-member _("Check for updated addons now"), UPDATE_RES) btn_box = help_btn.get_parent() btn_box.set_child_non_homogeneous(update_btn, True) if __debug__: # Only show the "Reload" button when in debug mode # (without -O on the command line) reload_btn = self.window.add_button( # pylint: disable=no-member _("Reload"), RELOAD_RES) btn_box.set_child_non_homogeneous(reload_btn, True) self.window.add_button(_('_Close'), Gtk.ResponseType.CLOSE) labeltitle, widget = self.registered_plugins_panel(None) self.window.vbox.pack_start(widget, True, True, 0) sep = Gtk.Separator.new(Gtk.Orientation.HORIZONTAL) self.window.vbox.pack_start(sep, False, False, 3) self.restart_needed = False self.window.connect('response', self.done) self.show() self.__populate_reg_list()
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 __init__(self, dbstate, uistate, track, event): self.dbstate = dbstate self.uistate = uistate self.track = track self.db = dbstate.db self.event = event self.citation = get_census_citation(self.db, self.event) if self.citation is None: self.citation = Citation() ManagedWindow.__init__(self, uistate, track, event) self.widgets = {} top = self.__create_gui() self.set_window(top, None, self.get_menu_title()) self._config = config.get_manager('census') width = self._config.get('interface.census-width') height = self._config.get('interface.census-height') self.window.resize(width, height) self.place_field = PlaceEntry(self.dbstate, self.uistate, self.track, self.widgets['place_text'], self.event.set_place_handle, self.event.get_place_handle, self.widgets['place_add'], self.widgets['place_share']) self.ref_field = MonitoredEntry( self.widgets['ref_entry'], self.citation.set_page, self.citation.get_page, self.db.readonly) if self.event.get_handle(): self.widgets['census_combo'].set_sensitive(False) self.__populate_gui(event) self.details.populate_gui(event)
def __init__(self, dbstate, user, options_class, name, callback=None): uistate = user.uistate self.label = _('Capitalization changes') self.dbstate = dbstate self.uistate = uistate 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 given_name_dict = self.get_given_name_dict() self.progress = ProgressMeter(_('Checking Given Names'), '', parent=uistate.window) self.progress.set_pass(_('Searching given names'), len(given_name_dict.keys())) self.name_list = [] for name in given_name_dict.keys(): if name != capitalize(name): self.name_list.append((name, given_name_dict[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 __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.callback = uistate.pulse_progressbar self.batch_ops = [] self.build_batch_ops() self.assistant = Gtk.Assistant() self.set_window(self.assistant, None, _('Media Manager')) self.setup_configs('interface.mediaman', 780, 600) help_btn = Gtk.Button.new_with_label(_('Help')) help_btn.connect('clicked', self.on_help_clicked) self.assistant.add_action_widget(help_btn) self.assistant.connect('close', self.do_close) self.assistant.connect('cancel', self.do_close) self.assistant.connect('apply', self.run) self.assistant.connect('prepare', self.prepare) intro = IntroductionPage() self.add_page(intro, Gtk.AssistantPageType.INTRO, _('Introduction')) self.selection = SelectionPage(self.batch_ops) self.add_page(self.selection, Gtk.AssistantPageType.CONTENT, _('Selection')) self.settings = SettingsPage(self.batch_ops, self.assistant) self.add_page(self.settings, Gtk.AssistantPageType.CONTENT) self.confirmation = ConfirmationPage(self.batch_ops) self.add_page(self.confirmation, Gtk.AssistantPageType.CONFIRM, _('Final confirmation')) self.conclusion = ConclusionPage(self.assistant) self.add_page(self.conclusion, Gtk.AssistantPageType.SUMMARY) self.show() self.assistant.set_forward_page_func(self.forward_page, None)
def __init__(self, dbstate, user, options_class, name, callback=None): uistate = user.uistate self.user = user self.label = _('Download media') ManagedWindow.__init__(self, uistate, [], self.__class__) self.set_window(Gtk.Window(), Gtk.Label(), '') tool.Tool.__init__(self, dbstate, options_class, name) self.num_downloads = 0 dialog = self.display() response = dialog.run() dialog.destroy() if response == Gtk.ResponseType.ACCEPT: self.on_ok_clicked() if hasattr(self.user.uistate, 'window'): parent_window = self.user.uistate.window else: parent_window = None OkDialog(_('Media downloaded'), _("%d media files downloaded") % self.num_downloads, parent=parent_window) self.close()
def __init__(self, uistate, dbstate, names): self.uistate = uistate self.dbstate = dbstate self.db = dbstate.db self.names = names self.nametypes = set() for rownum, row in enumerate(self.names): row.rownum = rownum code, text = row.nametype.serialize() self.nametypes.add((code, text)) ManagedWindow.__init__(self, self.uistate, [], self.__class__, modal=False) # the self.top.run() below makes Gtk make it modal, so any change to # the previous line's "modal" would require that line to be changed DbGUIElement.__init__(self, dbstate.db) self.draw_window() self.set_window(self.top, None, _("Name editor")) self.setup_configs('interface.names', 400, 350) self.show()
def __init__(self, dbstate, user, options_class, name, callback=None): uistate = user.uistate self.label = _('Capitalization changes') self.dbstate = dbstate self.uistate = uistate 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 given_name_dict = self.get_given_name_dict() self.progress = ProgressMeter(_('Checking Given Names'),'', parent=uistate.window) self.progress.set_pass(_('Searching given names'), len(given_name_dict.keys())) self.name_list = [] for name in given_name_dict.keys(): if name != capitalize(name): self.name_list.append((name, given_name_dict[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 __init__(self, uistate, track, data, name): self.name = name title = _("%(str1)s: %(str2)s") % {'str1': _("Detailed Info"), 'str2': name} ManagedWindow.__init__(self, uistate, track, self) dlg = Gtk.Dialog(title="", transient_for=uistate.window, destroy_with_parent=True) dlg.add_button(_('_Close'), Gtk.ResponseType.CLOSE) self.set_window(dlg, None, title) self.setup_configs('interface.plugininfo', 720, 520) self.window.connect('response', # pylint: disable=no-member self.close) scrolled_window = Gtk.ScrolledWindow(expand=True) # scrolled_window.set_policy(Gtk.PolicyType.AUTOMATIC, # Gtk.PolicyType.AUTOMATIC) self.text = Gtk.TextView() scrolled_window.add(self.text) self.text.get_buffer().set_text(data) # pylint: disable=no-member self.window.get_content_area().add(scrolled_window) self.show()
def __init__(self, dbstate, user, options_class, name, callback=None): uistate = user.uistate self.label = _("Gender Statistics tool") tool.Tool.__init__(self, dbstate, options_class, name) if uistate: ManagedWindow.__init__(self, uistate, [], self.__class__) stats_list = [] for name, value in dbstate.db.genderStats.stats.items(): stats_list.append((name, ) + value + ( _GENDER[dbstate.db.genderStats.guess_gender(name)], )) if uistate: titles = [(_('Name'), 0, 100), (_('Male'), 1, 70, INTEGER), (_('Female'), 2, 70, INTEGER), (_('Unknown'), 3, 70, INTEGER), (_('Guess'), 4, 70)] treeview = Gtk.TreeView() model = ListModel(treeview, titles) for entry in stats_list: model.add(entry, entry[0]) window = Gtk.Window() window.set_default_size(400, 300) s = Gtk.ScrolledWindow() s.add(treeview) window.add(s) window.show_all() self.set_window(window, None, self.label) self.show() else: print('\t%s' * 5 % ('Name', 'Male', 'Female', 'Unknown', 'Guess')) print() for entry in stats_list: print('\t%s' * 5 % entry)
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 __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, uistate, track): self.uistate = uistate self.dbstate = dbstate self._show_builtins = None self._show_hidden = None self.options = PluginManagerOptions('pluginmanager') #tool.Tool.__init__(self, dbstate, options_class, 'pluginmanager') self.options.load_previous_values() self.options_dict = self.options.handler.options_dict self.window = Gtk.Dialog(title=TITLE) ManagedWindow.__init__(self, uistate, track, self.__class__) self.set_window(self.window, None, TITLE, None) self._pmgr = GuiPluginManager.get_instance() self._preg = PluginRegister.get_instance() # obtain hidden plugins from the pluginmanager self.hidden = self._pmgr.get_hidden_plugin_ids() self.setup_configs('interface.pluginstatus', 750, 400) help_btn = self.window.add_button( # pylint: disable=no-member _("_Help"), Gtk.ResponseType.HELP) self.btn_box = help_btn.get_parent() self.btn_box.set_child_non_homogeneous(help_btn, True) # filter input box self.filter_entry = Gtk.SearchEntry() self.filter_entry.set_tooltip_text( _("Enter search words to filter the addons.\n" "All the words must be present somewhere in the row or\n" "the addon filename to be included in the search.\n" "Word case and order is ignored.")) self.filter_entry.set_placeholder_text(_("Search...")) self.btn_box.pack_start(self.filter_entry, True, True, 0) #self.btn_box.set_child_non_homogeneous(self.filter_entry, True) self.filter_entry.connect('search-changed', self.filter_str_changed) update_btn = self.window.add_button( # pylint: disable=no-member _("Check for updated addons now"), UPDATE_RES) self.btn_box.set_child_non_homogeneous(update_btn, True) if __debug__: # Only show the "Reload" button when in debug mode # (without -O on the command line) reload_btn = self.window.add_button( # pylint: disable=no-member _("Reload"), RELOAD_RES) self.btn_box.set_child_non_homogeneous(reload_btn, True) _w0, _wx_ = reload_btn.get_preferred_width() else: _w0 = 0 cls_btn = self.window.add_button(_('_Close'), Gtk.ResponseType.CLOSE) self.btn_box.set_child_non_homogeneous(cls_btn, True) _w1, dummy = help_btn.get_preferred_width() _w2, dummy = cls_btn.get_preferred_width() _w3, dummy = update_btn.get_preferred_width() #_wa, dummy = self.window.get_size() _we = 790 - _w0 - _w1 - _w2 - _w3 - 60 self.filter_entry.set_size_request(_we, -1) labeltitle, widget = self.registered_plugins_panel(None) self.window.vbox.pack_start(widget, True, True, 0) sep = Gtk.Separator.new(Gtk.Orientation.HORIZONTAL) self.window.vbox.pack_start(sep, False, False, 3) self.restart_needed = False self.window.connect('response', self.done) self.show() self.__populate_reg_list()
def __init__(self, dbstate, uistate, plugins, callback=None): """ A dialog to import a file into Gramps """ self.dbstate = dbstate self.uistate = uistate self.plugins = plugins self.debug = True self.title = _("Plugin installation from a ZIP file") ManagedWindow.__init__(self, uistate, [], self.__class__, modal=True) # the choose_plugin_name_dialog.run() below makes it modal, so any change to # the previous line's "modal" would require that line to be changed import_dialog = Gtk.FileChooserDialog( title='', transient_for=self.uistate.window, action=Gtk.FileChooserAction.OPEN) import_dialog.add_buttons(_('_Cancel'), Gtk.ResponseType.CANCEL, _('Open'), Gtk.ResponseType.OK) self.set_window(import_dialog, None, self.title) self.setup_configs('interface.zipimportfiledialog', 780, 630) import_dialog.set_local_only(False) # Always add automatic (match all files) filter add_supported_files_filter(import_dialog) # .zip and .tgz add_tgz_files_filter(import_dialog) # *.tgz add_zip_files_filter(import_dialog) # *.zip add_all_files_filter(import_dialog) # * import_dialog.set_current_folder(config.get('paths.recent-import-dir')) while True: # the choose_plugin_name_dialog.run() makes it modal, so any change to that # line would require the ManagedWindow.__init__ to be changed also response = import_dialog.run() if response == Gtk.ResponseType.CANCEL: break elif response == Gtk.ResponseType.DELETE_EVENT: # ??? return elif response == Gtk.ResponseType.OK: filename = import_dialog.get_filename() #if self.check_errors(filename): # # displays errors if any # continue (the_path, the_file) = os.path.split(filename) config.set('paths.recent-import-dir', the_path) if not self.extension_ok(the_file): ErrorDialog(_("Error"), _("Could not open file: %s") % the_file + ": " + _('File is not a .zip or .tgz file.\n\n'), parent=self.uistate.window) continue try: plugindata = self.get_plugin_data(filename) except Exception as e: traceback.print_exc() ErrorDialog(_("Error"), _("Could not process file %s") % filename + ": " + str(e), parent=self.uistate.window) continue plugin_info = None for plugin_id in plugindata: plugin_info = plugindata[plugin_id] plugin_name = plugin_info['name'] if plugin_id in self.plugins: # print(plugin_id,"already exists") p = self.plugins[plugin_id] old_plugin = p if self.debug: ptypestr = PTYPE_STR[p.ptype] print(" type:", ptypestr) print(" name:", p.name) print(" desc:", p.description) print(" path:", p.fpath) print(" file:", p.fname) print(" version:", p.version) print() print("This plugin:") print(plugin_info) else: old_plugin = None if not plugin_info: # some error, possibly invalid gpr file? continue self.backup_zipfname = None self.gramps_view_installed = False try: dirname = self.install_plugin_dialog( filename, plugin_info, old_plugin) except Exception as e: traceback.print_exc() ErrorDialog(_("Error"), _("Could not process file %s") % filename + ": " + str(e), parent=self.uistate.window) continue msg = _("Plugin '%s' installed in\n %s") % (plugin_name, dirname) if self.backup_zipfname: msg += _("\nOld version saved in\n %s" ) % self.backup_zipfname if self.gramps_view_installed: msg += _("\n\nRestart Gramps.") if dirname: OkDialog(_("Installed"), msg, parent=self.uistate.window) break self.close()
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 __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 }, 'citations': { 'get_func': self.db.get_citation_from_handle, 'remove': self.db.remove_citation, 'get_text': None, 'editor': 'EditCitation', 'icon': 'gramps-citation', 'name_ix': 3 }, '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_media_from_handle, 'remove': self.db.remove_media, '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__(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( # parent-OK _('Checking Family Names'), '', parent=uistate.window) 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'), # parent-OK _("No capitalization changes were detected."), parent=uistate.window)
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 __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) 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 __init__(self, dbstate, user, options_class, name, callback=None): uistate = user.uistate tool.Tool.__init__(self, dbstate, options_class, name) self.window_name = _('Note Cleanup Tool') ManagedWindow.__init__(self, uistate, [], self.__class__) self.dbstate = dbstate self.trans = None self.moved_files = [] self.titles = [_('Cleaned Notes'), _('Links Only'), _('Issues')] self.models = [] self.views = [] self.changelist = [] self.changelistidx = 0 window = MyWindow(self.dbstate, self.uistate, []) vbox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL) hbox = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL) hbox.set_homogeneous(True) rvbox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=2, width_request=400) vbox.pack_start(hbox, True, True, 5) self.notebook = Gtk.Notebook() self.notebook.set_scrollable(True) self.notebook.connect('switch-page', self.pagesw) for title in self.titles: self.create_tab(title) hbox.pack_start(self.notebook, True, True, 3) hbox.pack_start(rvbox, True, True, 3) bbox = Gtk.ButtonBox(orientation=Gtk.Orientation.HORIZONTAL) vbox.pack_start(bbox, False, False, 5) close = Gtk.Button(label=_('Close')) close.set_tooltip_text(_('Close the Note Cleanup Tool')) close.connect('clicked', self.close) save = Gtk.Button(label=_('Save All')) save.set_tooltip_text(_('Save All Changes')) save.connect('clicked', self.saveit) search = Gtk.Button(label=_('Search')) search.set_tooltip_text(_('Search for Untidy Notes')) search.connect('clicked', self.cleanup) testnote = Gtk.Button(label=_('Generate Test Notes')) testnote.set_tooltip_text(_( 'Generate Test notes in range N99996-N99999.\n' 'These are added to your database, so you may want to work with' ' a test database or delete them later.')) testnote.connect('clicked', self.gentest) export = Gtk.Button(label=_('Export')) export.set_tooltip_text(_('Export the results to a text file')) export.connect('clicked', self.export_results) bbox.add(search) bbox.add(testnote) bbox.add(export) bbox.add(save) bbox.add(close) self.tb = StyledTextEditor() self.tb.set_editable(False) self.tb.set_wrap_mode(Gtk.WrapMode.WORD) tbw = Gtk.ScrolledWindow() tbw.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC) tbw.add(self.tb) rvbox.pack_start(tbw, True, True, 0) self.ta = StyledTextEditor() self.ta.set_transient_parent(window) self.ta.set_editable(True) self.ta.set_wrap_mode(Gtk.WrapMode.WORD) taw = Gtk.ScrolledWindow() taw.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC) taw.add(self.ta) # tat=self.ta.get_toolbar() tat, self.action_group = self.ta.create_toolbar( uistate.uimanager, window) tat.set_icon_size(Gtk.IconSize.SMALL_TOOLBAR) tatb = tat.get_nth_item(5) tat.remove(tatb) tatb = tat.get_nth_item(5) tat.remove(tatb) rvbox.pack_start(tat, False, False, 0) rvbox.pack_start(taw, True, True, 0) self.clear_models() vbox.show_all() window.add(vbox) window.set_size_request(800, 400) self.set_window(window, None, self.window_name) self.show() self.show_tabs() WarningDialog( self.window_name, _("Please back up your database before running this tool.\n\n" "Start the tool by pressing the 'Search' button, then review" " the results.\n" "When satisifed press the 'Save All' button to save your work.\n" "You may export a summary list of the notes that" " were found using the 'Export' button."), self.window)
def __init__(self, uistate, dbstate, maps, layer, places, lat, lon, function, oldvalue=None): """ Place Selection initialization """ try: ManagedWindow.__init__(self, uistate, [], PlaceSelection) except WindowActiveError: return self.uistate = uistate self.dbstate = dbstate self.lat = lat self.lon = lon self.osm = maps self.radius = 1.0 self.circle = None self.oldvalue = oldvalue self.place_list = places self.function = function self.selection_layer = layer self.layer = layer self.set_window( Gtk.Dialog(_('Place Selection in a region'), buttons=(_('_Close'), Gtk.ResponseType.CLOSE)), None, _('Place Selection in a region'), None) label = Gtk.Label(label=_('Choose the radius of the selection.\n' 'On the map you should see a circle or an' ' oval depending on the latitude.')) label.set_valign(Gtk.Align.END) self.window.vbox.pack_start(label, False, True, 0) adj = Gtk.Adjustment(value=1.0, lower=0.1, upper=3.0, step_increment=0.1, page_increment=0, page_size=0) # default value is 1.0, minimum is 0.1 and max is 3.0 slider = Gtk.Scale(orientation=Gtk.Orientation.HORIZONTAL, adjustment=adj) slider.set_digits(1) slider.set_value_pos(Gtk.PositionType.BOTTOM) slider.connect('value-changed', self.slider_change, self.lat, self.lon) self.window.vbox.pack_start(slider, False, True, 0) self.vadjust = Gtk.Adjustment(page_size=15) self.scroll = Gtk.ScrolledWindow(self.vadjust) self.scroll.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC) self.scroll.set_shadow_type(Gtk.ShadowType.IN) self.plist = Gtk.ListStore(str, str, str, str) self.choices = Gtk.TreeView(self.plist) self.scroll.add(self.choices) self.renderer = Gtk.CellRendererText() self.tvcol1 = Gtk.TreeViewColumn(_('Country'), self.renderer, markup=0) self.tvcol2 = Gtk.TreeViewColumn(_('State'), self.renderer, markup=1) self.tvcol3 = Gtk.TreeViewColumn(_('County'), self.renderer, markup=2) self.tvcol1.set_sort_column_id(0) self.tvcol2.set_sort_column_id(1) self.tvcol3.set_sort_column_id(2) self.choices.append_column(self.tvcol1) self.choices.append_column(self.tvcol2) self.choices.append_column(self.tvcol3) self.window.vbox.pack_start(self.scroll, True, True, 0) self.label2 = Gtk.Label() self.label2.set_markup('<span background="green" foreground="black"' '>%s</span>' % _('The green values in the row correspond ' 'to the current place values.')) self.label2.set_valign(Gtk.Align.END) self.window.vbox.pack_start(self.label2, False, True, 0) self.window.set_default_size(400, 300) self.choices.connect('row-activated', self.selection, function) self.window.connect('response', self.close) self.window.show_all() self.show() self.label2.hide() self.slider_change(None, lat, lon)
def __init__(self, dbstate, user, options_class, name, callback=None): uistate = user.uistate ManagedWindow.__init__(self, uistate, [], self.__class__) tool.Tool.__init__(self, dbstate, options_class, name) self.display()
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", "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 = GladeWidgetsWrapper(glade_file, self) self.glade.add_from_file(glade_file) from gi.repository import GObject GObject.GObject.__init__(self.glade) window = self.glade.get_object('edit_birth') 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.glade = Glade(glade_file) #self.glade = GladeWidgetsWrapper(glade_file, self) 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) #GObject.__init__() takes exactly 0 arguments #self.text = Gtk.EntryBuffer('Gtk.Entry._get...', 5) # tests path = os.path.join(USER_PLUGINS, 'SourceIndex') self.rinfo = 'Library of usercity' callnumber = 'BX42_xzertra58364' # inherited or seizure source_handle = '_123456789' # or call the source title citation_handle = '_987654321' # or call any id self.avol = 'Page 105 n°56' self.aname = 'Civil book (Birth 1650)' separator = 'ↄ' name = self.rinfo + separator + callnumber + separator \ + source_handle + separator + citation_handle + separator \ + self.avol + separator + self.aname + '.xml' filename = os.path.join(path, name) self.write_xml( filename, 'B0001', 'DATE', 'PRÉNOM' ) #self._setup_fields() self.window.show() self.parse_xml(filename)
def __init__(self, dbstate, user, options_class, name, callback=None): uistate = user.uistate self.title = _('Find database loop') ManagedWindow.__init__(self, uistate, [], self.__class__) self.dbstate = dbstate self.uistate = uistate #self.db = CacheProxyDb(dbstate.db) self.db = dbstate.db top_dialog = Glade() top_dialog.connect_signals({ "destroy_passed_object" : self.close, "on_help_clicked" : self.on_help_clicked, "on_delete_event" : self.close, }) window = top_dialog.toplevel title = top_dialog.get_object("title") self.set_window(window, title, self.title) # start the progress indicator self.progress = ProgressMeter(self.title, _('Starting'), parent=uistate.window) self.progress.set_pass(_('Looking for possible loop for each person'), self.db.get_number_of_people()) self.model = Gtk.ListStore( GObject.TYPE_STRING, # 0==father id GObject.TYPE_STRING, # 1==father GObject.TYPE_STRING, # 2==son id GObject.TYPE_STRING, # 3==son GObject.TYPE_STRING, # 4==family gid GObject.TYPE_STRING) # 5==loop number self.model.set_sort_column_id( Gtk.TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID, 0) self.treeview = top_dialog.get_object("treeview") self.treeview.set_model(self.model) col0 = Gtk.TreeViewColumn('', Gtk.CellRendererText(), text=5) col1 = Gtk.TreeViewColumn(_('Gramps ID'), Gtk.CellRendererText(), text=0) col2 = Gtk.TreeViewColumn(_('Parent'), Gtk.CellRendererText(), text=1) col3 = Gtk.TreeViewColumn(_('Gramps ID'), Gtk.CellRendererText(), text=2) col4 = Gtk.TreeViewColumn(_('Child'), Gtk.CellRendererText(), text=3) col5 = Gtk.TreeViewColumn(_('Family ID'), Gtk.CellRendererText(), text=4) col1.set_resizable(True) col2.set_resizable(True) col3.set_resizable(True) col4.set_resizable(True) col5.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) col5.set_sizing(Gtk.TreeViewColumnSizing.AUTOSIZE) self.treeview.append_column(col0) self.treeview.append_column(col1) self.treeview.append_column(col2) self.treeview.append_column(col3) self.treeview.append_column(col4) self.treeview.append_column(col5) self.treeselection = self.treeview.get_selection() self.treeview.connect('row-activated', self.rowactivated_cb) self.curr_fam = None people = self.db.get_person_handles() self.total = len(people) # total number of people to process. self.count = 0 # current number of people completely processed self.loop = 0 # Number of loops found for GUI pset = OrderedDict() # pset is the handle list of persons from the current start of # exploration path to the current limit. The use of OrderedDict # allows us to use it as a LIFO during recursion, as well as makes for # quick lookup. If we find a loop, pset provides a nice way to get # the loop path. self.done = set() # self.done is the handle set of people that have been fully explored # and do NOT have loops in the decendent tree. We use this to avoid # repeating work when we encounter one of these during the search. for person_handle in people: person = self.db.get_person_from_handle(person_handle) self.current = person self.parent = None self.descendants(person_handle, pset) # close the progress bar 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.db = dbstate.db self.uistate = uistate self.map = {} self.list = [] self.index = 0 self.fam_h = self.fam_iter = self.family = self.progress = None self.update = callback self.top = Gtk.Builder() # Found out that Glade does not support translations for plugins, so # have to do it manually. base = os.path.dirname(__file__) glade_file = base + os.sep + "birthorder.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 BirthOrder failed!") # start with a file name dialog self.top.add_from_file(glade_file) # self.top = Glade() self.fam_liststore = self.top.get_object("fam_liststore") self.ch_liststore = self.top.get_object("ch_liststore") self.ch_liststore_s = self.top.get_object("ch_liststore_s") self.fam_view = self.top.get_object("Families_treeview") self.ch_view = self.top.get_object("children_treeview") self.ch_view_s = self.top.get_object("children_treeview_s") chs_style_cntx = self.ch_view.get_style_context() style_provider = Gtk.CssProvider() style_provider.load_from_data(CSS.encode('utf8')) chs_style_cntx.add_provider(style_provider, Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION) window = self.top.get_object("main") self.set_window(window, None, TITLE) self.setup_configs('interface.birthordertool', 750, 520) self.top.connect_signals({ "on_close": self.close, "on_help_clicked": self.on_help_clicked, "on_delete_event": self.close, "on_accept_clicked": self.on_accept, "on_easy_clicked": self.on_easy, "on_accept_all_clicked": self.on_accept_all, "on_up_btn_clicked": self.on_up, "on_down_btn_clicked": self.on_down }) self.fam_sel = self.fam_view.get_selection() self.fam_sel.connect('changed', self.on_fam_row_changed) self.ch_s_sel = self.ch_view_s.get_selection() self.show() self.find_potentials() if len(self.fam_liststore) == 0: self.kill_buttons() OkDialog(_("No families need sorting"), _("No children were out of birth order."), parent=self.window)
def __init__(self, dbstate, user, options_class, name, callback=None): uistate = user.uistate tool.Tool.__init__(self, dbstate, options_class, name) self.window_name = _('Types Cleanup Tool') ManagedWindow.__init__(self, uistate, [], self.__class__) self.db = dbstate.db self.dbstate = dbstate # Create a dict of dicts of lists. The first level dict has primary # objects as keys. The second level dict has type names for keys, # and lists of references as values. # the list is of (object_type, handle) tuples for each reference. self.types_dict = { obj: {} for (_attr, _name, obj, _srcobj) in self.t_table } window = Gtk.Window() window.set_size_request(740, 500) window.set_position(Gtk.WindowPosition.CENTER_ON_PARENT) self.set_window(window, None, self.window_name) # main area vbox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL) window.add(vbox) hbox = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, expand=True) vbox.add(hbox) # left types tree scrolled_window = Gtk.ScrolledWindow(min_content_width=250) scrolled_window.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC) hbox.pack_start(scrolled_window, False, True, 2) # right references tree scrolled_window_r = Gtk.ScrolledWindow(hexpand=True) scrolled_window_r.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC) hbox.pack_start(scrolled_window_r, True, True, 2) # Buttons etc. bbox = Gtk.ButtonBox(orientation=Gtk.Orientation.HORIZONTAL) vbox.pack_start(bbox, False, False, 5) # Help help_btn = Gtk.Button(label=_('Help')) help_btn.connect('clicked', self.on_help_clicked) bbox.add(help_btn) # Delete self.del_btn = Gtk.Button(label=_('Remove')) self.del_btn.set_tooltip_text( _('Remove the selected type from the db.\n' 'This does not change any referenced objects.')) self.del_btn.connect('clicked', self.delete) self.del_btn.set_sensitive(False) bbox.add(self.del_btn) # Combo self.cbox = Gtk.Box() self.cbox.set_tooltip_text( _('Select a new name for the current type, prior to renaming the ' 'type in the referenced objects.')) self.combo = Gtk.ComboBox.new_with_entry() self.combo.get_child().set_width_chars(40) self.cbox.add(self.combo) bbox.add(self.cbox) self.type_name = None # Rename self.ren_btn = Gtk.Button(label=_('Rename')) self.ren_btn.connect('clicked', self.rename) self.ren_btn.set_tooltip_text( _('Rename the selected type in all referenced objects.')) bbox.add(self.ren_btn) # close close_btn = Gtk.Button(label=_('Close')) close_btn.set_tooltip_text(_('Close the Type Cleanup Tool')) close_btn.connect('clicked', self.close) bbox.add(close_btn) # left types treeview view = Gtk.TreeView() view.expand_all() column = Gtk.TreeViewColumn(_('Types')) view.append_column(column) cell = Gtk.CellRendererText() column.pack_start(cell, True) column.add_attribute(cell, 'text', 0) column.set_sort_column_id(0) column.set_sort_indicator(True) # model: a tree of types and their custom values # Type name, t_table index for type, db cust type list index for type self.model = Gtk.TreeStore(str, int, int) self.model_load() view.set_model(self.model) view.show() selection = view.get_selection() selection.connect('changed', self.selection_changed) scrolled_window.add(view) # right references treeview view = Gtk.TreeView(hexpand=True) column = Gtk.TreeViewColumn(_("Type")) view.append_column(column) cell = Gtk.CellRendererText() column.pack_start(cell, True) column.add_attribute(cell, 'text', 0) column.set_sort_column_id(0) column.set_sort_indicator(True) column = Gtk.TreeViewColumn(_("References")) view.append_column(column) cell = Gtk.CellRendererText() column.pack_start(cell, True) column.add_attribute(cell, 'text', 1) column.set_expand(True) column.set_resizable(True) column.set_sort_column_id(1) column.set_sort_indicator(True) # model: a list of type references # translated object_type, object display name, handle, object class self.model_r = Gtk.ListStore(str, str, str, str) view.set_model(self.model_r) view.show() view.connect('row_activated', self.button_press) scrolled_window_r.add(view) self.show()