diff --git a/gramps/plugins/rel/rel_uk.py b/gramps/plugins/rel/rel_uk.py new file mode 100644 index 000000000..586d7398f --- /dev/null +++ b/gramps/plugins/rel/rel_uk.py @@ -0,0 +1,908 @@ +# -*- coding: utf-8 -*- +# +# Gramps - a GTK+/GNOME based genealogy program +# +# Copyright (C) 2003-2005 Donald N. Allingham +# Copyright (C) 2008 Brian G. Matherly +# Copyright (C) 2013 Oleh Petriv +# Copyright (C) 2013 Fedir Zinchuk +# +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program; if not, write to the Free Software +# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +# +# UA: Пояснення щодо родинних відносин див. relationship.py +# EN: Ukrainian relationship calculator. For more information see relationship.py + +""" +Ukrainian-specific definitions of relationships +""" +from __future__ import unicode_literals +#------------------------------------------------------------------------- +# +# GRAMPS modules +# +#------------------------------------------------------------------------- + +from gramps.gen.lib import Person +import gramps.gen.relationship + +#------------------------------------------------------------------------- + + +# Relationship levels + +_level_name = [ + "", + "рідний(-на)", "двоюрідний(-на)", "троюрідний(-на)", + "чотириюрідний(-на)", "п'ятиюрідний(-на)", "шестиюрідний(-на)", + "семиюрідний(-на)", "восьмиюрідний(-на)", "дев'ятиюрідний(-на)", + "десятиюрідний(-на)", "одинадцятиюрідний(-на)", + "дванадцятиюрідний(-на)", "тринадцятиюрідний(-на)", + "чотирнадцятиюрідний(-на)", "п'ятнадцятиюрідний(-на)", + "шістнадцятиюрідний(-на)", "сімнадцятиюрідний(-на)", + "вісімнадцятиюрідний(-на)", "дев'ятнадцятиюрідний(-на)", + "двадцятиюрідний(-на)" +] +_level_name_male = [ + "", + "рідний", "двоюрідний", "троюрідний", + "чотириюрідний", "п'ятиюрідний", "шестиюрідний", + "семиюрідний", "восьмиюрідний", "дев'ятиюрідний", + "десятиюрідний", "одинадцятиюрідний", "дванадцятиюрідний", + "тринадцятиюрідний", "чотирнадцятиюрідний", "п'ятнадцятиюрідний", + "шістнадцятиюрідний", "сімнадцятиюрідний", "вісімнадцятиюрідний", + "дев'ятнадцятиюрідний", "двадцятиюрідний" +] +_level_name_female = [ + "", + "рідна", "двоюрідна", "троюрідна", + "чотириюріднa", "п'ятиюрідна", "шестиюрідна", + "семиюрідна", "восьмиюрідна", "дев'ятиюрідна", + "десятиюрідна", "одинадцятиюрідна", "дванадцятиюрідна", + "тринадцятиюрідна", "чотирнадцятиюрідна", "п'ятнадцятиюрідна", + "шістнадцятиюрідна", "сімнадцятиюрідна", "вісімнадцятиюрідна", + "дев'ятнадцятиюрідна", "двадцятиюрідна" +] + +_son_level = [ + "", + "син", + "внук", + "правнук", + "праправнук", +] + +_daughter_level = [ + "", + "дочка", + "онука", + "правнучка", + "праправнучка", +] + +_father_level = [ + "", + "батько", + "дід", + "прадід", + "прапрадід", +] + +_mother_level = [ + "", + "мати", + "баба", + "прабаба", + "прапрабаба", +] + +_uncle_level = [ + "", + "брат", # not used, just for keep count + "дядько", + "дід", + "прадід", + "прапрадід", +] + +_aunt_level = [ + "", + "сестра", # not used, just for keep count + "тітка", + "баба", + "прабаба", + "прапрабаба", +] + + +#------------------------------------------------------------------------- +# +# +# +#------------------------------------------------------------------------- + +class RelationshipCalculator(gramps.gen.relationship.RelationshipCalculator): + """ + RelationshipCalculator Class + """ + + def __init__(self): + gramps.gen.relationship.RelationshipCalculator.__init__(self) + + def get_sword_distaff(self, level, reltocommon, gender = gen.lib.Person.UNKNOWN): + """ + Generate relationships 'by male line' or 'by female line', + specific for Ukraine + """ + if level <= 1: + return "" + + # test the relation line + by_line = '' + for g in reltocommon: + if(by_line and by_line != g): + by_line = '' + break + by_line = g + + if by_line == self.REL_FATHER and gender == gen.lib.Person.MALE: + # by male line + return " по чоловічій лінії" + elif by_line == self.REL_MOTHER and gender == gen.lib.Person.FEMALE: + # by male line + return " по жіночій лінії" + elif reltocommon[0] == self.REL_FATHER: + # From father's side + return " по батькові" + elif reltocommon[0] == self.REL_MOTHER: + # From mother's side + return " по матері" + else: + return "" + + + def get_son(self, level, inlaw=''): + """ + Provides information how much male descendant is related to this person + """ + # Define if the person is natural relative or in law + if inlaw == '': + t_inlaw = "" + else: + t_inlaw = "названий " + + if level >= 0 and level < len(_son_level): + return t_inlaw +_son_level[level] + else: + return t_inlaw + "пра(пра)внук у %d поколінні" % (level + 1) + + + + def get_daughter(self, level, inlaw=''): + """ + Provides information how much female descendant is related to this person + """ + # Define if the person is natural relative or in law + if inlaw == '': + t_inlaw = "" + else: + t_inlaw = "названа " + + if level >= 0 and level < len(_daughter_level): + return t_inlaw + _daughter_level[level] + else: + return t_inlaw + "пра(пра)внучка у %d поколінні" % (level + 1) + + + def get_child_unknown(self, level, inlaw=''): + """ + Provides information how much descendant of unknown gender is related to this person + """ + # Define if the person is natural relative or in law + if inlaw == '': + t_inlaw = "" + else: + t_inlaw = "названий(на) " + + if level == 1: + return t_inlaw + "внук(а)" + else: + return t_inlaw + "пра(пра)внук(а) у %d поколінні" % (level + 1) + + + def get_father(self, level, reltocommon, inlaw=''): + """ + Provides information how much male ancestor (for example father) + is related to the given person + """ + if inlaw == '': + t_inlaw = "" + else: + t_inlaw = "названий " + + if level >= 0 and level < len(_father_level): + # If you know exact name of relationship - use it + if level == 1: + # Father + return t_inlaw + _father_level[level] + else: + # Grandfather, Greatgrandfather, Greatgreatgrandfather + return t_inlaw + _father_level[level] \ + + self.get_sword_distaff(level, reltocommon, gen.lib.Person.MALE) + else: + # For deep generations + return t_inlaw + "пра(пра)дід у %d поколінні" % (level + 1) \ + + self.get_sword_distaff(level, reltocommon, gen.lib.Person.MALE) + + + def get_mother(self, level, reltocommon, inlaw=''): + """ + Provides information how much female ancestor (for example mother) + is related to the given person + """ + if inlaw == '': + t_inlaw = "" + else: + t_inlaw = "названа " + + if level >= 0 and level < len(_mother_level): + # If you know exact name of relationship - use it + if level == 1: + # Mother + return t_inlaw + _mother_level[level] + + else: + # Grandmother, Greatgrandmother, Greatgreatgrandmother + return t_inlaw + _mother_level[level] \ + + self.get_sword_distaff(level, reltocommon, gen.lib.Person.FEMALE) + else: + # For deep generations + return t_inlaw + "пра(пра)баба у %d поколінні" % (level + 1) \ + + self.get_sword_distaff(level, reltocommon, gen.lib.Person.FEMALE) + + + + def get_parent_unknown(self, level, reltocommon, inlaw=''): + """ + Provides information how much an ancestor of unknown gender + is related to the given person (unknown sex) + """ + if inlaw == '': + t_inlaw = "" + else: + t_inlaw = "названий " + + if level == 1: + return t_inlaw + "батько/мати" + else: + return t_inlaw + "пра(пра)- дід/баба у %d поколінні" % (level + 1) \ + + self.get_sword_distaff(level, reltocommon) + + + def get_uncle(self, level, reltocommon, inlaw = ''): + """ + Return ancle generation name + """ + + if reltocommon[0] == self.REL_FATHER: + # from Father + if level < len(_uncle_level): + if level == 2: + return _uncle_level[level] + " (стрийко)" + else: + return "двоюрідний " + _uncle_level[level] \ + + " по батькові" + else: + return "двоюрідний пра(пра)дід в %d поколінні по батькові" % (level) + elif reltocommon[0] == self.REL_MOTHER: + # from Mother + if level < len(_uncle_level): + if level == 2: + return _uncle_level[level] + " (вуйко)" + else: + return "двоюрідний " + _uncle_level[level] \ + + " по матері" + else: + return "двоюрідний пра(пра)дід в %d поколінні по матері" % (level) + else: + if level == 2: + return "дядько (стрийко/вуйко)" + else: + return "двоюрідний пра(пра)дід в %d поколінні" % (level) + + + def get_aunt(self, level, reltocommon, inlaw = ''): + """ + Return aunt generation name + """ + + if reltocommon[0] == self.REL_FATHER: + # from Father + if level < len(_aunt_level): + if level == 2: + return _aunt_level[level] + " (стрийна)" + else: + return "двоюрідна " + _aunt_level[level] \ + + " по батькові" + else: + return "двоюрідна пра(пра)баба в %d поколінні по батькові" \ + % (level) + elif reltocommon[0] == self.REL_MOTHER: + # from Mother + if level < len(_aunt_level): + if level == 2: + return _aunt_level[level] + " (вуйна)" + else: + return "двоюрідна " + _aunt_level[level] \ + + " по матері" + else: + return "двоюрідна пра(пра)баба в %d поколінні по матері" \ + % (level) + else: + if level == 2: + return "тітка (стрийна/вуйна)" + else: + return "двоюрідна пра(пра)баба в %d поколінні" % (level) + + + def get_uncle_aunt_unknown(self, level, reltocommon, inlaw = ''): + """ + Return uncle/aunt generation name when gender unknown + """ + + if reltocommon[0] == self.REL_FATHER: + # from Father + if level == 2: + return "дядько/тітка (стрийко)" + else: + return "двоюрідний дід/баба в %d поколінні по батькові" \ + % (level) + elif reltocommon[0] == self.REL_MOTHER: + # from Mother + if level == 2: + return "дядько/тітка (вуйко)" + else: + return "двоюрідний дід/баба в %d поколінні по матері" \ + % (level) + else: + if level == 2: + return "дядько/тітка" + else: + return "двоюрідний дід/баба в %d поколінні" % (level) + + + def get_nephew(self, level, reltocommon, inlaw = ''): + """ + Return nephew generation name + """ + if inlaw == '': + t_inlaw = "" + else: + t_inlaw = "названий " + + if level == 2: + if reltocommon[0] == self.REL_FATHER : + # Brother's son + return t_inlaw + "небіж (братанець)" + elif reltocommon[0] == self.REL_MOTHER : + # Sister's son + return t_inlaw + "небіж (сестринець)" + else: + return t_inlaw + "небіж (братанець/сестринець)" + elif level >= 2 and level <=6: + if reltocommon[level-2] == self.REL_FATHER : + # Brother's son generation + if reltocommon[level-3] == self.REL_FATHER : + # Son of brother son + return self.get_son((level - 2), inlaw) \ + + " небожа по брату" + elif reltocommon[level-3] == self.REL_MOTHER : + # Son of brother daughter + return self.get_son((level - 2), inlaw) \ + + " небоги по брату" + else: + return self.get_son((level - 2), inlaw) \ + + " небожа/небоги по брату" + elif reltocommon[level-2] == self.REL_MOTHER : + # Sister's son generation + if reltocommon[level-3] == self.REL_FATHER : + # Son of sister son + return self.get_son((level - 2), inlaw) \ + + " небожа по сестрі" + elif reltocommon[level-3] == self.REL_MOTHER : + # Son of sister daughter + return self.get_son((level - 2), inlaw) \ + + " небоги по сестрі" + else: + return self.get_son((level - 2), inlaw) \ + + " небожа/небоги по сестрі" + else: + return self.get_son((level - 2), inlaw) + " небожа/небоги" + else: + if reltocommon[level-2] == self.REL_FATHER : + # Brother's son generation + return t_inlaw + "чоловічий нащадок у %d поколінні брата" \ + % (level) + elif reltocommon[level-2] == self.REL_MOTHER : + # Sister's son generation + return t_inlaw + "чоловічий нащадок у %d поколінні сестри" \ + % (level) + else: + return t_inlaw + "чоловічий нащадок у %d поколінні брата/сестри" \ + % (level) + + + + def get_niece(self, level, reltocommon, inlaw = ''): + """ + Return niece generation name + """ + if inlaw == '': + t_inlaw = "" + else: + t_inlaw = "названий " + + if level == 2: + if reltocommon[0] == self.REL_FATHER : + # Brother's daughter + return t_inlaw + "небога (братанка)" + elif reltocommon[0] == self.REL_MOTHER : + # Sister's daughter + return t_inlaw + "небога (сестрениця)" + else: + return t_inlaw + "небога (братанка/сестрениця)" + elif level >= 2 and level <=6: + if reltocommon[level-2] == self.REL_FATHER : + # Brother's daughter generation + if reltocommon[level-3] == self.REL_FATHER : + # daughter of brother son + return self.get_daughter((level - 2), inlaw) \ + + " небожа по брату" + elif reltocommon[level-3] == self.REL_MOTHER : + # daughter of brother daughter + return self.get_daughter((level - 2), inlaw) \ + + " небоги по брату" + else: + return self.get_daughter((level - 2), inlaw) \ + + " небожа/небоги по брату" + elif reltocommon[level-2] == self.REL_MOTHER : + # Sister's daughter generation + if reltocommon[level-3] == self.REL_FATHER : + # daughter of sister son + return self.get_daughter((level - 2), inlaw) \ + + " небожа по сестрі" + elif reltocommon[level-3] == self.REL_MOTHER : + # daughter of sister daughter + return self.get_daughter((level - 2), inlaw) \ + + " небоги по сестрі" + else: + return self.get_daughter((level - 2), inlaw) \ + + " небожа/небоги по сестрі" + else: + return self.get_daughter(level, inlaw) + " небожа/небоги" + else: + if reltocommon[level-2] == self.REL_FATHER : + # Brother's daughter generation + return t_inlaw + "жіночий нащадок у %d поколінні брата" \ + % (level) + elif reltocommon[level-2] == self.REL_MOTHER : + # Sister's daughter generation + return t_inlaw + "жіночий нащадок у %d поколінні сестри" \ + % (level) + else: + return t_inlaw + "жіночий нащадок у %d поколінні брата/сестри" \ + % (level) + + + def get_nephew_niece_unknown (self, level, reltocommon, inlaw = ''): + """ + Return nephew/niece generation name when gender unknown + """ + if inlaw == '': + t_inlaw = "" + else: + t_inlaw = "названий " + + if reltocommon[level-2] == self.REL_FATHER: + # Brother's descendant + return t_inlaw + "нащадок в %d поколінні брата" % (level) + elif (reltocommon[level-2] == self.REL_MOTHER): + # Sister's descendant + return t_inlaw + "нащадок в %d поколінні сестри" % (level) + else : + return t_inlaw + "нащадок в %d поколінні брата aбо сестри" \ + % (level) + + + def get_level(self, level, gender): + """ + Return level name depend of gender + """ + if (gender == gen.lib.Person.MALE): + if level < len(_level_name_male): + return _level_name_male[level] + else: + return "%d-юрідний" % level + elif (gender == gen.lib.Person.FEMALE): + if level < len(_level_name_female): + return _level_name_female[level] + else: + return "%d-юрідна" % level + else: + if level < len(_level_name): + return _level_name[level] + else: + return "%d-юрідний(на)" % level + + + + + def get_single_relationship_string(self, Ga, Gb, gender_a, gender_b, + reltocommon_a, reltocommon_b, + only_birth=True, + in_law_a=False, in_law_b=False): + """ + Provide a string that describes the relationsip between a person, and + another person. E.g. "grandparent" or "child". + + Ga: The number of generations between the main person and the + common ancestor. (кількість поколінь між прямими родичами особи: + сини, батьки, бабусі...) + + Gb: The number of generations between the other person and the + common ancestor. (кількість поколінь між іншою особою + і спільним предком) + + gender_a : gender of person a + + gender_b : gender of person b + + reltocommon_a : relation path to common ancestor or common + Family for person a. + Note that length = Ga + reltocommon_b : relation path to common ancestor or common + Family for person b. + Note that length = Gb + + in_law_a : True if path to common ancestors is via the partner + of person a + + in_law_b : True if path to common ancestors is via the partner + of person b + + only_birth : True if relation between a and b is by birth only + False otherwise + + more see in relationship.py get_single_relationship_string() + """ + + if only_birth: + step = '' + else: + step = self.STEP + + if in_law_a or in_law_b : + inlaw = self.INLAW + else: + inlaw = '' + + t_inlaw = "" + + # b is the same person as a + if Ga == Gb == 0: + rel_str = 'та сама особа' + + elif Ga == 0: + # b is son/descendant of a + + if gender_b == gen.lib.Person.MALE: + if inlaw and Gb == 1 and not step: + rel_str = "зять" + else: + rel_str = self.get_son(Gb, inlaw) + + elif gender_b == gen.lib.Person.FEMALE: + if inlaw and Gb == 1 and not step: + rel_str = "невістка" + else: + rel_str = self.get_daughter(Gb, inlaw) + + else: + rel_str = self.get_child_unknown(Gb, inlaw) + + + elif Gb == 0: + # b is parent/grand parent of a + + if gender_b == gen.lib.Person.MALE: + if inlaw and Gb == 1 and not step: + rel_str = "тесть" + else: + rel_str = self.get_father(Ga, reltocommon_a, inlaw) + + elif gender_b == gen.lib.Person.FEMALE: + if inlaw and Gb == 1 and not step: + rel_str = "теща" + else: + rel_str = self.get_mother(Ga, reltocommon_a, inlaw) + + else: + rel_str = self.get_parent_unknown(Ga, reltocommon_a, inlaw) + + + elif Ga == Gb == 1: + # Family, brother/sister + # not used, leave it just in case + # because should be handled + # by get_sibling_relationship_string + # that called in parent RelationshipCalculator + # see Relationship.py + + if gender_b == gen.lib.Person.MALE: + if inlaw and not step: + rel_str = "рідний брат" + else: + rel_str = "напів рідний брат" + + elif gender_b == gen.lib.Person.FEMALE: + if inlaw and not step: + rel_str = "рідна сестра" + else: + rel_str = "напів рідна сестра" + else: + rel_str = "брат/сестра" + + elif Gb == 1 and Ga > 1: + # b is aunt/uncle of a + + if (gender_b == gen.lib.Person.MALE): + rel_str = self.get_uncle(Ga, reltocommon_a, inlaw) + elif (gender_b == gen.lib.Person.FEMALE): + rel_str = self.get_aunt(Ga, reltocommon_a, inlaw) + else: + rel_str = self.get_uncle_aunt_unknown(Ga, reltocommon_a, inlaw) + + elif Ga == 1 and Gb > 1: + # b is niece/nephew of a + + if (gender_b == gen.lib.Person.MALE): + rel_str = self.get_nephew(Gb, reltocommon_b, inlaw) + elif (gender_b == gen.lib.Person.FEMALE): + rel_str = self.get_niece(Gb, reltocommon_b, inlaw) + else: + rel_str = self.get_nephew_niece_unknown(Gb, reltocommon_b, inlaw) + + + elif Ga > 1 and Gb > 1: + # b is (cousin/far aunt/far uncle/far niece/far nephew) of a + + if Ga > Gb: + # b is far aunt/far uncle of a + level = Ga - Gb + 1 + if level >= 3:#it is right or??? + level_name = self.get_level(Gb + 1, gender_b) + else: + level_name = self.get_level(Gb, gender_b) + + + if (gender_b == gen.lib.Person.MALE): + # b is far uncle + if inlaw != '': + t_inlaw = "названий " + if level < len(_uncle_level): + rel_str = t_inlaw + "%s %s" \ + % (level_name, _uncle_level[level]) + else: + rel_str = t_inlaw + "%s пра(пра)дід в %d поколінні" \ + % (level_name, (level)) + elif (gender_b == gen.lib.Person.FEMALE): + # b is far aunt + if inlaw != '': + t_inlaw = "названа " + if level < len(_aunt_level): + rel_str = t_inlaw + "%s %s" \ + % (level_name, _aunt_level[level]) + else: + rel_str = t_inlaw + "%s пра(пра)баба в %d поколінні" \ + % (level_name, (level)) + else: + if inlaw != '': + t_inlaw = "названий(на) " + if level == 2: + rel_str = t_inlaw + "%s дядько/тітка" % level_name + else: + rel_str = t_inlaw + "%s пра(пра)- дід/баба в %d поколінні" \ + % (level_name, (level)) + + elif Ga < Gb: + # b is far niece/far nephew of a + level_name = self.get_level(Ga, gender_b) + level = Gb - Ga + 1 + + if (gender_b == gen.lib.Person.MALE): + # b is far nephew + if level == 2: + rel_str = "%s небіж" % level_name + else: + rel_str = "%s пра(пра)внук у %d поколінні" \ + % (level_name, level) + #rel_str = "%s %s" % (level_name, self.get_nephew(level, reltocommon_b, inlaw)) + elif (gender_b == gen.lib.Person.FEMALE): + # b is far niece + if level == 2: + rel_str = "%s небога" % level_name + else: + rel_str = "%s пра(пра)внучка у %d поколінні" \ + % (level_name, level) + #rel_str = "%s %s" % (level_name, self.get_niece(level, reltocommon_b, inlaw)) + else: + rel_str = "%s пра(пра)внук(а) у %d поколінні" % level + #rel_str = "%s %s" % (level_name, self.get_nephew_niece_unknown(level, reltocommon_b, inlaw)) + + else: #Gb == Ga + # b is cousin of a + level_name = self.get_level(Ga, gender_b) + + if (gender_b == gen.lib.Person.MALE): + if inlaw != '': + t_inlaw = "названий " + rel_str = t_inlaw + "%s брат" % level_name + elif (gender_b == gen.lib.Person.FEMALE): + if inlaw != '': + t_inlaw = "названа " + rel_str = t_inlaw + "%s сестра" % level_name + else: + if inlaw != '': + t_inlaw = "названий(на) " + rel_str = t_inlaw + "%s брат/сестра" % level_name + + else: + # A program should never goes there, but... + rel_str = "невизначений ступінь спорідненості" + + return rel_str + + def get_plural_relationship_string(self, Ga, Gb, + reltocommon_a='', reltocommon_b='', + only_birth=True, + in_law_a=False, in_law_b=False): + """ + Generate a text with information, how far away is a group of persons + from a main person + """ + + if Ga == Gb == 0: + return 'та сама особа' + if 0 == Ga: + # These are descendants + if 1 == Gb: + return 'діти' + if 2 == Gb: + return 'внуки' + if 3 == Gb: + return 'правнуки' + if 4 == Gb: + return 'праправнуки' + return 'прапрапра(n)внуки' + if 0 == Gb: + # These are parents/grand parents + if 1 == Ga: + return 'батьки' + if 2 == Ga: + return 'діди/баби' + if 3 == Ga: + return 'прадіди/прабаби' + if 4 == Ga: + return 'прапращури' + return 'прапрапра(n)щури' + if 1 == Ga == Gb: + return 'батьки' + if 1 == Gb and Ga > 1: + return 'дядьки (вуйки, стрийки) і тітки' + if 1 < Gb and 1 == Ga: + return 'небожі по братові і сестрі' + if 1 < Ga and 1 < Gb: + return 'дальня родина' + return 'відносини невідомі' + + + + def get_sibling_relationship_string(self, sib_type, gender_a, gender_b, + in_law_a=False, in_law_b=False): + + if in_law_a or in_law_b : + inlaw = self.INLAW + else: + inlaw = '' + + if sib_type == self.NORM_SIB: + if not inlaw: + if gender_b == gen.lib.Person.MALE: + rel_str = 'рідний брат' + elif gender_b == gen.lib.Person.FEMALE: + rel_str = 'рідна сестра' + else: + rel_str = 'рідний(а) брат або сестра' + else: + if gender_b == gen.lib.Person.MALE: + rel_str = "названий брат" + elif gender_b == gen.lib.Person.FEMALE: + rel_str = "названа сестра" + else: + rel_str = "названий(а) брат або сестра" + elif sib_type == self.UNKNOWN_SIB: + if not inlaw: + if gender_b == gen.lib.Person.MALE: + rel_str = 'брат' + elif gender_b == gen.lib.Person.FEMALE: + rel_str = 'сестра' + else: + rel_str = 'брат або сестра' + else: + if gender_b == gen.lib.Person.MALE: + rel_str = "швагро" + elif gender_b == gen.lib.Person.FEMALE: + rel_str = "братова" + else: + rel_str = "швагро або братова" + elif sib_type == self.HALF_SIB_FATHER: + if gender_b == gen.lib.Person.MALE: + rel_str = "єдинокровний(напіврідний) брат" + elif gender_b == gen.lib.Person.FEMALE: + rel_str = "єдинокровна(напіврідна) сестра" + else: + rel_str = "напіврідний(а) брат/сестра" + elif sib_type == self.HALF_SIB_MOTHER: + if gender_b == gen.lib.Person.MALE: + rel_str = "єдинокровний(напіврідний) брат" + elif gender_b == gen.lib.Person.FEMALE: + rel_str = "єдинокровна(напіврідна) сестра" + else: + rel_str = "напіврідний(а) брат/сестра" + elif sib_type == self.STEP_SIB: + if gender_b == gen.lib.Person.MALE: + rel_str = "зведений брат" + elif gender_b == gen.lib.Person.FEMALE: + rel_str = "зведена сестра" + else: + rel_str = "зведений брат або сестра" + else: + rel_str = "невизначена ступінь родинних відносин" + return rel_str + + +if __name__ == "__main__": + # Test function. Call it as follows from the command line (so as to find + # imported modules): + # export PYTHONPATH=/path/to/gramps/src + # python src/plugins/rel/rel_pl.py + + + """ + TRANSLATORS, copy this if statement at the bottom of your + rel_xx.py module, and test your work with: + python src/plugins/rel/rel_xx.py + """ + from gramps.gen.relationship import test + import signal + import sys + # If someone go out + def goodby(signal, frame): + print 'No more Drink!' + sys.exit(0) + signal.signal(signal.SIGINT, goodby) + # Run test + RC = RelationshipCalculator() + test(RC, True) + diff --git a/gramps/plugins/rel/relplugins.gpr.py b/gramps/plugins/rel/relplugins.gpr.py index 0ac99c782..c028a59ac 100644 --- a/gramps/plugins/rel/relplugins.gpr.py +++ b/gramps/plugins/rel/relplugins.gpr.py @@ -295,3 +295,19 @@ plg.relcalcclass = 'RelationshipCalculator' plg.lang_list = ["sv", "SV", "sv_SE", "swedish", "Swedish", "sv_SE.UTF8", "sv_SE@euro", "sv_SE.UTF8@euro", "svenska", "Svenska", "sv_SE.UTF-8", "sv_SE.utf-8", "sv_SE.utf8", "Swedish_Sweden"] +# uk +plg = newplugin() +plg.id = 'relcalc_uk' +plg.name = _("Ukrainian Relationship Calculator") +plg.description = _("Calculates relationships between people") +plg.version = '1.0' +plg.gramps_target_version = '4.1' +plg.status = STABLE +plg.fname = 'rel_uk.py' +plg.ptype = RELCALC +plg.relcalcclass = 'RelationshipCalculator' +plg.lang_list = ["uk", "UA", "uk_UA", "ukrainian", + "Ukrainian", "uk_UA.utf8", + "uk_UA.UTF8", "uk_UA.utf-8", "uk_UA.UTF-8", "uk_UA.iso88595", + "uk_UA.iso8859-5", "uk_UA.iso-8859-5", "koi8u", "uk_koi8u", + "uk_UA.koi8u","uk_UA.KOI8-U",]