class EditPlace(EditPrimary):
def __init__(self, dbstate, uistate, track, place, callback=None):
EditPrimary.__init__(self, dbstate, uistate, track, place,
dbstate.db.get_place_from_handle,
dbstate.db.get_place_from_gramps_id, callback)
def empty_object(self):
return gen.lib.Place()
def _local_init(self):
self.width_key = 'interface.place-width'
self.height_key = 'interface.place-height'
self.top = Glade()
self.set_window(self.top.toplevel, None,
self.get_menu_title())
tblmloc = self.top.get_object('table19')
notebook = self.top.get_object('notebook3')
#recreate start page as GrampsTab
notebook.remove_page(0)
self.mloc = MainLocTab(self.dbstate, self.uistate, self.track,
_('_Location'), tblmloc)
self.track_ref_for_deletion("mloc")
def get_menu_title(self):
if self.obj and self.obj.get_handle():
title = self.obj.get_title()
dialog_title = _('Place: %s') % title
else:
dialog_title = _('New Place')
return dialog_title
def _connect_signals(self):
self.define_ok_button(self.top.get_object('ok'), self.save)
self.define_cancel_button(self.top.get_object('cancel'))
self.define_help_button(self.top.get_object('help'))
def _connect_db_signals(self):
"""
Connect any signals that need to be connected.
Called by the init routine of the base class (_EditPrimary).
"""
self._add_db_signal('place-rebuild', self._do_close)
self._add_db_signal('place-delete', self.check_for_close)
def _setup_fields(self):
mloc = self.obj.get_main_location()
self.title = MonitoredEntry(self.top.get_object("place_title"),
self.obj.set_title, self.obj.get_title,
self.db.readonly)
self.street = MonitoredEntry(self.top.get_object("street"),
mloc.set_street, mloc.get_street,
self.db.readonly)
self.locality = MonitoredEntry(self.top.get_object("locality"),
mloc.set_locality, mloc.get_locality,
self.db.readonly)
self.city = MonitoredEntry(self.top.get_object("city"),
mloc.set_city, mloc.get_city,
self.db.readonly)
self.gid = MonitoredEntry(self.top.get_object("gid"),
self.obj.set_gramps_id,
self.obj.get_gramps_id, self.db.readonly)
self.privacy = PrivacyButton(self.top.get_object("private"), self.obj,
self.db.readonly)
self.parish = MonitoredEntry(self.top.get_object("parish"),
mloc.set_parish, mloc.get_parish,
self.db.readonly)
self.county = MonitoredEntry(self.top.get_object("county"),
mloc.set_county, mloc.get_county,
self.db.readonly)
self.state = MonitoredEntry(self.top.get_object("state"),
mloc.set_state, mloc.get_state,
self.db.readonly)
self.phone = MonitoredEntry(self.top.get_object("phone"),
mloc.set_phone, mloc.get_phone,
self.db.readonly)
self.postal = MonitoredEntry(self.top.get_object("postal"),
mloc.set_postal_code,
mloc.get_postal_code, self.db.readonly)
self.country = MonitoredEntry(self.top.get_object("country"),
mloc.set_country, mloc.get_country,
self.db.readonly)
self.longitude = MonitoredEntry(
self.top.get_object("lon_entry"),
self.obj.set_longitude, self.obj.get_longitude,
self.db.readonly)
self.longitude.connect("validate", self._validate_coordinate, "lon")
#force validation now with initial entry
self.top.get_object("lon_entry").validate(force=True)
self.latitude = MonitoredEntry(
self.top.get_object("lat_entry"),
self.obj.set_latitude, self.obj.get_latitude,
self.db.readonly)
self.latitude.connect("validate", self._validate_coordinate, "lat")
#force validation now with initial entry
self.top.get_object("lat_entry").validate(force=True)
def _validate_coordinate(self, widget, text, typedeg):
if (typedeg == 'lat') and not conv_lat_lon(text, "0", "ISO-D"):
return ValidationError(_(u"Invalid latitude (syntax: 18\u00b09'") +
_('48.21"S, -18.2412 or -18:9:48.21)'))
elif (typedeg == 'lon') and not conv_lat_lon("0", text, "ISO-D"):
return ValidationError(_(u"Invalid longitude (syntax: 18\u00b09'") +
_('48.21"E, -18.2412 or -18:9:48.21)'))
def build_menu_names(self, place):
return (_('Edit Place'), self.get_menu_title())
def _create_tabbed_pages(self):
"""
Create the notebook tabs and inserts them into the main
window.
"""
notebook = self.top.get_object('notebook3')
self._add_tab(notebook, self.mloc)
self.loc_list = LocationEmbedList(self.dbstate,
self.uistate,
self.track,
self.obj.alt_loc)
self._add_tab(notebook, self.loc_list)
self.track_ref_for_deletion("loc_list")
self.citation_list = CitationEmbedList(self.dbstate,
self.uistate,
self.track,
self.obj.get_citation_list(),
self.get_menu_title())
self._add_tab(notebook, self.citation_list)
self.track_ref_for_deletion("citation_list")
self.note_tab = NoteTab(self.dbstate,
self.uistate,
self.track,
self.obj.get_note_list(),
self.get_menu_title(),
notetype=gen.lib.NoteType.PLACE)
self._add_tab(notebook, self.note_tab)
self.track_ref_for_deletion("note_tab")
self.gallery_tab = GalleryTab(self.dbstate,
self.uistate,
self.track,
self.obj.get_media_list())
self._add_tab(notebook, self.gallery_tab)
self.track_ref_for_deletion("gallery_tab")
self.web_list = WebEmbedList(self.dbstate,
self.uistate,
self.track,
self.obj.get_url_list())
self._add_tab(notebook, self.web_list)
self.track_ref_for_deletion("web_list")
self.backref_list = PlaceBackRefList(self.dbstate,
self.uistate,
self.track,
self.db.find_backlink_handles(self.obj.handle))
self.backref_tab = self._add_tab(notebook, self.backref_list)
self.track_ref_for_deletion("backref_list")
self.track_ref_for_deletion("backref_tab")
self._setup_notebook_tabs(notebook)
def save(self, *obj):
self.ok_button.set_sensitive(False)
if self.object_is_empty():
ErrorDialog(_("Cannot save place"),
_("No data exists for this place. Please "
"enter data or cancel the edit."))
self.ok_button.set_sensitive(True)
return
(uses_dupe_id, id) = self._uses_duplicate_id()
if uses_dupe_id:
prim_object = self.get_from_gramps_id(id)
name = prim_object.get_title()
msg1 = _("Cannot save place. ID already exists.")
msg2 = _("You have attempted to use the existing Gramps ID with "
"value %(id)s. This value is already used by '"
"%(prim_object)s'. Please enter a different ID or leave "
"blank to get the next available ID value.") % {
'id' : id, 'prim_object' : name }
ErrorDialog(msg1, msg2)
self.ok_button.set_sensitive(True)
return
with DbTxn('', self.db) as trans:
if not self.obj.get_handle():
self.db.add_place(self.obj, trans)
msg = _("Add Place (%s)") % self.obj.get_title()
else:
if not self.obj.get_gramps_id():
self.obj.set_gramps_id(self.db.find_next_place_gramps_id())
self.db.commit_place(self.obj, trans)
msg = _("Edit Place (%s)") % self.obj.get_title()
trans.set_description(msg)
self.close()
if self.callback:
self.callback(self.obj)
class EditName(EditSecondary):
def __init__(self, dbstate, uistate, track, name, callback):
EditSecondary.__init__(self, dbstate, uistate, track, name, callback)
def _local_init(self):
self.width_key = 'interface.name-width'
self.height_key = 'interface.name-height'
self.top = Glade()
self.set_window(self.top.toplevel, None, _("Name Editor"))
tblgnam = self.top.get_object('table23')
notebook = self.top.get_object('notebook')
hbox_surn = self.top.get_object('hboxmultsurnames')
hbox_surn.set_size_request(
-1, int(config.get('interface.surname-box-height')))
hbox_surn.pack_start(
SurnameTab(self.dbstate,
self.uistate,
self.track,
self.obj,
top_label=None))
#recreate start page as GrampsTab
notebook.remove_page(0)
self.gennam = GeneralNameTab(self.dbstate, self.uistate, self.track,
_('_General'), tblgnam)
self.original_group_as = self.obj.get_group_as()
self.original_group_set = not (self.original_group_as == '')
srn = self.obj.get_primary_surname().get_surname()
self._get_global_grouping(srn)
self.group_over = self.top.get_object('group_over')
self.group_over.connect('toggled', self.on_group_over_toggled)
self.group_over.set_sensitive(not self.db.readonly)
self.toggle_dirty = False
def _post_init(self):
"""if there is override, set the override toggle active
"""
if self.original_group_set:
self.group_over.set_active(True)
else:
# The glade file correctly sets group_as widget editable=False.
# At this stage of initialization self.group_as.obj.get_editable()
# is however still true, correct that.
self.group_as.enable(False)
def _connect_signals(self):
self.define_cancel_button(self.top.get_object('button119'))
self.define_help_button(
self.top.get_object('button131'),
_('Gramps_3.4_Wiki_Manual_-_Entering_and_Editing_Data:_Detailed_-_part_3'
), _('manpage section id|Name_Editor'))
self.define_ok_button(self.top.get_object('button118'), self.save)
def _validate_call(self, widget, text):
""" a callname must be a part of the given name, see if this is the
case """
validcall = self.given_field.obj.get_text().split()
dummy = copy(validcall)
for item in dummy:
validcall += item.split('-')
if text in validcall:
return
return ValidationError(
_("Call name must be the given name that "
"is normally used."))
def _setup_fields(self):
self.group_as = MonitoredEntry(self.top.get_object("group_as"),
self.obj.set_group_as,
self.obj.get_group_as, self.db.readonly)
if not self.original_group_set:
if self.global_group_set:
self.group_as.force_value(self.global_group_as)
else:
self.group_as.force_value(
self.obj.get_primary_surname().get_surname())
format_list = [
(name, number)
for (number, name, fmt_str,
act) in name_displayer.get_name_format(also_default=True)
]
self.sort_as = MonitoredMenu(self.top.get_object('sort_as'),
self.obj.set_sort_as,
self.obj.get_sort_as, format_list,
self.db.readonly)
self.display_as = MonitoredMenu(self.top.get_object('display_as'),
self.obj.set_display_as,
self.obj.get_display_as, format_list,
self.db.readonly)
self.given_field = MonitoredEntry(self.top.get_object("given_name"),
self.obj.set_first_name,
self.obj.get_first_name,
self.db.readonly)
self.call_field = MonitoredEntry(self.top.get_object("call"),
self.obj.set_call_name,
self.obj.get_call_name,
self.db.readonly)
self.call_field.connect("validate", self._validate_call)
#force validation now with initial entry
self.call_field.obj.validate(force=True)
self.title_field = MonitoredEntry(self.top.get_object("title_field"),
self.obj.set_title,
self.obj.get_title, self.db.readonly)
self.suffix_field = MonitoredEntry(self.top.get_object("suffix"),
self.obj.set_suffix,
self.obj.get_suffix,
self.db.readonly)
self.nick = MonitoredEntry(self.top.get_object("nickname"),
self.obj.set_nick_name,
self.obj.get_nick_name, self.db.readonly)
self.famnick = MonitoredEntry(self.top.get_object("familynickname"),
self.obj.set_family_nick_name,
self.obj.get_family_nick_name,
self.db.readonly)
#self.surname_field = MonitoredEntry(
# self.top.get_object("alt_surname"),
# self.obj.set_surname,
# self.obj.get_surname,
# self.db.readonly,
# autolist=self.db.get_surname_list() if not self.db.readonly else [],
# changed=self.update_group_as)
self.date = MonitoredDate(self.top.get_object("date_entry"),
self.top.get_object("date_stat"),
self.obj.get_date_object(), self.uistate,
self.track, self.db.readonly)
self.obj_combo = MonitoredDataType(
self.top.get_object("ntype"),
self.obj.set_type,
self.obj.get_type,
self.db.readonly,
self.db.get_name_types(),
)
self.privacy = PrivacyButton(self.top.get_object("priv"), self.obj,
self.db.readonly)
def _create_tabbed_pages(self):
notebook = self.top.get_object("notebook")
self._add_tab(notebook, self.gennam)
self.track_ref_for_deletion("gennam")
self.srcref_list = CitationEmbedList(self.dbstate, self.uistate,
self.track,
self.obj.get_citation_list())
self._add_tab(notebook, self.srcref_list)
self.track_ref_for_deletion("srcref_list")
self.note_tab = NoteTab(self.dbstate,
self.uistate,
self.track,
self.obj.get_note_list(),
notetype=NoteType.PERSONNAME)
self._add_tab(notebook, self.note_tab)
self.track_ref_for_deletion("note_tab")
self._setup_notebook_tabs(notebook)
def _get_global_grouping(self, srn):
""" we need info on the global grouping of the surname on init,
and on change of surname
"""
self.global_group_as = self.db.get_name_group_mapping(srn)
if srn == self.global_group_as:
self.global_group_as = None
self.global_group_set = False
else:
self.global_group_set = True
def build_menu_names(self, name):
if name:
ntext = name_displayer.display_name(name)
submenu_label = '%s: %s' % (_('Name'), ntext)
else:
submenu_label = _('New Name')
menu_label = _('Name Editor')
return (menu_label, submenu_label)
def update_group_as(self, obj):
"""Callback if surname changes on GUI
If overwrite is not set, we change the group name too
"""
name = self.obj.get_primary_surname().get_surname()
if not self.group_over.get_active():
self.group_as.force_value(name)
#new surname, so perhaps now a different grouping?
self._get_global_grouping(name)
if not self.group_over.get_active() and self.global_group_set:
self.group_over.set_active(True)
self.group_as.enable(True)
self.toggle_dirty = True
self.group_as.force_value(self.global_group_as)
elif self.group_over.get_active() and self.toggle_dirty:
#changing surname caused active group_over in past, change
# group_over as we type
if self.global_group_set:
self.group_as.force_value(self.global_group_as)
else:
self.toggle_dirty = False
self.group_as.force_value(name)
self.group_over.set_active(False)
self.group_as.enable(False)
def on_group_over_toggled(self, obj):
""" group over changes, if activated, enable edit,
if unactivated, go back to surname/global_group_as.
"""
self.toggle_dirty = False
#enable group as box
self.group_as.enable(obj.get_active())
if not obj.get_active():
if self.global_group_set:
self.group_as.set_text(self.global_group_as)
else:
surname = self.obj.get_primary_surname().get_surname()
self.group_as.set_text(surname)
def save(self, *obj):
"""Save the name setting. All is ok, except grouping. We need to
consider:
1/ global set, not local set --> unset (ask if global unset)
2/ global set, local set --> unset (only local unset!)
3/ not global set, local set
or not global set, not local set --> unset
4/ not local set, not global set
or not local set, global set --> set val (ask global or local)
5/ local set, not global set --> set (change local)
6/ local set, global set --> set (set to global if possible)
"""
closeit = True
surname = self.obj.get_primary_surname().get_surname()
group_as = self.obj.get_group_as()
grouping_active = self.group_over.get_active()
if not grouping_active:
#user wants to group with surname
if self.global_group_set and not self.original_group_set:
#warn that group will revert to surname
from QuestionDialog import QuestionDialog2
q = QuestionDialog2(
_("Break global name grouping?"),
_("All people with the name of %(surname)s will no longer "
"be grouped with the name of %(group_name)s.") % {
'surname': surname,
'group_name': group_as
}, _("Continue"), _("Return to Name Editor"))
val = q.run()
if val:
#delete the grouping link on database
self.db.set_name_group_mapping(surname, None)
self.obj.set_group_as("")
else:
closeit = False
elif self.global_group_set and self.original_group_set:
#we change it only back to surname locally, so store group_as
# Note: if all surnames are locally changed to surname, we
# should actually unsed the global group here ....
pass
else:
#global group not set, don't set local group too:
self.obj.set_group_as("")
else:
#user wants to override surname, see what he wants
if not self.original_group_set:
#if changed, ask if this has to happen for the entire group,
#this might be creation of group link, or change of group link
if self.global_group_as != group_as:
from QuestionDialog import QuestionDialog2
q = QuestionDialog2(
_("Group all people with the same name?"),
_("You have the choice of grouping all people with the "
"name of %(surname)s with the name of %(group_name)s, or "
"just mapping this particular name.") % {
'surname': surname,
'group_name': group_as
}, _("Group all"), _("Group this name only"))
val = q.run()
if val:
if group_as == surname:
self.db.set_name_group_mapping(surname, None)
else:
self.db.set_name_group_mapping(surname, group_as)
self.obj.set_group_as("")
else:
if self.global_group_set:
#allow smith to Dummy, but one person still Smith
self.obj.set_group_as(group_as)
elif group_as == surname:
self.obj.set_group_as("")
else:
self.obj.set_group_as(group_as)
else:
#keep original value, no original group
self.obj.set_group_as("")
elif not self.global_group_set:
#don't ask user, group was set locally before,
#change it locally only
if group_as == surname:
#remove grouping
self.obj.set_group_as("")
else:
pass
else:
#locally set group and global group set
if group_as == self.global_group_as:
#unset local group, go with global one
self.obj.set_group_as("")
else:
#local set is different from global, keep it like that
pass
if closeit:
if self.callback:
self.callback(self.obj)
self.callback = None
self.close()
def _cleanup_on_exit(self):
"""
Somehow it was decided that a database value of group="" is represented
in the GUI by a widget with a group="surname" which is disabled. So if
the group_as widget is disabled then remove the group from the name
otherwise gramps thinks the name has changed resulting in asking if
data must be saved, and also bug 1892 occurs on reopening of the editor.
"""
# can't use group_over, see Note in gen/lib/name/Name.set_group_as().
if not self.group_as.obj.get_editable():
self.obj.set_group_as("")
EditSecondary._cleanup_on_exit(self)