From f01ae999c34ab9de1f792f4f1ba69b87750748f3 Mon Sep 17 00:00:00 2001 From: Benny Malengier Date: Tue, 9 Oct 2007 13:05:56 +0000 Subject: [PATCH] 2007-10-09 Benny Malengier * src/GrampsDb/_GrampsInMemDB.py: correctly store global name grouping * src/GrampsDb/_GrampsBSDDB.py: correctly store global name grouping * src/gen/lib/name.py: allow grouping equal to surname * src/Editors/_EditName.py: correct handling of name grouping, issue #647 svn: r9116 --- ChangeLog | 6 ++ src/Editors/_EditName.py | 177 +++++++++++++++++++++++++++------ src/GrampsDb/_GrampsBSDDB.py | 9 +- src/GrampsDb/_GrampsInMemDB.py | 2 +- src/gen/lib/name.py | 8 +- 5 files changed, 163 insertions(+), 39 deletions(-) diff --git a/ChangeLog b/ChangeLog index 482f465c6..7c7a883cb 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,9 @@ +2007-10-09 Benny Malengier + * src/GrampsDb/_GrampsInMemDB.py: correctly store global name grouping + * src/GrampsDb/_GrampsBSDDB.py: correctly store global name grouping + * src/RelLib/_Name.py: allow grouping equal to surname + * src/Editors/_EditName.py: correct handling of name grouping, issue #647 + 2007-10-08 Don Allingham * various: cleanup diff --git a/src/Editors/_EditName.py b/src/Editors/_EditName.py index f7f2b4113..deff1d84e 100644 --- a/src/Editors/_EditName.py +++ b/src/Editors/_EditName.py @@ -72,17 +72,24 @@ class EditName(EditSecondary): _("Name Editor")) self.original_group_as = self.obj.get_group_as() + self.original_group_set = not (self.original_group_as == '') + srn = self.obj.get_surname() + self._get_global_grouping(srn) + self.general_label = self.top.get_widget("general_tab") self.group_over = self.top.get_widget('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 Utils.bold_label(self.general_label) def _post_init(self): - if self.original_group_as and \ - (self.original_group_as != self.obj.get_surname()): + """if there is override, set the override toggle active + """ + if self.original_group_set or self.global_group_set : self.group_over.set_active(True) def _connect_signals(self): @@ -97,8 +104,11 @@ class EditName(EditSecondary): self.obj.get_group_as, self.db.readonly) - if not self.original_group_as: - self.group_as.force_value(self.obj.get_surname()) + 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_surname()) format_list = [(name,number) for (number,name,fmt_str,act) in name_displayer.get_name_format(also_default=True)] @@ -196,6 +206,18 @@ class EditName(EditSecondary): notetype=NoteType.PERSONNAME)) 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: @@ -207,48 +229,141 @@ class EditName(EditSecondary): 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_surname() if not self.group_over.get_active(): - if self.obj.get_group_as() != self.obj.get_surname(): - val = self.obj.get_group_as() + 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: - name = self.obj.get_surname() - val = self.db.get_name_group_mapping(name) - self.group_as.force_value(val) + 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. + """ + self.toggle_dirty = False + #enable group as box self.group_as.enable(obj.get_active()) if not obj.get_active(): - field_value = self.obj.get_surname() - mapping = self.db.get_name_group_mapping(field_value) - self.group_as.set_text(mapping) + surname = self.obj.get_surname() + self.group_as.set_text(surname) def save(self,*obj): - - if not self.group_over.get_active(): - self.obj.set_group_as("") - elif self.obj.get_group_as() == self.obj.get_surname(): - self.obj.set_group_as("") - elif self.obj.get_group_as() != self.original_group_as: - grp_as = self.obj.get_group_as() - srn = self.obj.get_surname() - if grp_as not in self.db.get_name_group_keys(): + """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_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' : srn, - 'group_name':grp_as}, + "just mapping this particular name." + ) % { 'surname' : surname, + 'group_name':group_as}, _("Group all"), _("Group this name only")) - val = q.run() - if val: - self.obj.set_group_as("") - self.db.set_name_group_mapping(srn,grp_as) + 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: - self.obj.set_group_as(grp_as) + #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 self.callback: - self.callback(self.obj) - self.close() + if closeit: + if self.callback: + self.callback(self.obj) + self.close() diff --git a/src/GrampsDb/_GrampsBSDDB.py b/src/GrampsDb/_GrampsBSDDB.py index 9cd4b5b1b..9112b3987 100644 --- a/src/GrampsDb/_GrampsBSDDB.py +++ b/src/GrampsDb/_GrampsBSDDB.py @@ -1257,6 +1257,9 @@ class GrampsBSDDB(GrampsDbBase, UpdateCallback): self.event_map.sync() def set_name_group_mapping(self, name, group): + """Make name group under the value of group. + If group =None, the old grouping is deleted + """ if not self.readonly: if self.UseTXN: # Start transaction if needed @@ -1265,10 +1268,10 @@ class GrampsBSDDB(GrampsDbBase, UpdateCallback): the_txn = None name = str(name) data = self.name_group.get(name, txn=the_txn) - if not group and data: + if data is not None: self.name_group.delete(name, txn=the_txn) - else: - self.name_group.put(name, group, txn=the_txn) + if group is not None: + self.name_group.put(name,group,txn=the_txn) if self.UseTXN: the_txn.commit() else: diff --git a/src/GrampsDb/_GrampsInMemDB.py b/src/GrampsDb/_GrampsInMemDB.py index a6ed0769b..85cce36fb 100644 --- a/src/GrampsDb/_GrampsInMemDB.py +++ b/src/GrampsDb/_GrampsInMemDB.py @@ -130,7 +130,7 @@ class GrampsInMemDB(GrampsDbBase): def set_name_group_mapping(self,name,group): if group == None and self.name_group.has_key(name): del self.name_group[name] - else: + if group is not None : self.name_group[name] = group def build_surname_list(self): diff --git a/src/gen/lib/name.py b/src/gen/lib/name.py index bd13ee5cf..229c01e64 100644 --- a/src/gen/lib/name.py +++ b/src/gen/lib/name.py @@ -176,11 +176,11 @@ class Name(SecondaryObject, PrivacyBase, SourceBase, NoteBase, DateBase): Sets the grouping name for a person. Normally, this is the person's surname. However, some locales group equivalent names (e.g. Ivanova and Ivanov in Russian are usually considered equivalent. + Note that there is also a database wide grouping set_name_group_mapping + So one might map a name Smith to SmithNew, and have one person still + grouped with name Smith. Hence, group_as can be equal to surname! """ - if name == self.surname: - self.group_as = "" - else: - self.group_as = name + self.group_as = name def get_group_as(self): """