def create_event(self, description=_("Estimated date"),
type=None, date=None, source=None,
note_text="", modifier=None):
event = Event()
event.set_description(description)
note = Note()
note.handle = create_id()
note.type.set(NoteType.EVENT)
note.set(note_text)
self.db.add_note(note, self.trans)
event.add_note(note.handle)
if type:
event.set_type(EventType(type))
if date:
if modifier:
date.set_modifier(modifier)
date.set_quality(Date.QUAL_ESTIMATED)
date.set_yr_mon_day(date.get_year(), 0, 0)
event.set_date_object(date)
if source:
citation = Citation()
citation.set_reference_handle(source.get_handle())
self.db.add_citation(citation, self.trans)
event.add_citation(citation.get_handle())
self.db.commit_source(source, self.trans)
self.db.add_event(event, self.trans)
return event
def instance_from_struct(cls, struct):
"""
Given a struct with metadata, create a Gramps object.
self is class when called as a classmethod.
"""
from gramps.gen.lib import (Person, Family, Event, Source, Place,
Citation, Repository, Media, Note, Tag,
Date)
if isinstance(struct, dict):
if "_class" in struct.keys():
if struct["_class"] == "Person":
return Person.create(Person.from_struct(struct))
elif struct["_class"] == "Family":
return Family.create(Family.from_struct(struct))
elif struct["_class"] == "Event":
return Event.create(Event.from_struct(struct))
elif struct["_class"] == "Source":
return Source.create(Source.from_struct(struct))
elif struct["_class"] == "Place":
return Place.create(Place.from_struct(struct))
elif struct["_class"] == "Citation":
return Citation.create(Citation.from_struct(struct))
elif struct["_class"] == "Repository":
return Repository.create(Repository.from_struct(struct))
elif struct["_class"] == "Media":
return Media.create(Media.from_struct(struct))
elif struct["_class"] == "Note":
return Note.create(Note.from_struct(struct))
elif struct["_class"] == "Tag":
return Tag.create(Tag.from_struct(struct))
elif struct["_class"] == "Date":
return Date().unserialize(
Date.from_struct(struct, full=True))
raise AttributeError("invalid struct: %s" % struct)
def from_struct(struct):
"""
Given a struct with metadata, create a Gramps object.
"""
from gramps.gen.lib import (Person, Family, Event, Source, Place, Citation,
Repository, MediaObject, Note, Tag)
if isinstance(struct, dict):
if "_class" in struct.keys():
if struct["_class"] == "Person":
return Person.create(Person.from_struct(struct))
elif struct["_class"] == "Family":
return Family.create(Family.from_struct(struct))
elif struct["_class"] == "Event":
return Event.create(Event.from_struct(struct))
elif struct["_class"] == "Source":
return Source.create(Source.from_struct(struct))
elif struct["_class"] == "Place":
return Place.create(Place.from_struct(struct))
elif struct["_class"] == "Citation":
return Citation.create(Citation.from_struct(struct))
elif struct["_class"] == "Repository":
return Repository.create(Repository.from_struct(struct))
elif struct["_class"] == "MediaObject":
return MediaObject.create(MediaObject.from_struct(struct))
elif struct["_class"] == "Note":
return Note.create(Note.from_struct(struct))
elif struct["_class"] == "Tag":
return Tag.create(Tag.from_struct(struct))
raise AttributeError("invalid struct: %s" % struct)
def instance_from_struct(cls, struct):
"""
Given a struct with metadata, create a Gramps object.
self is class when called as a classmethod.
"""
from gramps.gen.lib import (Person, Family, Event, Source, Place, Citation,
Repository, Media, Note, Tag, Date)
if isinstance(struct, dict):
if "_class" in struct.keys():
if struct["_class"] == "Person":
return Person.create(Person.from_struct(struct))
elif struct["_class"] == "Family":
return Family.create(Family.from_struct(struct))
elif struct["_class"] == "Event":
return Event.create(Event.from_struct(struct))
elif struct["_class"] == "Source":
return Source.create(Source.from_struct(struct))
elif struct["_class"] == "Place":
return Place.create(Place.from_struct(struct))
elif struct["_class"] == "Citation":
return Citation.create(Citation.from_struct(struct))
elif struct["_class"] == "Repository":
return Repository.create(Repository.from_struct(struct))
elif struct["_class"] == "Media":
return Media.create(Media.from_struct(struct))
elif struct["_class"] == "Note":
return Note.create(Note.from_struct(struct))
elif struct["_class"] == "Tag":
return Tag.create(Tag.from_struct(struct))
elif struct["_class"] == "Date":
return Date().unserialize(Date.from_struct(struct, full=True))
raise AttributeError("invalid struct: %s" % struct)
def create_event(self, description=_("Estimated date"),
type=None, date=None, source=None,
note_text="", modifier=None):
event = Event()
event.set_description(description)
note = Note()
note.handle = create_id()
note.type.set(NoteType.EVENT)
note.set(note_text)
self.db.add_note(note, self.trans)
event.add_note(note.handle)
if type:
event.set_type(EventType(type))
if date:
if modifier:
date.set_modifier(modifier)
date.set_quality(Date.QUAL_ESTIMATED)
date.set_yr_mon_day(date.get_year(), 0, 0)
event.set_date_object(date)
if source:
citation = Citation()
citation.set_reference_handle(source.get_handle())
self.db.add_citation(citation, self.trans)
event.add_citation(citation.get_handle())
self.db.commit_source(source, self.trans)
self.db.add_event(event, self.trans)
return event
def from_struct(struct):
"""
Given a struct with metadata, create a Gramps object.
"""
from gramps.gen.lib import (Person, Family, Event, Source, Place, Citation,
Repository, MediaObject, Note, Tag)
if isinstance(struct, dict):
if "_class" in struct.keys():
if struct["_class"] == "Person":
return Person.create(Person.from_struct(struct))
elif struct["_class"] == "Family":
return Family.create(Family.from_struct(struct))
elif struct["_class"] == "Event":
return Event.create(Event.from_struct(struct))
elif struct["_class"] == "Source":
return Source.create(Source.from_struct(struct))
elif struct["_class"] == "Place":
return Place.create(Place.from_struct(struct))
elif struct["_class"] == "Citation":
return Citation.create(Citation.from_struct(struct))
elif struct["_class"] == "Repository":
return Repository.create(Repository.from_struct(struct))
elif struct["_class"] == "MediaObject":
return MediaObject.create(MediaObject.from_struct(struct))
elif struct["_class"] == "Note":
return Note.create(Note.from_struct(struct))
elif struct["_class"] == "Tag":
return Tag.create(Tag.from_struct(struct))
raise AttributeError("invalid struct: %s" % struct)
def object_extend(self, obj: Citation, args: Dict) -> Citation:
"""Extend citation attributes as needed."""
if "extend" in args:
db_handle = self.db_handle
obj.extended = get_extended_attributes(db_handle, obj, args)
if "all" in args["extend"] or "source" in args["extend"]:
obj.extended["source"] = get_source_by_handle(
db_handle, obj.source_handle, args)
return obj
def citation_sort_date(self, data):
if data[COLUMN_DATE]:
citation = Citation()
citation.unserialize(data)
retval = "%09d" % citation.get_date_object().get_sort_value()
if not get_date_valid(citation):
return INVALID_DATE_FORMAT % retval
else:
return retval
return ''
def citation_sort_date(self, data):
if data[COLUMN_DATE]:
citation = Citation()
citation.unserialize(data)
retval = "%09d" % citation.get_date_object().get_sort_value()
if not get_date_valid(citation):
return INVALID_DATE_FORMAT % retval
else:
return retval
return ''
def citation_date(self, data):
if data[COLUMN_DATE]:
citation = Citation()
citation.unserialize(data)
date_str = get_date(citation)
if date_str != "":
retval = escape(date_str)
if not get_date_valid(citation):
return INVALID_DATE_FORMAT % retval
else:
return retval
return ''
def citation_date(self, data):
if data[COLUMN_DATE]:
citation = Citation()
citation.unserialize(data)
date_str = get_date(citation)
if date_str != "":
retval = escape(date_str)
if not get_date_valid(citation):
return INVALID_DATE_FORMAT % retval
else:
return retval
return ''
def object_extend(self,
obj: Citation,
args: Dict,
locale: GrampsLocale = glocale) -> Citation:
"""Extend citation attributes as needed."""
if "profile" in args:
obj.profile = get_citation_profile_for_object(
self.db_handle, obj, args["profile"])
if "extend" in args:
obj.extended = get_extended_attributes(self.db_handle, obj, args)
if "all" in args["extend"] or "source_handle" in args["extend"]:
obj.extended["source"] = get_source_by_handle(
self.db_handle, obj.source_handle, args)
return obj
def __new_form(self, widget):
"""
Create a new form and invoke the editor.
"""
sel = SelectForm(self.dbstate, self.uistate, [])
source_handle = sel.run()
if source_handle:
citation = Citation()
citation.set_reference_handle(source_handle)
try:
EditForm(self.gui.dbstate, self.gui.uistate, [], citation,
self.update)
except WindowActiveError:
pass
def on_ok_clicked(self):
"""
Method that is run when you click the OK button. The numbers of sources
and citations are retrieved from the entry box and used to govern the
amount of data generated
"""
num_sources_text = self.sources_entry.get_text()
try:
num_sources = int(num_sources_text)
except:
return
num_citations_text = self.citations_entry.get_text()
num_citations = int(num_citations_text)
self.progress = ProgressMeter(
'Generating data', '', parent=self.uistate.window)
self.progress.set_pass('Generating data',
num_sources*num_citations)
LOG.debug("sources %04d citations %04d" % (num_sources,
num_citations))
source = Source()
citation = Citation()
self.db.disable_signals()
with DbTxn('Populate sources and citations', self.db) as trans:
for i in range(num_sources):
source.gramps_id = None
source.handle = None
source.title = "Source %04d" % (i + 1)
source_handle = self.db.add_source(source, trans)
for j in range(num_citations):
citation.gramps_id = None
citation.handle = None
citation.source_handle = source_handle
citation.page = "Page %04d" % (j + 1)
self.db.add_citation(citation, trans)
self.progress.step()
LOG.debug("sources and citations added")
self.db.enable_signals()
self.db.request_rebuild()
self.progress.close()
self.options.handler.options_dict['sources'] = num_sources
self.options.handler.options_dict['citations'] = num_citations
# Save options
self.options.handler.save_options()
def get_or_create_source(self,source_name):
source = None
if source_name in self.skeys:
source = self.db.get_source_from_handle(self.skeys[source_name])
else:
source = Source()
source.set_title(source_name)
self.db.add_source(source,self.trans)
self.db.commit_source(source,self.trans)
self.skeys[source_name] = source.get_handle()
citation = Citation()
citation.set_reference_handle(source.get_handle())
self.db.add_citation(citation, self.trans)
self.db.commit_citation(citation, self.trans)
return citation
def get_or_create_source(self, source_name):
source = None
if source_name in self.skeys:
source = self.db.get_source_from_handle(self.skeys[source_name])
else:
source = Source()
source.set_title(source_name)
self.db.add_source(source, self.trans)
self.db.commit_source(source, self.trans)
self.skeys[source_name] = source.get_handle()
citation = Citation()
citation.set_reference_handle(source.get_handle())
self.db.add_citation(citation, self.trans)
self.db.commit_citation(citation, self.trans)
return citation
def empty_object(self):
"""
Return an empty Citation object for comparison for changes.
It is used by the base class L{EditPrimary}.
"""
return Citation()
def share_button_clicked(self, obj):
SelectCitation = SelectorFactory('Citation')
sel = SelectCitation(self.dbstate, self.uistate, self.track)
objct = sel.run()
LOG.debug("selected object: %s" % objct)
# the object returned should either be a Source or a Citation
if objct:
if isinstance(objct, Source):
try:
from .. import EditCitation
EditCitation(self.dbstate, self.uistate, self.track,
Citation(), objct,
callback=self.add_callback,
callertitle=self.callertitle)
except WindowActiveError:
from ...dialog import WarningDialog
WarningDialog(_("Cannot share this reference"),
self.__blocked_text(),
parent=self.uistate.window)
elif isinstance(objct, Citation):
try:
from .. import EditCitation
EditCitation(self.dbstate, self.uistate, self.track,
objct, callback=self.add_callback,
callertitle=self.callertitle)
except WindowActiveError:
from ...dialog import WarningDialog
WarningDialog(_("Cannot share this reference"),
self.__blocked_text(),
parent=self.uistate.window)
else:
raise ValueError("selection must be either source or citation")
def importData(db, filename, user):
"""Function called by Gramps to import data on persons in CSV format."""
db.disable_signals()
try:
with DbTxn(_("JSON import"), db, batch=True) as trans:
with OpenFileOrStdin(filename, encoding="utf-8") as fp:
line = fp.readline()
while line:
data = json.loads(line)
if data["_class"] == "Person":
obj = Person.create(Person.from_struct(data))
db.add_person(obj, trans)
elif data["_class"] == "Family":
obj = Family.create(Family.from_struct(data))
db.add_family(obj, trans)
elif data["_class"] == "Event":
obj = Event.create(Event.from_struct(data))
db.add_event(obj, trans)
elif data["_class"] == "Media":
obj = Media.create(Media.from_struct(data))
db.add_media(obj, trans)
elif data["_class"] == "Repository":
obj = Repository.create(Repository.from_struct(data))
db.add_repository(obj, trans)
elif data["_class"] == "Tag":
obj = Tag.create(Tag.from_struct(data))
db.add_tag(obj, trans)
elif data["_class"] == "Source":
obj = Source.create(Source.from_struct(data))
db.add_source(obj, trans)
elif data["_class"] == "Citation":
obj = Citation.create(Citation.from_struct(data))
db.add_citation(obj, trans)
elif data["_class"] == "Note":
obj = Note.create(Note.from_struct(data))
db.add_note(obj, trans)
elif data["_class"] == "Place":
obj = Place.create(Place.from_struct(data))
db.add_place(obj, trans)
else:
LOG.warn("ignored: " + data)
line = fp.readline()
except EnvironmentError as err:
user.notify_error(_("%s could not be opened\n") % filename, str(err))
db.enable_signals()
db.request_rebuild()
def _add_source(self, repos=None):
# Add a Source
with DbTxn("Add Source and Citation", self._db) as tran:
source = Source()
if repos is not None:
repo_ref = RepoRef()
repo_ref.set_reference_handle(repos.get_handle())
source.add_repo_reference(repo_ref)
self._db.add_source(source, tran)
self._db.commit_source(source, tran)
citation = Citation()
citation.set_reference_handle(source.get_handle())
self._db.add_citation(citation, tran)
self._db.commit_citation(citation, tran)
return citation
def _add_source(self,repos=None):
# Add a Source
with DbTxn("Add Source and Citation", self._db) as tran:
source = Source()
if repos is not None:
repo_ref = RepoRef()
repo_ref.set_reference_handle(repos.get_handle())
source.add_repo_reference(repo_ref)
self._db.add_source(source, tran)
self._db.commit_source(source, tran)
citation = Citation()
citation.set_reference_handle(source.get_handle())
self._db.add_citation(citation, tran)
self._db.commit_citation(citation, tran)
return citation
def add_button_clicked(self, obj):
"""
Create a new Citation instance and call the EditCitation editor with
the new citation.
Called when the Add button is clicked.
If the window already exists (WindowActiveError), we ignore it.
This prevents the dialog from coming up twice on the same object.
"""
try:
from .. import EditCitation
EditCitation(self.dbstate, self.uistate, self.track, Citation(),
Source(), self.add_callback, self.callertitle)
except WindowActiveError:
pass
def find_and_set_citation(self, obj, source):
# look for the source in the existing citations for the object
LOG.debug("find_and_set_citation: looking for source: %s",
source.get_gramps_id())
for citation_handle in obj.get_citation_list():
citation = self.db.get_citation_from_handle(citation_handle)
LOG.debug("find_and_set_citation: existing citation: %s",
citation.get_gramps_id())
poss_source = self.db.get_source_from_handle(
citation.get_reference_handle())
LOG.debug(" compare source %s == %s", source.get_gramps_id(),
poss_source.get_gramps_id())
if poss_source.get_handle() == source.get_handle():
# The source is already cited
LOG.debug(" source already cited")
return
# we couldn't find an appropriate citation, so we have to create one.
citation = Citation()
LOG.debug(" creating citation")
citation.set_reference_handle(source.get_handle())
self.db.add_citation(citation, self.trans)
LOG.debug(" created citation, citation %s %s" %
(citation, citation.get_gramps_id()))
obj.add_citation(citation.get_handle())
def share(self, obj):
"""
share: Add a new citation to an existing source (when a source is
selected)
"""
for handle in self.selected_handles():
# The handle will either be a Source handle or a Citation handle
source, citation = self.get_source_or_citation(handle)
if not source:
source = self.dbstate.db.get_source_from_handle(
citation.get_reference_handle())
try:
EditCitation(self.dbstate, self.uistate, [], Citation(),
source)
except WindowActiveError:
from gramps.gui.dialog import WarningDialog
WarningDialog(_("Cannot share this reference"),
self.__blocked_text(),
parent=self.uistate.window)
def handle_extra_type(self, objtype, handle):
"""
A SOURCE_LINK object has been dragged
"""
if handle:
objct = self.dbstate.db.get_source_from_handle(handle)
if isinstance(objct, Source):
try:
from .. import EditCitation
EditCitation(self.dbstate, self.uistate, self.track,
Citation(), objct,
callback=self.add_callback,
callertitle=self.callertitle)
except WindowActiveError:
from ...dialog import WarningDialog
WarningDialog(_("Cannot share this reference"),
self.__blocked_text(),
parent=self.uistate.window)
else:
raise ValueError("selection must be either source or citation")
def on_ok_clicked(self):
"""
Method that is run when you click the OK button. The numbers of sources
and citations are retrieved from the entry box and used to govern the
amount of data generated
"""
num_sources_text = self.sources_entry.get_text()
try:
num_sources = int(num_sources_text)
except:
return
num_citations_text = self.citations_entry.get_text()
num_citations = int(num_citations_text)
self.progress = ProgressMeter(
'Generating data', '')
self.progress.set_pass('Generating data',
num_sources*num_citations)
LOG.debug("sources %04d citations %04d" % (num_sources,
num_citations))
source = Source()
citation = Citation()
self.db.disable_signals()
with DbTxn('Populate sources and citations', self.db) as trans:
for i in range(num_sources):
source.gramps_id = None
source.handle = None
source.title = "Source %04d" % (i + 1)
source_handle = self.db.add_source(source, trans)
for j in range(num_citations):
citation.gramps_id = None
citation.handle = None
citation.source_handle = source_handle
citation.page = "Page %04d" % (j + 1)
self.db.add_citation(citation, trans)
self.progress.step()
LOG.debug("sources and citations added")
self.db.enable_signals()
self.db.request_rebuild()
self.progress.close()
self.options.handler.options_dict['sources'] = num_sources
self.options.handler.options_dict['citations'] = num_citations
# Save options
self.options.handler.save_options()
def add(self, obj):
"""
add: Add a new citation and a new source (this can also be done
by source view add a source, then citation view add a new
citation to an existing source)
Create a new Source instance and Citation instance and call the
EditSource editor with the new source.
Called when the Add button is clicked.
If the window already exists (WindowActiveError), we ignore it.
This prevents the dialog from coming up twice on the same object.
However, since the window is identified by the Source object, and
we have just created a new one, it seems to be impossible for the
window to already exist, so this is just an extra safety measure.
"""
try:
EditCitation(self.dbstate, self.uistate, [], Citation(), Source())
except WindowActiveError:
pass
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 share(self, obj):
"""
share: Add a new citation to an existing source (when a source is
selected)
"""
for handle in self.selected_handles():
# The handle will either be a Source handle or a Citation handle
source = self.dbstate.db.get_source_from_handle(handle)
citation = self.dbstate.db.get_citation_from_handle(handle)
if (not source and not citation) or (source and citation):
raise ValueError("selection must be either source or citation")
if source:
try:
EditCitation(self.dbstate, self.uistate, [], Citation(),
source)
except WindowActiveError:
from gramps.gui.dialog import WarningDialog
WarningDialog(_("Cannot share this reference"),
self.__blocked_text())
else:
msg = _("Cannot add citation.")
msg2 = _("In order to add a citation to an existing source, "
" you must select a source.")
ErrorDialog(msg, msg2)
def find_and_set_citation(self, obj, source):
# look for the source in the existing citations for the object
LOG.debug("find_and_set_citation: looking for source: %s",
source.get_gramps_id())
for citation_handle in obj.get_citation_list():
citation = self.db.get_citation_from_handle(citation_handle)
LOG.debug("find_and_set_citation: existing citation: %s",
citation.get_gramps_id())
poss_source = self.db.get_source_from_handle(
citation.get_reference_handle())
LOG.debug(" compare source %s == %s", source.get_gramps_id(),
poss_source.get_gramps_id())
if poss_source.get_handle() == source.get_handle():
# The source is already cited
LOG.debug(" source already cited")
return
# we couldn't find an appropriate citation, so we have to create one.
citation = Citation()
LOG.debug(" creating citation")
citation.set_reference_handle(source.get_handle())
self.db.add_citation(citation, self.trans)
LOG.debug(" created citation, citation %s %s" %
(citation, citation.get_gramps_id()))
obj.add_citation(citation.get_handle())
def make_citation(self, citation):
if self.use_db_cache and citation.cache:
data = citation.from_cache()
else:
data = self.dji.get_citation(citation)
return Citation.create(data)
def on_res_ok_clicked(self, dummy):
""" Accept changes displayed and commit to place.
Also find or create a new enclosing place from parent. """
# do the names
namelist = []
for row in self.alt_store:
if row[0] == 'P':
self.place.name = self.newplace.names[row[4]]
elif row[0] == '\u2714':
namelist.append(self.newplace.names[row[4]])
self.place.alt_names = namelist
# Lat/lon/ID/code/type
self.place.lat = self.top.get_object('latitude').get_text()
self.place.long = self.top.get_object('longitude').get_text()
self.place.gramps_id = self.top.get_object('grampsid').get_text()
self.place.code = self.top.get_object('postal').get_text()
self.place.place_type.set(self.type_combo.get_values())
# Add in URLs if wanted
if self.keepweb:
for url in self.newplace.links:
self.place.add_url(url)
# Enclose in the next level place
next_place = False
parent = None
if not self.keep_enclosure or not self.place.placeref_list:
if self.newplace.parent_ids:
# we might have a parent with geo id 'GEO12345'
parent = self.dbstate.db.get_place_from_gramps_id(
self.newplace.parent_ids[0])
if not parent and self.newplace.parent_names:
# make one, will have to be examined/cleaned later
parent = Place()
parent.title = ', '.join(self.newplace.parent_names)
name = PlaceName()
name.value = parent.title
parent.name = name
parent.gramps_id = self.newplace.parent_ids[0]
with DbTxn(
_("Add Place (%s)") % parent.title,
self.dbstate.db) as trans:
self.dbstate.db.add_place(parent, trans)
next_place = True
if parent:
if located_in(self.dbstate.db, parent.handle,
self.place.handle):
# attempting to create a place loop, not good!
ErrorDialog(_('Place cycle detected'),
msg2=_("The place you chose is enclosed in the"
" place you are workin on!\n"
"Please cancel and choose another "
"place."),
parent=self.uistate.window)
return
# check to see if we already have the enclosing place
already_there = False
for pref in self.place.placeref_list:
if parent.handle == pref.ref:
already_there = True
break
if not already_there:
placeref = PlaceRef()
placeref.set_reference_handle(parent.handle)
self.place.set_placeref_list([placeref])
# Add in Citation/Source if wanted
if self.addcitation and self.newplace.geoid:
src_hndl = self.find_or_make_source()
cit = Citation()
cit.set_reference_handle(src_hndl)
cit.set_page("GeoNames ID: %s" %
self.newplace.geoid.replace('GEO', ''))
with DbTxn(_("Add Citation (%s)") % "GeoNames",
self.dbstate.db) as trans:
self.dbstate.db.add_citation(cit, trans)
self.place.add_citation(cit.handle)
# We're finally ready to commit the updated place
with DbTxn(_("Edit Place (%s)") % self.place.title,
self.dbstate.db) as trans:
self.dbstate.db.commit_place(self.place, trans)
# Jump to enclosing place to clean it if necessary
if next_place:
self.set_active('Place', parent.handle)
self.place = parent
# if geoparse fails, leave us at main view
if self.newplace.parent_ids and \
self.geoparse(self.newplace.parent_ids[0],
_(", ").join(self.newplace.parent_names),
self.newplace.parent_ids,
self.newplace.parent_names):
# geoparse worked, lets put up the results view
self.gui.get_child().remove(self.mainwin)
self.gui.get_child().add(self.results_win)
self.res_gui()
return
self.reset_main()
if self.gui.get_child().get_child() == self.results_win:
self.gui.get_child().remove(self.results_win)
self.gui.get_child().add(self.mainwin)
def exportData(database, filename,
error_dialog=None, option_box=None, callback=None):
if not callable(callback):
callback = lambda percent: None # dummy
with OpenFileOrStdout(filename, encoding="utf-8") as fp:
total = (len(database.note_map) +
len(database.person_map) +
len(database.event_map) +
len(database.family_map) +
len(database.repository_map) +
len(database.place_map) +
len(database.media_map) +
len(database.citation_map) +
len(database.source_map) +
len(database.tag_map))
count = 0.0
# ---------------------------------
# Notes
# ---------------------------------
for handle in database.note_map.keys():
serial = database.note_map[handle]
write_line(fp, Note.create(serial))
count += 1
callback(100 * count/total)
# ---------------------------------
# Event
# ---------------------------------
for handle in database.event_map.keys():
serial = database.event_map[handle]
write_line(fp, Event.create(serial))
count += 1
callback(100 * count/total)
# ---------------------------------
# Person
# ---------------------------------
for handle in database.person_map.keys():
serial = database.person_map[handle]
write_line(fp, Person.create(serial))
count += 1
callback(100 * count/total)
# ---------------------------------
# Family
# ---------------------------------
for handle in database.family_map.keys():
serial = database.family_map[handle]
write_line(fp, Family.create(serial))
count += 1
callback(100 * count/total)
# ---------------------------------
# Repository
# ---------------------------------
for handle in database.repository_map.keys():
serial = database.repository_map[handle]
write_line(fp, Repository.create(serial))
count += 1
callback(100 * count/total)
# ---------------------------------
# Place
# ---------------------------------
for handle in database.place_map.keys():
serial = database.place_map[handle]
write_line(fp, Place.create(serial))
count += 1
callback(100 * count/total)
# ---------------------------------
# Source
# ---------------------------------
for handle in database.source_map.keys():
serial = database.source_map[handle]
write_line(fp, Source.create(serial))
count += 1
callback(100 * count/total)
# ---------------------------------
# Citation
# ---------------------------------
for handle in database.citation_map.keys():
serial = database.citation_map[handle]
write_line(fp, Citation.create(serial))
count += 1
callback(100 * count/total)
# ---------------------------------
# Media
# ---------------------------------
for handle in database.media_map.keys():
serial = database.media_map[handle]
write_line(fp, Media.create(serial))
count += 1
callback(100 * count/total)
# ---------------------------------
# Tag
# ---------------------------------
for handle in database.tag_map.keys():
serial = database.tag_map[handle]
write_line(fp, Tag.create(serial))
count += 1
callback(100 * count/total)
return True
def on_res_ok_clicked(self, dummy):
""" Accept changes displayed and commit to place.
Also find or create a new enclosing place from parent. """
# do the names
namelist = []
for row in self.alt_store:
if row[0] == 'P':
self.place.name = self.newplace.names[row[4]]
elif row[0] == '\u2714':
namelist.append(self.newplace.names[row[4]])
self.place.alt_names = namelist
# Lat/lon/ID/code/type
self.place.lat = self.top.get_object('latitude').get_text()
self.place.long = self.top.get_object('longitude').get_text()
self.place.gramps_id = self.top.get_object('grampsid').get_text()
self.place.code = self.top.get_object('postal').get_text()
self.place.place_type.set(self.type_combo.get_values())
# Add in URLs if wanted
if self.keepweb:
for url in self.newplace.links:
self.place.add_url(url)
# Enclose in the next level place
next_place = False
parent = None
if not self.keep_enclosure or not self.place.placeref_list:
if self.newplace.parent_ids:
# we might have a parent with geo id 'GEO12345'
parent = self.dbstate.db.get_place_from_gramps_id(
self.newplace.parent_ids[0])
if not parent and self.newplace.parent_names:
# make one, will have to be examined/cleaned later
parent = Place()
parent.title = ', '.join(self.newplace.parent_names)
name = PlaceName()
name.value = parent.title
parent.name = name
parent.gramps_id = self.newplace.parent_ids[0]
with DbTxn(_("Add Place (%s)") % parent.title,
self.dbstate.db) as trans:
self.dbstate.db.add_place(parent, trans)
next_place = True
if parent:
if located_in(self.dbstate.db, parent.handle,
self.place.handle):
# attempting to create a place loop, not good!
ErrorDialog(_('Place cycle detected'),
msg2=_("The place you chose is enclosed in the"
" place you are workin on!\n"
"Please cancel and choose another "
"place."),
parent=self.uistate.window)
return
# check to see if we already have the enclosing place
already_there = False
for pref in self.place.placeref_list:
if parent.handle == pref.ref:
already_there = True
break
if not already_there:
placeref = PlaceRef()
placeref.set_reference_handle(parent.handle)
self.place.set_placeref_list([placeref])
# Add in Citation/Source if wanted
if self.addcitation and self.newplace.geoid:
src_hndl = self.find_or_make_source()
cit = Citation()
cit.set_reference_handle(src_hndl)
cit.set_page("GeoNames ID: %s" %
self.newplace.geoid.replace('GEO', ''))
with DbTxn(_("Add Citation (%s)") % "GeoNames",
self.dbstate.db) as trans:
self.dbstate.db.add_citation(cit, trans)
self.place.add_citation(cit.handle)
# We're finally ready to commit the updated place
with DbTxn(_("Edit Place (%s)") % self.place.title,
self.dbstate.db) as trans:
self.dbstate.db.commit_place(self.place, trans)
# Jump to enclosing place to clean it if necessary
if next_place:
self.set_active('Place', parent.handle)
self.place = parent
# if geoparse fails, leave us at main view
if self.newplace.parent_ids and \
self.geoparse(self.newplace.parent_ids[0],
_(", ").join(self.newplace.parent_names),
self.newplace.parent_ids,
self.newplace.parent_names):
# geoparse worked, lets put up the results view
self.gui.get_child().remove(self.mainwin)
self.gui.get_child().add(self.results_win)
self.res_gui()
return
self.reset_main()
if self.gui.get_child().get_child() == self.results_win:
self.gui.get_child().remove(self.results_win)
self.gui.get_child().add(self.mainwin)
def exportData(database,
filename,
error_dialog=None,
option_box=None,
callback=None):
if not callable(callback):
callback = lambda percent: None # dummy
with OpenFileOrStdout(filename, encoding="utf-8") as fp:
total = (len(database.note_map) + len(database.person_map) +
len(database.event_map) + len(database.family_map) +
len(database.repository_map) + len(database.place_map) +
len(database.media_map) + len(database.citation_map) +
len(database.source_map) + len(database.tag_map))
count = 0.0
# ---------------------------------
# Notes
# ---------------------------------
for handle in database.note_map.keys():
serial = database.note_map[handle]
write_line(fp, Note.create(serial))
count += 1
callback(100 * count / total)
# ---------------------------------
# Event
# ---------------------------------
for handle in database.event_map.keys():
serial = database.event_map[handle]
write_line(fp, Event.create(serial))
count += 1
callback(100 * count / total)
# ---------------------------------
# Person
# ---------------------------------
for handle in database.person_map.keys():
serial = database.person_map[handle]
write_line(fp, Person.create(serial))
count += 1
callback(100 * count / total)
# ---------------------------------
# Family
# ---------------------------------
for handle in database.family_map.keys():
serial = database.family_map[handle]
write_line(fp, Family.create(serial))
count += 1
callback(100 * count / total)
# ---------------------------------
# Repository
# ---------------------------------
for handle in database.repository_map.keys():
serial = database.repository_map[handle]
write_line(fp, Repository.create(serial))
count += 1
callback(100 * count / total)
# ---------------------------------
# Place
# ---------------------------------
for handle in database.place_map.keys():
serial = database.place_map[handle]
write_line(fp, Place.create(serial))
count += 1
callback(100 * count / total)
# ---------------------------------
# Source
# ---------------------------------
for handle in database.source_map.keys():
serial = database.source_map[handle]
write_line(fp, Source.create(serial))
count += 1
callback(100 * count / total)
# ---------------------------------
# Citation
# ---------------------------------
for handle in database.citation_map.keys():
serial = database.citation_map[handle]
write_line(fp, Citation.create(serial))
count += 1
callback(100 * count / total)
# ---------------------------------
# Media
# ---------------------------------
for handle in database.media_map.keys():
serial = database.media_map[handle]
write_line(fp, MediaObject.create(serial))
count += 1
callback(100 * count / total)
# ---------------------------------
# Tag
# ---------------------------------
for handle in database.tag_map.keys():
serial = database.tag_map[handle]
write_line(fp, Tag.create(serial))
count += 1
callback(100 * count / total)
return True
def _process(self, count, total, sql):
# ---------------------------------
# Process note
# ---------------------------------
notes = sql.query("""select * from note;""")
for note in notes:
(handle, gid, text, _format, note_type1, note_type2, change,
private) = note
styled_text = [text, []]
markups = sql.query(
"""select * from link where from_handle = ? """
"""and to_type = 'markup';""", handle)
for markup_link in markups:
_from_type, _from_handle, _to_type, to_handle = markup_link
markup_detail = sql.query(
"""select * from markup where handle = ?;""", to_handle)
for markup in markup_detail:
(_mhandle, markup0, markup1, value,
start_stop_list) = markup
ss_list = eval(start_stop_list)
styled_text[1] += [((markup0, markup1), value, ss_list)]
tags = self.get_links(sql, "note", handle, "tag")
g_note = Note()
g_note.unserialize(
(handle, gid, styled_text, _format, (note_type1, note_type2),
change, tags, bool(private)))
self.db.add_note(g_note, self.trans)
count += 1
self.callback(100 * count / total)
# ---------------------------------
# Process event
# ---------------------------------
events = sql.query("""select * from event;""")
for event in events:
(handle, gid, the_type0, the_type1, description, change,
private) = event
note_list = self.get_note_list(sql, "event", handle)
citation_list = self.get_citation_list(sql, "event", handle)
media_list = self.get_media_list(sql, "event", handle)
attribute_list = self.get_attribute_list(sql, "event", handle)
date_handle = self.get_link(sql, "event", handle, "date")
date = self.get_date(sql, date_handle)
place_handle = self.get_link(sql, "event", handle, "place")
place = self.get_place_from_handle(sql, place_handle)
tags = self.get_links(sql, "event", handle, "tag")
data = (handle, gid, (the_type0, the_type1), date, description,
place, citation_list, note_list, media_list,
attribute_list, change, tags, bool(private))
g_event = Event()
g_event.unserialize(data)
self.db.add_event(g_event, self.trans)
count += 1
self.callback(100 * count / total)
# ---------------------------------
# Process person
# ---------------------------------
people = sql.query("""select * from person;""")
for person in people:
if person is None:
continue
(
handle, # 0
gid, # 1
gender, # 2
death_ref_handle, # 5
birth_ref_handle, # 6
change, # 17
private, # 19
) = person
primary_name = self.get_names(sql, "person", handle, True) # one
alternate_names = self.get_names(sql, "person", handle, False)
event_ref_list = self.get_event_ref_list(sql, "person", handle)
family_list = self.get_family_list(sql, "person", handle)
parent_family_list = self.get_parent_family_list(
sql, "person", handle)
media_list = self.get_media_list(sql, "person", handle)
address_list = self.get_address_list(sql,
"person",
handle,
with_parish=False)
attribute_list = self.get_attribute_list(sql, "person", handle)
urls = self.get_url_list(sql, "person", handle)
lds_ord_list = self.get_lds_list(sql, "person", handle)
pcitation_list = self.get_citation_list(sql, "person", handle)
pnote_list = self.get_note_list(sql, "person", handle)
person_ref_list = self.get_person_ref_list(sql, "person", handle)
death_ref_index = lookup(death_ref_handle, event_ref_list)
birth_ref_index = lookup(birth_ref_handle, event_ref_list)
tags = self.get_links(sql, "person", handle, "tag")
data = (
handle, # 0
gid, # 1
gender, # 2
primary_name, # 3
alternate_names, # 4
death_ref_index, # 5
birth_ref_index, # 6
event_ref_list, # 7
family_list, # 8
parent_family_list, # 9
media_list, # 10
address_list, # 11
attribute_list, # 12
urls, # 13
lds_ord_list, # 14
pcitation_list, # 15
pnote_list, # 16
change, # 17
tags,
bool(private), # 19
person_ref_list,
) # 20
g_pers = Person()
g_pers.unserialize(data)
self.db.add_person(g_pers, self.trans)
count += 1
self.callback(100 * count / total)
# ---------------------------------
# Process family
# ---------------------------------
families = sql.query("""select * from family;""")
for family in families:
(handle, gid, father_handle, mother_handle, the_type0, the_type1,
change, private) = family
child_ref_list = self.get_child_ref_list(sql, "family", handle)
event_ref_list = self.get_event_ref_list(sql, "family", handle)
media_list = self.get_media_list(sql, "family", handle)
attribute_list = self.get_attribute_list(sql, "family", handle)
lds_seal_list = self.get_lds_list(sql, "family", handle)
citation_list = self.get_citation_list(sql, "family", handle)
note_list = self.get_note_list(sql, "family", handle)
tags = self.get_links(sql, "family", handle, "tag")
data = (handle, gid, father_handle, mother_handle, child_ref_list,
(the_type0, the_type1), event_ref_list, media_list,
attribute_list, lds_seal_list, citation_list, note_list,
change, tags, private)
g_fam = Family()
g_fam.unserialize(data)
self.db.add_family(g_fam, self.trans)
count += 1
self.callback(100 * count / total)
# ---------------------------------
# Process repository
# ---------------------------------
repositories = sql.query("""select * from repository;""")
for repo in repositories:
(handle, gid, the_type0, the_type1, name, change, private) = repo
note_list = self.get_note_list(sql, "repository", handle)
address_list = self.get_address_list(sql,
"repository",
handle,
with_parish=False)
urls = self.get_url_list(sql, "repository", handle)
tags = self.get_links(sql, "repository", handle, "tag")
data = (handle, gid, (the_type0, the_type1), name, note_list,
address_list, urls, change, tags, private)
g_rep = Repository()
g_rep.unserialize(data)
self.db.add_repository(g_rep, self.trans)
count += 1
self.callback(100 * count / total)
# ---------------------------------
# Process place
# ---------------------------------
places = sql.query("""select * from place;""")
for place in places:
count += 1
(handle, gid, title, value, the_type0, the_type1, code, long, lat,
lang, change, private) = place
# We could look this up by "place_main", but we have the handle:
#main_loc = self.get_main_location(sql, handle, with_parish=True)
alt_loc_list = self.get_location_list(sql,
"place_alt",
handle,
with_parish=True)
urls = self.get_url_list(sql, "place", handle)
media_list = self.get_media_list(sql, "place", handle)
citation_list = self.get_citation_list(sql, "place", handle)
note_list = self.get_note_list(sql, "place", handle)
tags = self.get_links(sql, "place", handle, "tag")
place_type = (the_type0, the_type1)
alt_place_name_list = self.get_alt_place_name_list(sql, handle)
place_ref_list = self.get_place_ref_list(sql, handle)
data = (handle, gid, title, long, lat, place_ref_list,
PlaceName(value=value,
lang=lang).serialize(), alt_place_name_list,
place_type, code, alt_loc_list, urls, media_list,
citation_list, note_list, change, tags, private)
g_plac = Place()
g_plac.unserialize(data)
self.db.commit_place(g_plac, self.trans)
self.callback(100 * count / total)
# ---------------------------------
# Process citation
# ---------------------------------
citations = sql.query("""select * from citation;""")
for citation in citations:
(handle, gid, confidence, page, source_handle, change,
private) = citation
date_handle = self.get_link(sql, "citation", handle, "date")
date = self.get_date(sql, date_handle)
note_list = self.get_note_list(sql, "citation", handle)
media_list = self.get_media_list(sql, "citation", handle)
datamap = self.get_datamap_list(sql, "citation", handle)
tags = self.get_links(sql, "citation", handle, "tag")
data = (handle, gid, date, page, confidence, source_handle,
note_list, media_list, datamap, change, tags, private)
g_cit = Citation()
g_cit.unserialize(data)
self.db.commit_citation(g_cit, self.trans)
count += 1
self.callback(100 * count / total)
# ---------------------------------
# Process source
# ---------------------------------
sources = sql.query("""select * from source;""")
for source in sources:
(handle, gid, title, author, pubinfo, abbrev, change,
private) = source
note_list = self.get_note_list(sql, "source", handle)
media_list = self.get_media_list(sql, "source", handle)
datamap = self.get_datamap_list(sql, "source", handle)
reporef_list = self.get_repository_ref_list(sql, "source", handle)
tags = self.get_links(sql, "source", handle, "tag")
data = (handle, gid, title, author, pubinfo, note_list, media_list,
abbrev, change, datamap, reporef_list, tags, private)
g_src = Source()
g_src.unserialize(data)
self.db.commit_source(g_src, self.trans)
count += 1
self.callback(100 * count / total)
# ---------------------------------
# Process media
# ---------------------------------
media = sql.query("""select * from media;""")
for med in media:
(handle, gid, path, mime, desc, checksum, change, private) = med
attribute_list = self.get_attribute_list(sql, "media", handle)
citation_list = self.get_citation_list(sql, "media", handle)
note_list = self.get_note_list(sql, "media", handle)
date_handle = self.get_link(sql, "media", handle, "date")
date = self.get_date(sql, date_handle)
tags = self.get_links(sql, "media", handle, "tag")
data = (handle, gid, path, mime, desc, checksum, attribute_list,
citation_list, note_list, change, date, tags, private)
g_med = Media()
g_med.unserialize(data)
self.db.commit_media(g_med, self.trans)
count += 1
self.callback(100 * count / total)
# ---------------------------------
# Process tag
# ---------------------------------
tags = sql.query("""select * from tag;""")
for tag in tags:
(handle, name, color, priority, change) = tag
data = (handle, name, color, priority, change)
g_tag = Tag()
g_tag.unserialize(data)
self.db.commit_tag(g_tag, self.trans)
count += 1
self.callback(100 * count / total)
class CensusEditor(ManagedWindow):
"""
Census Editor.
"""
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 _add_tab(self, notebook, page):
notebook.append_page(page, page.get_tab_widget())
page.label.set_use_underline(True)
return page
def get_menu_title(self):
"""
Get the menu title.
"""
if self.event.get_handle():
date = get_date(self.event)
if not date:
date = 'unknown'
dialog_title = _('Census: %s') % date
else:
dialog_title = _('New Census')
return dialog_title
def build_menu_names(self, event):
"""
Build menu names. Overrides method in ManagedWindow.
"""
return (_('Edit Census'), self.get_menu_title())
def __create_gui(self):
"""
Create and display the GUI components of the editor.
"""
root = Gtk.Window(type=Gtk.WindowType.TOPLEVEL)
root.set_transient_for(self.uistate.window)
vbox = Gtk.VBox()
tab = Gtk.Table(4, 4, False)
tab.set_row_spacings(10)
tab.set_col_spacings(10)
census_label = Gtk.Label(_("Source:"))
census_label.set_alignment(0.0, 0.5)
tab.attach(census_label, 0, 1, 0, 1,
xoptions=Gtk.AttachOptions.FILL, xpadding=10)
liststore = Gtk.ListStore(str, str, str)
for row in get_census_sources(self.db):
liststore.append([row[0].decode(), row[1], row[2]])
census_combo = Gtk.ComboBox()
census_combo.set_model(liststore)
cell = Gtk.CellRendererText()
census_combo.pack_start(cell, True)
census_combo.add_attribute(cell, 'text', 1)
#cell = Gtk.CellRendererText()
#census_combo.pack_start(cell, True)
#census_combo.add_attribute(cell, 'text', 2)
census_combo.connect('changed', self.__census_changed)
self.widgets['census_combo'] = census_combo
hbox = Gtk.HBox()
hbox.pack_start(census_combo, False, True, 0)
tab.attach(hbox, 1, 2, 0, 1)
date_label = Gtk.Label(_("Date:"))
date_label.set_alignment(0.0, 0.5)
tab.attach(date_label, 0, 1, 1, 2,
xoptions=Gtk.AttachOptions.FILL, xpadding=10)
date_text = Gtk.Label()
date_text.set_alignment(0.0, 0.5)
tab.attach(date_text, 1, 2, 1, 2)
self.widgets['date_text'] = date_text
ref_label = Gtk.Label(_("Reference:"))
ref_label.set_alignment(0.0, 0.5)
tab.attach(ref_label, 0, 1, 2, 3,
xoptions=Gtk.AttachOptions.FILL, xpadding=10)
ref_entry = Gtk.Entry()
tab.attach(ref_entry, 1, 2, 2, 3)
self.widgets['ref_entry'] = ref_entry
place_label = Gtk.Label(_("Place:"))
place_label.set_alignment(0.0, 0.5)
tab.attach(place_label, 0, 1, 3, 4,
xoptions=Gtk.AttachOptions.FILL, xpadding=10)
place_text = Gtk.Label()
place_text.set_alignment(0.0, 0.5)
tab.attach(place_text, 1, 2, 3, 4)
self.widgets['place_text'] = place_text
image = Gtk.Image()
image.set_from_stock(Gtk.STOCK_INDEX, Gtk.IconSize.BUTTON)
place_share = Gtk.Button()
place_share.set_relief(Gtk.ReliefStyle.NONE)
place_share.add(image)
tab.attach(place_share, 2, 3, 3, 4, xoptions=0)
self.widgets['place_share'] = place_share
image = Gtk.Image()
image.set_from_stock(Gtk.STOCK_ADD, Gtk.IconSize.BUTTON)
place_add = Gtk.Button()
place_add.set_relief(Gtk.ReliefStyle.NONE)
place_add.add(image)
tab.attach(place_add, 3, 4, 3, 4, xoptions=0)
self.widgets['place_add'] = place_add
button_box = Gtk.HButtonBox()
button_box.set_layout(Gtk.ButtonBoxStyle.END)
help_btn = Gtk.Button(stock=Gtk.STOCK_HELP)
help_btn.connect('clicked', self.help_clicked)
button_box.add(help_btn)
button_box.set_child_secondary(help_btn, True)
cancel_btn = Gtk.Button(stock=Gtk.STOCK_CANCEL)
cancel_btn.connect('clicked', self.close)
button_box.add(cancel_btn)
ok_btn = Gtk.Button(stock=Gtk.STOCK_OK)
ok_btn.connect('clicked', self.save)
button_box.add(ok_btn)
notebook = Gtk.Notebook()
self.details = DetailsTab(self.dbstate,
self.uistate,
self.track,
self.event,
census_combo)
self._add_tab(notebook, self.details)
self.headings = HeadingsTab(self.dbstate,
self.uistate,
self.track,
self.event,
census_combo)
self._add_tab(notebook, self.headings)
self.gallery_list = GalleryTab(self.dbstate,
self.uistate,
self.track,
self.citation.get_media_list())
self._add_tab(notebook, self.gallery_list)
vbox.pack_start(tab, expand=False, fill=True, padding=10)
vbox.pack_start(notebook, expand=True, fill=True, padding=0)
vbox.pack_end(button_box, expand=False, fill=True, padding=10)
root.add(vbox)
root.show_all()
notebook.set_current_page(0)
return root
def __populate_gui(self, event):
"""
Populate the GUI for a given census event.
"""
census_combo = self.widgets['census_combo']
for pos, row in enumerate(census_combo.get_model()):
if row[0] == self.citation.get_reference_handle():
census_combo.set_active(pos)
date_text = self.widgets['date_text']
date_text.set_text(get_date(event))
def __census_changed(self, combo):
"""
Called when the user selects a new census from the combo box.
"""
model = combo.get_model()
index = combo.get_active()
census_id = model[index][2]
# Set date
census_date = get_census_date(census_id)
date_text = self.widgets['date_text']
date_text.set_text(displayer.display(census_date))
self.event.set_date_object(census_date)
self.citation.set_date_object(census_date)
# Set source
self.citation.set_reference_handle(model[index][0])
# Set new columns
columns = get_census_columns(census_id)
report_columns = get_report_columns(census_id)
self.details.create_table(columns, report_columns)
heading_list = get_census_headings(census_id)
self.headings.create_table(heading_list)
def save(self, button):
"""
Called when the user clicks the OK button.
"""
if self.widgets['census_combo'].get_active() == -1:
ErrorDialog(_('Census Editor'),
_('Cannot save this census. First select '
'a census from the drop-down list.'))
return
with DbTxn(self.get_menu_title(), self.db) as trans:
if not self.event.get_handle():
self.db.add_event(self.event, trans)
self.headings.save()
self.details.save(trans)
citation_handle = self.citation.get_handle()
if not citation_handle:
citation_handle = self.db.add_citation(self.citation, trans)
self.event.add_citation(citation_handle)
else:
self.db.commit_citation(self.citation, trans)
self.db.commit_event(self.event, trans)
self.close()
def close(self, *args):
"""
Close the editor window.
"""
(width, height) = self.window.get_size()
self._config.set('interface.census-width', width)
self._config.set('interface.census-height', height)
self._config.save()
self.details.entry_grid.clean_up()
self.details.clean_up()
self.gallery_list.clean_up()
ManagedWindow.close(self)
def help_clicked(self, obj):
"""
Display the relevant portion of GRAMPS manual
"""
display_help(webpage='Census_Addons')
def run(self):
objects = []
skipped = 0
total_objects = 0
total_notes = 0
matching_notes = 0
citations_added = 0
sources_added = 0
repos_added = 0
with self.user.progress(_("Generating citations"), '',
self.db.get_total()) as step:
repos = self.get_repos()
sources = self.get_sources()
notes_to_remove = {}
for classname, obj in self.yield_objects(step):
total_objects += 1
obj.classname = classname
obj.notes = []
obj.citations = []
current_citations = None
for note, m, notehandle in self.find_matching_notes(obj):
matching_notes += 1
# get a list of current citations; this is in the loop to avoid computing the set for all objects
if current_citations is None:
current_citations = set()
for type, h in obj.get_referenced_citation_handles(
): # type = 'Citation'
citation = self.db.get_citation_from_handle(h)
page = citation.get_page()
current_citations.add(
(page, citation.source_handle))
source = sources[m.sourcetitle]
source.set_title(m.sourcetitle)
if (m.citationpage, source.handle) in current_citations:
skipped += 1
continue # already has this citation, skip
repo = repos[m.reponame]
repo.set_name(m.reponame)
source.repo = repo
citation = Citation()
citation.set_page(m.citationpage)
citation.source = source
citation.note = m.details
obj.citations.append(citation)
obj.notes.append(notehandle)
notelines = note.get().splitlines()
if len(notelines) == 1:
notes_to_remove[notehandle] = m
if obj.notes: objects.append(obj)
with DbTxn(_("Add citations"), self.db) as trans:
for obj in objects:
self.log("Object {}".format(obj))
for citation in obj.citations:
source = citation.source
repo = source.repo
citation_handle = self.db.add_citation(citation, trans)
source_handle = self.db.add_source(source, trans)
repo_handle = self.db.add_repository(repo, trans)
self.log("- Adding citation: {}".format(
citation.get_page()))
if not hasattr(repo, "in_db"):
repos_added += 1
self.log("- Adding repo: {}".format(
repo.get_name()))
repo.in_db = True
if not hasattr(source, "in_db"):
sources_added += 1
self.log("- Adding source: {}".format(
source.get_title()))
source.in_db = True
note = Note()
note.set(citation.note)
note.set_type(NoteType.LINK)
note_handle = self.db.add_note(note, trans)
citation.add_note(note_handle)
citation.newnote = note
citation.set_reference_handle(source_handle)
if not source.has_repo_reference(repo_handle):
reporef = RepoRef()
reporef.set_reference_handle(repo_handle)
source.add_repo_reference(reporef)
obj.add_citation(citation_handle)
citations_added += 1
for notehandle in obj.notes:
if notehandle in notes_to_remove:
obj.remove_note(notehandle)
commit_func = self.primary_objects[
obj.primary_object_class]['commit_func']
commit_func(obj.primary_object, trans)
for citation in obj.citations:
self.db.commit_citation(citation, trans)
self.db.commit_source(citation.source, trans)
self.db.commit_repository(source.repo, trans)
self.db.commit_note(citation.newnote, trans)
for notehandle, m in notes_to_remove.items():
self.log("Removing note: {} {}".format(
repr(notehandle), m.line))
self.db.remove_note(notehandle, trans)
log = []
log.append(
_("Total objects processed: {total_objects}").format(
total_objects=total_objects))
log.append("- " + _("Total notes: {total_notes}").format(
total_notes=self.total_notes))
log.append("- " + _("Matching notes: {matching_notes}").format(
matching_notes=matching_notes))
log.append("- " +
_("Unique matching notes: {unique_matching_notes}"
).format(unique_matching_notes=len(notes_to_remove)))
log.append("- " +
_("Skipped notes: {skipped}").format(skipped=skipped))
log.append("- " + _("Citations added: {citations_added}").format(
citations_added=citations_added))
log.append("- " + _("Sources added: {sources_added}").format(
sources_added=sources_added))
log.append("- " + _("Repositories added: {repos_added}").format(
repos_added=repos_added))
msg = "\n".join(log)
msg += "\n\n" + _("You can undo all changes with Ctrl-Z.")
self.log(msg)
OkDialog(_("All events processed"),
msg,
parent=self.uistate.window)