Exemple #1
0
    def findChildren(self):
        # we need to start with all of our "people of interest"
        childrenNotYetProcessed = set(self._interest_set)
        childrenToInclude = set()

        # now we find all the children of our people of interest

        while len(childrenNotYetProcessed) > 0:
            handle = childrenNotYetProcessed.pop()

            if handle not in childrenToInclude:

                person = self._db.get_person_from_handle(handle)

                # if this is a private record, and we're not
                # including private records, then go back to the
                # top of the while loop to get the next person
                if person.private and not self._incprivate:
                    continue

                # remember this person!
                childrenToInclude.add(handle)

                # if we have a limit on the number of people, and we've
                # reached that limit, then don't attempt to find any
                # more children
                if self._limitchildren and (
                        self._maxchildren <
                    (len(childrenNotYetProcessed) + len(childrenToInclude))):
                    # get back to the top of the while loop so we can finish
                    # processing the people queued up in the "not yet processed" list
                    continue

                # iterate through this person's families
                for family_handle in person.get_family_handle_list():
                    family = self._db.get_family_from_handle(family_handle)
                    if (family.private
                            and self._incprivate) or not family.private:

                        # queue up any children from this person's family
                        for childRef in family.get_child_ref_list():
                            child = self._db.get_person_from_handle(
                                childRef.ref)
                            if (child.private
                                    and self._incprivate) or not child.private:
                                childrenNotYetProcessed.add(child.get_handle())
                                self._families.add(family_handle)

                        # include the spouse from this person's family
                        spouse_handle = ReportUtils.find_spouse(person, family)
                        if spouse_handle:
                            spouse = self._db.get_person_from_handle(
                                spouse_handle)
                            if (spouse.private and
                                    self._incprivate) or not spouse.private:
                                childrenToInclude.add(spouse_handle)
                                self._families.add(family_handle)

        # we now merge our temp set "childrenToInclude" into our master set
        self._people.update(childrenToInclude)
Exemple #2
0
    def __rec_fill_data(self, gen, person, pos):
        """
        Recursively fill in the data
        """
        totdesc = 0
        nrfam = len(person.get_family_handle_list())
        self.gen2people[gen][pos][6] = nrfam
        for family_handle in person.get_family_handle_list():
            totdescfam = 0
            family = self.dbstate.db.get_family_from_handle(family_handle)

            spouse_handle = find_spouse(person, family)
            if spouse_handle:
                spouse = self.dbstate.db.get_person_from_handle(spouse_handle)
                spname = name_displayer.display(spouse)
            else:
                spname = ''
                spouse = None
            if family_handle in self.famhandle2desc:
                #family occurs via father and via mother in the chart, only
                #first to show and count.
                famdup = True
            else:
                famdup = False
            # family, duplicate or not, start angle, slice size,
            #   text, spouse pos in gen, nrchildren, userdata, parnter, status
            self.gen2fam[gen].append(
                [family, famdup, 0, 0, spname, pos, 0, [], spouse, NORMAL])
            posfam = len(self.gen2fam[gen]) - 1

            if not famdup:
                nrchild = len(family.get_child_ref_list())
                self.gen2fam[gen][-1][6] = nrchild
                for child_ref in family.get_child_ref_list():
                    child = self.dbstate.db.get_person_from_handle(
                        child_ref.ref)
                    chname = name_displayer.display(child)
                    if child_ref.ref in self.handle2desc:
                        dup = True
                    else:
                        dup = False
                        self.handle2desc[child_ref.ref] = 0
                    # person, duplicate or not, start angle, slice size,
                    #         text, parent pos in fam, nrfam, userdata, status
                    self.gen2people[gen + 1].append(
                        [child, dup, 0, 0, chname, posfam, 0, [], NORMAL])
                    totdescfam += 1  #add this person as descendant
                    pospers = len(self.gen2people[gen + 1]) - 1
                    if not dup and not (self.generations == gen + 2):
                        nrdesc = self.__rec_fill_data(gen + 1, child, pospers)
                        self.handle2desc[child_ref.ref] += nrdesc
                        totdescfam += nrdesc  # add children of him as descendants
                self.famhandle2desc[family_handle] = totdescfam
            totdesc += totdescfam
        return totdesc
Exemple #3
0
    def recurse(self, level, person, curdepth):

        person_handle = person.get_handle()
        display_num = self.objPrint.print_person(level, person)

        if curdepth is None:
            ref_str = display_num
        else:
            ref_str = curdepth + " " + display_num

        if person_handle not in self.person_printed:
            self.person_printed[person_handle] = ref_str
            report_person_ref[person_handle] = (self.report_count, ref_str)

        for family_handle in person.get_family_handle_list():
            family = self.database.get_family_from_handle(family_handle)

            spouse_handle = ReportUtils.find_spouse(person, family)

            if not self.showdups and spouse_handle in self.person_printed:
                # Just print a reference
                spouse = self.database.get_person_from_handle(spouse_handle)
                self.objPrint.print_reference(
                    level, spouse, self.person_printed[person_handle])

            else:
                if not self.showdups and self.report_count > 1:
                    if spouse_handle in report_person_ref:
                        self.objPrint.print_spouse(level, spouse_handle,
                                                   family)
                        childlist = family.get_child_ref_list()[:]
                        if len(childlist) > 0:
                            spouse = \
                                self.database.get_person_from_handle(
                                                                spouse_handle)
                            self.objPrint.print_report_reference(
                                level + 1, person, spouse,
                                report_person_ref[spouse_handle])
                        return

                self.objPrint.print_spouse(level, spouse_handle, family)

                if spouse_handle:
                    spouse_num = _("%s sp." % (ref_str))
                    self.person_printed[spouse_handle] = spouse_num
                    report_person_ref[spouse_handle] = \
                        (self.report_count, spouse_num)

                if level >= self.max_generations:
                    continue

                childlist = family.get_child_ref_list()[:]
                for child_ref in childlist:
                    child = self.database.get_person_from_handle(child_ref.ref)
                    self.recurse(level + 1, child, ref_str)
Exemple #4
0
    def __rec_fill_data(self, gen, person, pos):
        """
        Recursively fill in the data
        """
        totdesc = 0
        nrfam = len(person.get_family_handle_list())
        self.gen2people[gen][pos][6] = nrfam
        for family_handle in person.get_family_handle_list():
            totdescfam = 0
            family = self.dbstate.db.get_family_from_handle(family_handle)

            spouse_handle = find_spouse(person, family)
            if spouse_handle:
                spouse = self.dbstate.db.get_person_from_handle(spouse_handle)
                spname = name_displayer.display(spouse)
            else:
                spname = ''
                spouse = None
            if family_handle in self.famhandle2desc:
                #family occurs via father and via mother in the chart, only
                #first to show and count.
                famdup = True
            else:
                famdup = False
            # family, duplicate or not, start angle, slice size, 
            #   text, spouse pos in gen, nrchildren, userdata, parnter, status
            self.gen2fam[gen].append([family, famdup, 0, 0, spname, pos, 0, [],
                                      spouse, NORMAL])
            posfam = len(self.gen2fam[gen]) - 1

            if not famdup:
                nrchild = len(family.get_child_ref_list())
                self.gen2fam[gen][-1][6] = nrchild
                for child_ref in family.get_child_ref_list():
                    child = self.dbstate.db.get_person_from_handle(child_ref.ref)
                    chname = name_displayer.display(child)
                    if child_ref.ref in self.handle2desc:
                        dup = True
                    else:
                        dup = False
                        self.handle2desc[child_ref.ref] = 0
                    # person, duplicate or not, start angle, slice size,
                    #         text, parent pos in fam, nrfam, userdata, status
                    self.gen2people[gen+1].append([child, dup, 0, 0, chname, 
                            posfam, 0, [], NORMAL])
                    totdescfam += 1 #add this person as descendant
                    pospers = len(self.gen2people[gen+1]) - 1
                    if not dup and not(self.generations == gen+2):
                        nrdesc = self.__rec_fill_data(gen+1, child, pospers)
                        self.handle2desc[child_ref.ref] += nrdesc
                        totdescfam += nrdesc # add children of him as descendants
                self.famhandle2desc[family_handle] = totdescfam
            totdesc += totdescfam
        return totdesc
    def recurse(self, level, person, curdepth):

        person_handle = person.get_handle()
        display_num = self.objPrint.print_person(level, person)

        if curdepth is None:
            ref_str = display_num
        else:
            ref_str = curdepth + " " + display_num

        if person_handle not in self.person_printed:
            self.person_printed[person_handle] = ref_str
            report_person_ref[person_handle] = (self.report_count, ref_str)

        for family_handle in person.get_family_handle_list():
            family = self.database.get_family_from_handle(family_handle)

            spouse_handle = ReportUtils.find_spouse(person, family)

            if not self.showdups and spouse_handle in self.person_printed:
                # Just print a reference
                spouse = self.database.get_person_from_handle(spouse_handle)
                self.objPrint.print_reference(level, spouse,
                        self.person_printed[person_handle])

            else:
                if not self.showdups and self.report_count > 1:
                    if spouse_handle in report_person_ref:
                        self.objPrint.print_spouse(level, spouse_handle, family)
                        childlist = family.get_child_ref_list()[:]
                        if len(childlist) > 0:
                            spouse = \
                                self.database.get_person_from_handle(
                                                                spouse_handle)
                            self.objPrint.print_report_reference(
                                level+1, person,
                                spouse, report_person_ref[spouse_handle])
                        return

                self.objPrint.print_spouse(level, spouse_handle, family)

                if spouse_handle:
                    spouse_num = _("%s sp." % (ref_str))
                    self.person_printed[spouse_handle] = spouse_num
                    report_person_ref[spouse_handle] = \
                        (self.report_count, spouse_num)

                if level >= self.max_generations:
                    continue

                childlist = family.get_child_ref_list()[:]
                for child_ref in childlist:
                    child = self.database.get_person_from_handle(child_ref.ref)
                    self.recurse(level+1, child, ref_str)
Exemple #6
0
 def display_family(self, family, active_person):
     """
     Display the events for the given family.
     """
     spouse_handle = find_spouse(active_person, family)
     if spouse_handle:
         spouse = self.dbstate.db.get_person_from_handle(spouse_handle)
     else:
         spouse = None
     if family:
         for event_ref in family.get_event_ref_list():
             self.add_event_ref(event_ref, spouse)
Exemple #7
0
 def display_family(self, family, active_person):
     """
     Display the events for the given family.
     """
     spouse_handle = find_spouse(active_person, family)
     if spouse_handle:
         spouse = self.dbstate.db.get_person_from_handle(spouse_handle)
     else:
         spouse = None
     if family:
         for event_ref in family.get_event_ref_list():
             self.add_event_ref(event_ref, spouse)
Exemple #8
0
    def display_family(self, family, active_person):
        """
        Display the children of given family.
        """
        spouse_handle = find_spouse(active_person, family)
        if spouse_handle:
            spouse = self.dbstate.db.get_person_from_handle(spouse_handle)
        else:
            spouse = None

        for child_ref in family.get_child_ref_list():
            child = self.dbstate.db.get_person_from_handle(child_ref.ref)
            self.add_child(child, spouse)
Exemple #9
0
    def __get_spouse(self, person, family):

        spouse_handle = utils.find_spouse(person, family)
        if not spouse_handle:
            if family.get_relationship() == FamilyRelType.MARRIED:
                return UnknownPerson
            else:
                return None
        spouse = self.dbstate.db.get_person_from_handle(spouse_handle)
        if self.__ignore_handle is not None and self.__ignore_handle in spouse.get_tag_list():
            return None
        else:
            return spouse
Exemple #10
0
    def display_family(self, family, active_person):
        """
        Display the children of given family.
        """
        spouse_handle = find_spouse(active_person, family)
        if spouse_handle:
            spouse = self.dbstate.db.get_person_from_handle(spouse_handle)
        else:
            spouse = None

        for child_ref in family.get_child_ref_list():
            child = self.dbstate.db.get_person_from_handle(child_ref.ref)
            self.add_child(child, spouse)
    def _rec_fill_data(self, gen, person, pos, maxgen):
        """
        Recursively fill in the data
        """
        totdesc = 0
        marriage_handle_list = person.get_family_handle_list()
        self.gen2people[gen][pos][5] = len(marriage_handle_list)
        for family_handle in marriage_handle_list:
            totdescfam = 0
            family = self.dbstate.db.get_family_from_handle(family_handle)

            spouse_handle = find_spouse(person, family)
            if spouse_handle:
                spouse = self.dbstate.db.get_person_from_handle(spouse_handle)
            else:
                spouse = None
            # family may occur via father and via mother in the chart, only
            # first to show and count.
            fam_duplicate = family_handle in self.famhandle2desc
            # family, duplicate or not, start angle, slice size,
            #   spouse pos in gen, nrchildren, userdata, parnter, status
            self.gen2fam[gen].append(
                [family, fam_duplicate, 0, 0, pos, 0, [], spouse, NORMAL])
            posfam = len(self.gen2fam[gen]) - 1

            if not fam_duplicate and gen < maxgen - 1:
                nrchild = len(family.get_child_ref_list())
                self.gen2fam[gen][posfam][5] = nrchild
                for child_ref in family.get_child_ref_list():
                    chld = self.dbstate.db.get_person_from_handle(
                        child_ref.ref)
                    child_dup = child_ref.ref in self.handle2desc
                    if not child_dup:
                        # mark this child as processed
                        self.handle2desc[child_ref.ref] = 0
                    # person, duplicate or not, start angle, slice size,
                    #         parent pos in fam, nrfam, userdata, status
                    self.gen2people[gen + 1].append(
                        [chld, child_dup, 0, 0, posfam, 0, [], NORMAL])
                    totdescfam += 1  #add this person as descendant
                    pospers = len(self.gen2people[gen + 1]) - 1
                    if not child_dup:
                        nrdesc = self._rec_fill_data(gen + 1, chld, pospers,
                                                     maxgen)
                        self.handle2desc[child_ref.ref] += nrdesc
                        # add children of him as descendants
                        totdescfam += nrdesc
            if not fam_duplicate:
                self.famhandle2desc[family_handle] = totdescfam
            totdesc += totdescfam
        return totdesc
Exemple #12
0
    def __get_spouse(self, person, family):

        spouse_handle = utils.find_spouse(person, family)
        if not spouse_handle:
            if family.get_relationship() == FamilyRelType.MARRIED:
                return UnknownPerson
            else:
                return None
        spouse = self.dbstate.db.get_person_from_handle(spouse_handle)
        if self.__ignore_handle is not None and \
           self.__ignore_handle in spouse.get_tag_list():
            return None
        else:
            return spouse
Exemple #13
0
    def find_children(self):
        """ find any children """
        # we need to start with all of our "people of interest"
        children_not_yet_processed = set(self._interest_set)
        children_to_include = set()

        # now we find all the children of our people of interest

        while len(children_not_yet_processed) > 0:
            handle = children_not_yet_processed.pop()

            if handle not in children_to_include:

                person = self._db.get_person_from_handle(handle)

                # remember this person!
                children_to_include.add(handle)

                # if we have a limit on the number of people, and we've
                # reached that limit, then don't attempt to find any
                # more children
                if (self._limitchildren and
                        (self._maxchildren <
                         len(children_not_yet_processed) +
                         len(children_to_include)
                        )):
                    # get back to the top of the while loop
                    # so we can finish processing the people
                    # queued up in the "not yet processed" list
                    continue

                # iterate through this person's families
                for family_handle in person.get_family_handle_list():
                    family = self._db.get_family_from_handle(family_handle)

                    # queue up any children from this person's family
                    for childref in family.get_child_ref_list():
                        child = self._db.get_person_from_handle(childref.ref)
                        children_not_yet_processed.add(child.get_handle())
                        self._families.add(family_handle)

                    # include the spouse from this person's family
                    spouse_handle = utils.find_spouse(person, family)
                    if spouse_handle:
                        children_to_include.add(spouse_handle)
                        self._families.add(family_handle)

        # we now merge our temp set "children_to_include" into our master set
        self._people.update(children_to_include)
Exemple #14
0
        def _recurse(self, handle):
            if not handle:
                return
            if handle in self._people:
                return

            person = self._db.get_person_from_handle(handle)
            # if this is a private record, and we're not
            # including private records, then go back to the
            # top of the while loop to get the next person

            if person.private and not self._incprivate:
                return

            # remember this person!
            self._people.add(handle)

            # if this person is an edge-case, we are done
            if handle in self._edgepeople:
                return

            ## find spouses and children
            ## by walking through all families were we are parent
            for family_handle in person.get_family_handle_list():
                if not family_handle in self._families:
                    self._families.add(family_handle)
                    family = self._db.get_family_from_handle(family_handle)

                    ## add spouse
                    spouse_handle = ReportUtils.find_spouse(person, family)
                    self._recurse(spouse_handle)

                    ## add children
                    for child_ref in family.get_child_ref_list():
                        self._recurse(child_ref.ref)

            ## find parents
            for family_handle in person.get_parent_family_handle_list():
                if not family_handle in self._families:
                    self._families.add(family_handle)
                    family = self._db.get_family_from_handle(family_handle)

                    ## add parents
                    self._recurse(family.get_father_handle())
                    self._recurse(family.get_mother_handle())
                    ## add siblings
                    for sibling_ref in family.get_child_ref_list():
                        self._recurse(sibling_ref.ref)
Exemple #15
0
    def write_marriage(self, person):
        """
        Output marriage sentence.
        """
        is_first = True
        for family_handle in person.get_family_handle_list():
            family = self.db.get_family_from_handle(family_handle)
            spouse_handle = ReportUtils.find_spouse(person,family)
            spouse = self.db.get_person_from_handle(spouse_handle)
            spouse_mark = ReportUtils.get_person_mark(self.db, spouse)
            text = ""
            text = self.__narrator.get_married_string(family, is_first,
                                                      self._name_display)

            if text:
                self.doc.write_text_citation(text, spouse_mark)
                is_first = False
Exemple #16
0
    def write_marriage(self, person):
        """ 
        Output marriage sentence.
        """
        is_first = True
        for family_handle in person.get_family_handle_list():
            family = self.db.get_family_from_handle(family_handle)
            spouse_handle = ReportUtils.find_spouse(person,family)
            spouse = self.db.get_person_from_handle(spouse_handle)
            spouse_mark = ReportUtils.get_person_mark(self.db, spouse)
            text = ""
            text = self.__narrator.get_married_string(family, is_first,
                                                      self._name_display)

            if text:
                self.doc.write_text_citation(text, spouse_mark)
                is_first = False
Exemple #17
0
    def _rec_fill_data(self, gen, person, pos, maxgen):
        """
        Recursively fill in the data
        """
        totdesc = 0
        marriage_handle_list = person.get_family_handle_list()
        self.gen2people[gen][pos][5] = len(marriage_handle_list)
        for family_handle in marriage_handle_list:
            totdescfam = 0
            family = self.dbstate.db.get_family_from_handle(family_handle)

            spouse_handle = find_spouse(person, family)
            if spouse_handle:
                spouse = self.dbstate.db.get_person_from_handle(spouse_handle)
            else:
                spouse = None
            # family may occur via father and via mother in the chart, only
            # first to show and count.
            fam_duplicate = family_handle in self.famhandle2desc
            # family, duplicate or not, start angle, slice size,
            #   spouse pos in gen, nrchildren, userdata, parnter, status
            self.gen2fam[gen].append([family, fam_duplicate, 0, 0, pos, 0, [], spouse, NORMAL])
            posfam = len(self.gen2fam[gen]) - 1

            if not fam_duplicate and gen < maxgen-1:
                nrchild = len(family.get_child_ref_list())
                self.gen2fam[gen][posfam][5] = nrchild
                for child_ref in family.get_child_ref_list():
                    child = self.dbstate.db.get_person_from_handle(child_ref.ref)
                    child_dup = child_ref.ref in self.handle2desc
                    if not child_dup:
                        self.handle2desc[child_ref.ref] = 0  # mark this child as processed
                    # person, duplicate or not, start angle, slice size,
                    #         parent pos in fam, nrfam, userdata, status
                    self.gen2people[gen+1].append([child, child_dup, 0, 0, posfam, 0, [], NORMAL])
                    totdescfam += 1 #add this person as descendant
                    pospers = len(self.gen2people[gen+1]) - 1
                    if not child_dup:
                        nrdesc = self._rec_fill_data(gen+1, child, pospers, maxgen)
                        self.handle2desc[child_ref.ref] += nrdesc
                        totdescfam += nrdesc # add children of him as descendants
            if not fam_duplicate:
                self.famhandle2desc[family_handle] = totdescfam
            totdesc += totdescfam
        return totdesc
Exemple #18
0
    def add_children(self, person):
        self._people.add(person.get_handle())

        for family_handle in person.get_family_handle_list():
            family = self.database.get_family_from_handle(family_handle)
            for childref in family.get_child_ref_list():
                child = self.database.get_person_from_handle(childref.ref)
                if (self._withchildren
                        or child.get_gramps_id() in self._gidlist):
                    self.add_children(child)
                    self._families.add(family_handle)

            spouse_handle = utils.find_spouse(person, family)
            if spouse_handle:
                spouse = self.database.get_person_from_handle(spouse_handle)
                if self._withspouses or spouse.get_gramps_id(
                ) in self._gidlist:
                    self._people.add(spouse_handle)
                    self._families.add(family_handle)
    def write_marriage(self, person):
        """
        Output marriage sentence.
        """
        is_first = True
        for family_handle in person.get_family_handle_list():
            family = self._db.get_family_from_handle(family_handle)
            spouse_handle = utils.find_spouse(person, family)
            if spouse_handle:
                spouse = self._db.get_person_from_handle(spouse_handle)
                spouse_mark = utils.get_person_mark(self._db, spouse)
            else:
                spouse_mark = None

            text = self.__narrator.get_married_string(family, is_first,
                                                      self._nd)
            if text:
                self.doc.write_text_citation(text, spouse_mark)
                if self.want_ids:
                    self.doc.write_text(' (%s)' % family.get_gramps_id())
                is_first = False
Exemple #20
0
    def write_marriage(self, person):
        """
        Output marriage sentence.
        """
        is_first = True
        for family_handle in person.get_family_handle_list():
            family = self._db.get_family_from_handle(family_handle)
            spouse_handle = utils.find_spouse(person, family)
            if spouse_handle:
                spouse = self._db.get_person_from_handle(spouse_handle)
                spouse_mark = utils.get_person_mark(self._db, spouse)
            else:
                spouse_mark = None

            text = self.__narrator.get_married_string(family,
                                                      is_first,
                                                      self._nd)
            if text:
                self.doc.write_text_citation(text, spouse_mark)
                if self.want_ids:
                    self.doc.write_text(' (%s)' % family.get_gramps_id())
                is_first = False
    def recurse(self, level, person, curdepth):
        """ recurse """

        person_handle = person.get_handle()
        display_num = self.obj_print.print_person(level, person)

        if curdepth is None:
            ref_str = display_num
        else:
            ref_str = curdepth + " " + display_num

        if person_handle not in self.person_printed:
            self.person_printed[person_handle] = ref_str

        for family_handle in person.get_family_handle_list():
            family = self.database.get_family_from_handle(family_handle)

            spouse_handle = utils.find_spouse(person, family)

            if not self.showdups and spouse_handle in self.person_printed:
                # Just print a reference
                spouse = self.database.get_person_from_handle(spouse_handle)
                self.obj_print.print_reference(
                    level, spouse, self.person_printed[spouse_handle])
            else:
                self.obj_print.print_spouse(level, spouse_handle, family)

                if spouse_handle:
                    spouse_num = self._("%s sp.") % ref_str
                    self.person_printed[spouse_handle] = spouse_num

                if level >= self.max_generations:
                    continue

                childlist = family.get_child_ref_list()[:]
                for child_ref in childlist:
                    child = self.database.get_person_from_handle(child_ref.ref)
                    self.recurse(level + 1, child, ref_str)
Exemple #22
0
    def recurse(self, level, person, curdepth):
        """ recurse """

        person_handle = person.get_handle()
        display_num = self.obj_print.print_person(level, person)

        if curdepth is None:
            ref_str = display_num
        else:
            ref_str = curdepth + " " + display_num

        if person_handle not in self.person_printed:
            self.person_printed[person_handle] = ref_str

        for family_handle in person.get_family_handle_list():
            family = self.database.get_family_from_handle(family_handle)

            spouse_handle = utils.find_spouse(person, family)

            if not self.showdups and spouse_handle in self.person_printed:
                # Just print a reference
                spouse = self.database.get_person_from_handle(spouse_handle)
                self.obj_print.print_reference(
                    level, spouse, self.person_printed[spouse_handle])
            else:
                self.obj_print.print_spouse(level, spouse_handle, family)

                if spouse_handle:
                    spouse_num = self._("%s sp.") % ref_str
                    self.person_printed[spouse_handle] = spouse_num

                if level >= self.max_generations:
                    continue

                childlist = family.get_child_ref_list()[:]
                for child_ref in childlist:
                    child = self.database.get_person_from_handle(child_ref.ref)
                    self.recurse(level+1, child, ref_str)
Exemple #23
0
    def findParents(self):
        # we need to start with all of our "people of interest"
        ancestorsNotYetProcessed = set(self._interest_set)

        # now we find all the immediate ancestors of our people of interest

        while ancestorsNotYetProcessed:
            handle = ancestorsNotYetProcessed.pop()

            # One of 2 things can happen here:
            #   1) we've already know about this person and he/she is already
            #      in our list
            #   2) this is someone new, and we need to remember him/her
            #
            # In the first case, there isn't anything else to do, so we simply
            # go back to the top and pop the next person off the list.
            #
            # In the second case, we need to add this person to our list, and
            # then go through all of the parents this person has to find more
            # people of interest.

            if handle not in self._people:
                person = self.database.get_person_from_handle(handle)

                # if this is a private record, and we're not
                # including private records, then go back to the
                # top of the while loop to get the next person
                if person.private and not self._incprivate:
                    continue

                # remember this person!
                self._people.add(handle)

                # see if a family exists between this person and someone else
                # we have on our list of people we're going to output -- if
                # there is a family, then remember it for when it comes time
                # to link spouses together
                for family_handle in person.get_family_handle_list():
                    family = self.database.get_family_from_handle(
                        family_handle)
                    spouse_handle = ReportUtils.find_spouse(person, family)
                    if spouse_handle:
                        if (spouse_handle in self._people
                                or spouse_handle in ancestorsNotYetProcessed):
                            self._families.add(family_handle)

                # if we have a limit on the number of people, and we've
                # reached that limit, then don't attempt to find any
                # more ancestors
                if self._limitparents and (
                        self._maxparents <
                        len(ancestorsNotYetProcessed) + len(self._people)):
                    # get back to the top of the while loop so we can finish
                    # processing the people queued up in the "not yet
                    # processed" list
                    continue

                # queue the parents of the person we're processing
                for family_handle in person.get_parent_family_handle_list():
                    family = self.database.get_family_from_handle(
                        family_handle)

                    if not family.private or self._incprivate:
                        try:
                            father = self.database.get_person_from_handle(
                                family.get_father_handle())
                        except AttributeError:
                            father = None
                        try:
                            mother = self.database.get_person_from_handle(
                                family.get_mother_handle())
                        except AttributeError:
                            mother = None
                        if father:
                            if not father.private or self._incprivate:
                                ancestorsNotYetProcessed.add(
                                    family.get_father_handle())
                                self._families.add(family_handle)
                        if mother:
                            if not mother.private or self._incprivate:
                                ancestorsNotYetProcessed.add(
                                    family.get_mother_handle())
                                self._families.add(family_handle)

                        for sib in family.get_child_ref_list():
                            sibling = self.database.get_person_from_handle(
                                sib.ref)
                            if sibling and (not sibling.private
                                            or self._incprivate):
                                ancestorsNotYetProcessed.add(sib.ref)
                                self._families.add(family_handle)
Exemple #24
0
    def display(self, tobj, person):
        """Fill text buffer tobj with detailed info on person person."""
        normal = tobj.create_tag()
        normal.set_property('indent', 10)
        normal.set_property('pixels-above-lines', 1)
        normal.set_property('pixels-below-lines', 1)
        indent = tobj.create_tag()
        indent.set_property('indent', 30)
        indent.set_property('pixels-above-lines', 1)
        indent.set_property('pixels-below-lines', 1)
        title = tobj.create_tag()
        title.set_property('weight', Pango.Weight.BOLD)
        title.set_property('scale', 1.2)
        self.add(tobj, title, name_displayer.display(person))
        self.add(tobj, normal, "%s:\t%s" % (_('ID'), person.get_gramps_id()))
        self.add(tobj, normal,
                 "%s:\t%s" % (_('Gender'), sex[person.get_gender()]))
        bref = person.get_birth_ref()
        if bref:
            self.add(tobj, normal,
                     "%s:\t%s" % (_('Birth'), self.get_event_info(bref.ref)))
        dref = person.get_death_ref()
        if dref:
            self.add(tobj, normal,
                     "%s:\t%s" % (_('Death'), self.get_event_info(dref.ref)))

        nlist = person.get_alternate_names()
        if len(nlist) > 0:
            self.add(tobj, title, _("Alternate Names"))
            for name in nlist:
                self.add(tobj, normal, name_displayer.display_name(name))

        elist = person.get_event_ref_list()
        if len(elist) > 0:
            self.add(tobj, title, _("Events"))
            for event_ref in person.get_event_ref_list():
                event_handle = event_ref.ref
                role = event_ref.get_role()
                name = str(
                    self.database.get_event_from_handle(
                        event_handle).get_type())
                if role.is_primary():
                    self.add(
                        tobj, normal,
                        "%s:\t%s" % (name, self.get_event_info(event_handle)))
                else:
                    self.add(
                        tobj, normal, "%s (%s):\t%s" %
                        (name, role, self.get_event_info(event_handle)))
        plist = person.get_parent_family_handle_list()

        if len(plist) > 0:
            self.add(tobj, title, _("Parents"))
            for fid in person.get_parent_family_handle_list():
                (fname, mname, gid) = self.get_parent_info(fid)
                self.add(tobj, normal, "%s:\t%s" % (_('Family ID'), gid))
                if fname:
                    self.add(tobj, indent, "%s:\t%s" % (_('Father'), fname))
                if mname:
                    self.add(tobj, indent, "%s:\t%s" % (_('Mother'), mname))
        else:
            self.add(tobj, normal, _("No parents found"))

        self.add(tobj, title, _("Spouses"))
        slist = person.get_family_handle_list()
        if len(slist) > 0:
            for fid in slist:
                (fname, mname, pid) = self.get_parent_info(fid)
                family = self.database.get_family_from_handle(fid)
                self.add(tobj, normal, "%s:\t%s" % (_('Family ID'), pid))
                spouse_id = ReportUtils.find_spouse(person, family)
                if spouse_id:
                    spouse = self.database.get_person_from_handle(spouse_id)
                    self.add(tobj, indent,
                             "%s:\t%s" % (_('Spouse'), name_of(spouse)))
                relstr = str(family.get_relationship())
                self.add(tobj, indent, "%s:\t%s" % (_('Type'), relstr))
                event = ReportUtils.find_marriage(self.database, family)
                if event:
                    self.add(
                        tobj, indent,
                        "%s:\t%s" % (_('Marriage'),
                                     self.get_event_info(event.get_handle())))
                for child_ref in family.get_child_ref_list():
                    child = self.database.get_person_from_handle(child_ref.ref)
                    self.add(tobj, indent,
                             "%s:\t%s" % (_('Child'), name_of(child)))
        else:
            self.add(tobj, normal, _("No spouses or children found"))

        alist = person.get_address_list()
        if len(alist) > 0:
            self.add(tobj, title, _("Addresses"))
            for addr in alist:
                location = ", ".join([
                    addr.get_street(),
                    addr.get_city(),
                    addr.get_state(),
                    addr.get_country(),
                    addr.get_postal_code(),
                    addr.get_phone()
                ])
                self.add(tobj, normal, location.strip())
Exemple #25
0
    def display(self, tobj, person):
        """Fill text buffer tobj with detailed info on person person."""
        normal = tobj.create_tag()
        normal.set_property('indent', 10)
        normal.set_property('pixels-above-lines', 1)
        normal.set_property('pixels-below-lines', 1)
        indent = tobj.create_tag()
        indent.set_property('indent', 30)
        indent.set_property('pixels-above-lines', 1)
        indent.set_property('pixels-below-lines', 1)
        title = tobj.create_tag()
        title.set_property('weight', Pango.Weight.BOLD)
        title.set_property('scale', 1.2)
        self.add(tobj, title, name_displayer.display(person))
        self.add(tobj, normal, KEYVAL % {
            'key': _('ID'),
            'value': person.get_gramps_id()
        })
        self.add(
            tobj, normal, KEYVAL % {
                'key': _('Gender'),
                'value': sex[person.get_gender()]
            })
        bref = person.get_birth_ref()
        if bref:
            self.add(
                tobj, normal, KEYVAL % {
                    'key': _('Birth'),
                    'value': self.get_event_info(bref.ref)
                })
        dref = person.get_death_ref()
        if dref:
            self.add(
                tobj, normal, KEYVAL % {
                    'key': _('Death'),
                    'value': self.get_event_info(dref.ref)
                })

        nlist = person.get_alternate_names()
        if len(nlist) > 0:
            self.add(tobj, title, _("Alternate Names"))
            for name in nlist:
                self.add(tobj, normal, name_displayer.display_name(name))

        elist = person.get_event_ref_list()
        if len(elist) > 0:
            self.add(tobj, title, _("Events"))
            for event_ref in person.get_event_ref_list():
                event_handle = event_ref.ref
                role = event_ref.get_role()
                name = str(
                    self.database.get_event_from_handle(
                        event_handle).get_type())
                ev_info = self.get_event_info(event_handle)
                if role.is_primary():
                    self.add(tobj, normal, KEYVAL % {
                        'key': name,
                        'value': ev_info
                    })
                else:
                    self.add(
                        tobj,
                        normal,  # translators: needed for French
                        "%(name)s (%(role)s):\t%(info)s" % {
                            'name': name,
                            'role': role,
                            'info': ev_info
                        })
        plist = person.get_parent_family_handle_list()

        if len(plist) > 0:
            self.add(tobj, title, _("Parents"))
            for fid in person.get_parent_family_handle_list():
                (fname, mname, gid) = self.get_parent_info(fid)
                self.add(tobj, normal, KEYVAL % {
                    'key': _('Family ID'),
                    'value': gid
                })
                if fname:
                    self.add(tobj, indent, KEYVAL % {
                        'key': _('Father'),
                        'value': fname
                    })
                if mname:
                    self.add(tobj, indent, KEYVAL % {
                        'key': _('Mother'),
                        'value': mname
                    })
        else:
            self.add(tobj, normal, _("No parents found"))

        self.add(tobj, title, _("Spouses"))
        slist = person.get_family_handle_list()
        if len(slist) > 0:
            for fid in slist:
                (fname, mname, pid) = self.get_parent_info(fid)
                family = self.database.get_family_from_handle(fid)
                self.add(tobj, normal, KEYVAL % {
                    'key': _('Family ID'),
                    'value': pid
                })
                spouse_id = utils.find_spouse(person, family)
                if spouse_id:
                    spouse = self.database.get_person_from_handle(spouse_id)
                    self.add(
                        tobj, indent, KEYVAL % {
                            'key': _('Spouse'),
                            'value': name_of(spouse)
                        })
                relstr = str(family.get_relationship())
                self.add(tobj, indent, KEYVAL % {
                    'key': _('Type'),
                    'value': relstr
                })
                event = utils.find_marriage(self.database, family)
                if event:
                    m_info = self.get_event_info(event.get_handle())
                    self.add(tobj, indent, KEYVAL % {
                        'key': _('Marriage'),
                        'value': m_info
                    })
                for child_ref in family.get_child_ref_list():
                    child = self.database.get_person_from_handle(child_ref.ref)
                    self.add(
                        tobj, indent, KEYVAL % {
                            'key': _('Child'),
                            'value': name_of(child)
                        })
        else:
            self.add(tobj, normal, _("No spouses or children found"))

        alist = person.get_address_list()
        if len(alist) > 0:
            self.add(tobj, title, _("Addresses"))
            for addr in alist:
                # TODO for Arabic, should the next line's comma be translated?
                location = ", ".join([
                    addr.get_street(),
                    addr.get_city(),
                    addr.get_state(),
                    addr.get_country(),
                    addr.get_postal_code(),
                    addr.get_phone()
                ])
                self.add(tobj, normal, location.strip())
Exemple #26
0
    def __calc_person_key(self, person):
        """
        The person key is a unique identifier that is built from the
        relationship to the default person. It consists of the "Ahnentafel"
        number of the common ancestor of the person with the default person,
        and then a letter representing the child number for each generation
        from the common ancestor to the person.

        If more than one common ancestor exists, the common ancestor with the
        lowest "Ahnentafel" number has precedence.

        For example, the second child of the third child of the father of the
        mother of the central person gets the person key "6cb".
        """

        relationship = get_relationship_calculator()

        default_person = self.database.get_default_person()

        # No home person set.
        if default_person is None:
            return (-1, 0, "")

        # First try direct relationship.
        spousestring = ""
        info, msg = relationship.get_relationship_distance_new(self.database, default_person, person, all_dist=True)
        info = relationship.collapse_relations(info)[0]
        (rank, ancestor_handle, default_rel, default_fam, person_rel, person_fam) = info

        # Then try relationship to any spouse.
        if rank == -1:
            index = 0
            for family_handle in default_person.get_family_handle_list():
                index += 1
                family = self.database.get_family_from_handle(family_handle)
                spouse_handle = utils.find_spouse(default_person, family)
                spouse = self.database.get_person_from_handle(spouse_handle)
                info, msg = relationship.get_relationship_distance_new(self.database, spouse, person, all_dist=True)
                info = relationship.collapse_relations(info)[0]
                (rank, ancestor_handle, default_rel, default_fam, person_rel, person_fam) = info
                if rank != -1:
                    spousestring = utils.roman(index)
                    break
            # If no relationship found at all, exit here.
            if rank == -1:
                return (rank, 0, "")

        # Calculate Ahnentafel number of common ancestor.
        ahnentafel = 1
        for rel in default_rel:
            ahnentafel *= 2
            if rel in (relationship.REL_MOTHER, relationship.REL_MOTHER_NOTBIRTH):
                ahnentafel += 1

        # Find out child letters.
        child = person
        childletters = ""
        for rel in person_rel:
            family_handle = child.get_main_parents_family_handle()
            family = self.database.get_family_from_handle(family_handle)
            if rel in (relationship.REL_MOTHER, relationship.REL_MOTHER_NOTBIRTH):
                parent_handle = family.get_mother_handle()
            else:
                parent_handle = family.get_father_handle()
            parent = self.database.get_person_from_handle(parent_handle)
            # Count *all* children from this parent
            childletter = "?"
            index = 0
            for family_handle in parent.get_family_handle_list():
                family = self.database.get_family_from_handle(family_handle)
                for child_ref in family.get_child_ref_list():
                    if child_ref.ref == child.get_handle():
                        childletter = string.ascii_lowercase[index]
                        break
                    index += 1
                else:
                    continue
                break
            childletters = childletter + childletters
            child = parent

        return (rank, ahnentafel, "%s%s%s" % (spousestring, ahnentafel, childletters))
Exemple #27
0
    def __process_person(self, person, rank, ahnentafel, person_key):
        """
        Recursively build the Family Sheet for this person and all children
        with spouses.

        @param person: Person object for the key person of the Family Sheet.
        @param rank: Numerical distance between the central person in the
            database and the person in the parameter (the number of births
            needed to connect them).
        @param ahnentafel: "Ahnentafel" number of the common ancestor of the
            central person in the database and the person in the parameter,
            seen from the side of the central person in the database.
        @param person_key: Family Sheet key to be printed on the top right of
            the corner.
        """

        # List of (person, rank, ahnentafel, person_key) tuples for persons to
        # process recursively after this one.
        more_sheets = []

        # Numbering of spouses (integer, but printed in roman numbers).
        spouse_index = 0

        # Numbering of children (integer, but printed as lowercase letters).
        child_index = 0

        # Source references to print as footnotes.
        self.__citation_index = 0
        self.__citations = []

        # Notes to print as footnotes.
        self.__note_index = 0
        self.__notes = []

        # --- Now let the party begin! ---

        self.doc.start_paragraph("FSR-Key")
        self.doc.write_text(person_key)
        self.doc.end_paragraph()

        self.doc.start_table(None, "FSR-Table")

        # Main person
        self.doc.start_row()
        self.doc.start_cell("FSR-HeadCell", 3)
        self.__dump_person(person, False, None)
        self.doc.end_cell()
        self.doc.end_row()

        # Spouses
        for family_handle in person.get_family_handle_list():
            family = self.database.get_family_from_handle(family_handle)

            spouse_index += 1

            spouse_handle = utils.find_spouse(person, family)
            spouse = self.database.get_person_from_handle(spouse_handle)

            # Determine relationship between the center person and the spouse.
            # If the spouse has a closer blood relationship than the current
            # person, we refer to the Family Sheet of the spouse instead of
            # printing the child list, because all children are more closely
            # related to the center person via the spouse than via the current
            # person. The same happens if the relationship is on the same
            # level, but the relationship via the spouse goes via a common
            # ancestor with a lower Ahnentafel numbering (i.e. a relationship
            # stronger father-sided). In these cases, refer_spouse will be set
            # to True.
            (spouse_rank, spouse_at, spouse_key) = self.__calc_person_key(spouse)
            if self.recurse != RelationsOptions.RECURSE_ALL:
                refer_spouse = spouse_rank != -1 and (
                    spouse_rank < rank or (spouse_rank == rank and spouse_at < ahnentafel)
                )
            else:
                refer_spouse = False

            self.doc.start_row()

            self.doc.start_cell("FSR-NumberCell", 1)
            self.doc.start_paragraph("FSR-Number")
            self.doc.write_text(utils.roman(spouse_index))
            self.doc.end_paragraph()
            self.doc.end_cell()

            self.doc.start_cell("FSR-DataCell", 2)
            self.__dump_family(family, spouse)
            if refer_spouse:
                self.doc.start_paragraph("FSR-Normal")
                self.doc.write_text(_("\u2192 %s") % spouse_key)
                self.doc.end_paragraph()
            self.doc.end_cell()

            self.doc.end_row()

            if refer_spouse:
                # Spouse with closer relationship than current person? Don't
                # print children on this Family Sheet (but count them for the
                # numbering).
                child_index += len(family.get_child_ref_list())
                continue

            # Children
            for child_ref in family.get_child_ref_list():
                child = self.database.get_person_from_handle(child_ref.ref)
                child_letter = string.ascii_lowercase[child_index]

                self.doc.start_row()

                self.doc.start_cell("FSR-EmptyCell", 1)
                self.doc.end_cell()

                self.doc.start_cell("FSR-NumberCell", 1)
                self.doc.start_paragraph("FSR-Number")
                self.doc.write_text(child_letter)
                self.doc.end_paragraph()
                self.doc.end_cell()

                self.doc.start_cell("FSR-DataCell", 1)

                has_spouses = child.get_family_handle_list() != []

                self.__dump_person(child, has_spouses, child_ref)

                if has_spouses:
                    # We have to recalculate the key for this person, it could
                    # be closer related if it is a direct ancestor of the
                    # central person or one of its spouses.
                    (child_rank, child_at, child_key) = self.__calc_person_key(child)

                    self.doc.start_paragraph("FSR-Normal")
                    self.doc.write_text(_("\u2192 %s") % child_key)
                    self.doc.end_paragraph()

                    # We recursively print this child *only* if its
                    # relationship with the central person is closest via the
                    # current person. This way, we avoid that a person is
                    # printed recursively from more than one of its ancestors.
                    if child_key == person_key + child_letter or self.recurse == RelationsOptions.RECURSE_ALL:
                        more_sheets.append((child, child_rank, child_at, child_key))

                self.doc.end_cell()

                self.doc.end_row()

                child_index += 1

        self.doc.start_row()
        self.doc.start_cell("FSR-FootCell", 3)
        self.doc.end_cell()
        self.doc.end_row()

        self.doc.end_table()

        self.__dump_sources()
        self.__dump_notes()

        # Now print the sheets for the children.
        if self.recurse != RelationsOptions.RECURSE_NONE:
            for (child, child_rank, child_at, child_key) in more_sheets:
                self.doc.page_break()
                self.__process_person(child, child_rank, child_at, child_key)
Exemple #28
0
    def display(self, tobj, person):
        """Fill text buffer tobj with detailed info on person person."""
        normal = tobj.create_tag()
        normal.set_property('indent', 10)
        normal.set_property('pixels-above-lines', 1)
        normal.set_property('pixels-below-lines', 1)
        indent = tobj.create_tag()
        indent.set_property('indent', 30)
        indent.set_property('pixels-above-lines', 1)
        indent.set_property('pixels-below-lines', 1)
        title = tobj.create_tag()
        title.set_property('weight', Pango.Weight.BOLD)
        title.set_property('scale', 1.2)
        self.add(tobj, title, name_displayer.display(person))
        self.add(tobj, normal, KEYVAL % {'key': _('ID'),
                                         'value': person.get_gramps_id()})
        self.add(tobj, normal, KEYVAL % {'key': _('Gender'),
                                         'value': sex[person.get_gender()]})
        bref = person.get_birth_ref()
        if bref:
            self.add(tobj, normal,
                     KEYVAL % {'key': _('Birth'),
                               'value': self.get_event_info(bref.ref)})
        dref = person.get_death_ref()
        if dref:
            self.add(tobj, normal,
                     KEYVAL % {'key': _('Death'),
                               'value': self.get_event_info(dref.ref)})

        nlist = person.get_alternate_names()
        if len(nlist) > 0:
            self.add(tobj, title, _("Alternate Names"))
            for name in nlist:
                self.add(tobj, normal,
                         name_displayer.display_name(name))

        elist = person.get_event_ref_list()
        if len(elist) > 0:
            self.add(tobj, title, _("Events"))
            for event_ref in person.get_event_ref_list():
                event_handle = event_ref.ref
                role = event_ref.get_role()
                name = str(
                    self.database.get_event_from_handle(event_handle).get_type())
                ev_info = self.get_event_info(event_handle)
                if role.is_primary():
                    self.add(tobj, normal,
                             KEYVAL % {'key': name, 'value': ev_info})
                else:
                    self.add(tobj, normal, # translators: needed for French
                             "%(name)s (%(role)s):\t%(info)s"
                                 % {'name': name, 'role': role,
                                    'info': ev_info})
        plist = person.get_parent_family_handle_list()

        if len(plist) > 0:
            self.add(tobj, title, _("Parents"))
            for fid in person.get_parent_family_handle_list():
                (fname, mname, gid) = self.get_parent_info(fid)
                self.add(tobj, normal,
                         KEYVAL % {'key': _('Family ID'), 'value': gid})
                if fname:
                    self.add(tobj, indent,
                             KEYVAL % {'key': _('Father'), 'value': fname})
                if mname:
                    self.add(tobj, indent,
                             KEYVAL % {'key': _('Mother'), 'value': mname})
        else:
            self.add(tobj, normal, _("No parents found"))

        self.add(tobj, title, _("Spouses"))
        slist = person.get_family_handle_list()
        if len(slist) > 0:
            for fid in slist:
                (fname, mname, pid) = self.get_parent_info(fid)
                family = self.database.get_family_from_handle(fid)
                self.add(tobj, normal,
                         KEYVAL % {'key': _('Family ID'), 'value': pid})
                spouse_id = utils.find_spouse(person, family)
                if spouse_id:
                    spouse = self.database.get_person_from_handle(spouse_id)
                    self.add(tobj, indent, KEYVAL % {'key': _('Spouse'),
                                                     'value': name_of(spouse)})
                relstr = str(family.get_relationship())
                self.add(tobj, indent,
                         KEYVAL % {'key': _('Type'), 'value': relstr})
                event = utils.find_marriage(self.database, family)
                if event:
                    m_info = self.get_event_info(event.get_handle())
                    self.add(tobj, indent,
                             KEYVAL % {'key': _('Marriage'), 'value': m_info})
                for child_ref in family.get_child_ref_list():
                    child = self.database.get_person_from_handle(child_ref.ref)
                    self.add(tobj, indent, KEYVAL % {'key': _('Child'),
                                                     'value': name_of(child)})
        else:
            self.add(tobj, normal, _("No spouses or children found"))

        alist = person.get_address_list()
        if len(alist) > 0:
            self.add(tobj, title, _("Addresses"))
            for addr in alist:
                location = ", ".join([addr.get_street(), addr.get_city(),
                                     addr.get_state(), addr.get_country(),
                                     addr.get_postal_code(), addr.get_phone()])
                self.add(tobj, normal, location.strip())
Exemple #29
0
    def __init__(self, report, title, surname, ppl_handle_list):
        """
        @param: report          -- The instance of the main report class for
                                   this report
        @param: title           -- Is the title of the web page
        @param: surname         -- The surname to use
        @param: ppl_handle_list -- The list of people for whom we need to create
                                   a page.
        """
        BasePage.__init__(self, report, title)

        # module variables
        showbirth = report.options['showbirth']
        showdeath = report.options['showdeath']
        showpartner = report.options['showpartner']
        showparents = report.options['showparents']

        if surname == '':
            surname = self._("<absent>")

        output_file, sio = self.report.create_file(name_to_md5(surname), "srn")
        self.uplink = True
        (surnamepage, head,
         body) = self.write_header("%s - %s" % (self._("Surname"), surname))
        ldatec = 0

        # begin SurnameDetail division
        with Html("div", class_="content", id="SurnameDetail") as surnamedetail:
            body += surnamedetail

            # section title
            surnamedetail += Html("h3", html_escape(surname), inline=True)

            # feature request 2356: avoid genitive form
            msg = self._("This page contains an index of all the individuals "
                         "in the database with the surname of %s. "
                         "Selecting the person&#8217;s name "
                         "will take you to that person&#8217;s "
                         "individual page.") % html_escape(surname)
            surnamedetail += Html("p", msg, id="description")

            # begin surname table and thead
            with Html("table", class_="infolist primobjlist surname") as table:
                surnamedetail += table
                thead = Html("thead")
                table += thead

                trow = Html("tr")
                thead += trow

                # Name Column
                trow += Html("th", self._("Given Name"), class_="ColumnName",
                             inline=True)

                if showbirth:
                    trow += Html("th", self._("Birth"), class_="ColumnDate",
                                 inline=True)

                if showdeath:
                    trow += Html("th", self._("Death"), class_="ColumnDate",
                                 inline=True)

                if showpartner:
                    trow += Html("th", self._("Partner"),
                                 class_="ColumnPartner",
                                 inline=True)

                if showparents:
                    trow += Html("th", self._("Parents"),
                                 class_="ColumnParents",
                                 inline=True)

                # begin table body
                tbody = Html("tbody")
                table += tbody

                for person_handle in sorted(ppl_handle_list,
                                            key=self.sort_on_name_and_grampsid):

                    person = self.r_db.get_person_from_handle(person_handle)
                    if person.get_change_time() > ldatec:
                        ldatec = person.get_change_time()
                    trow = Html("tr")
                    tbody += trow

                    # firstname column
                    link = self.new_person_link(person_handle, uplink=True,
                                                person=person,
                                                name_style=_NAME_STYLE_FIRST)
                    trow += Html("td", link, class_="ColumnName")

                    # birth column
                    if showbirth:
                        tcell = Html("td", class_="ColumnBirth", inline=True)
                        trow += tcell

                        birth_date = _find_birth_date(self.r_db, person)
                        if birth_date is not None:
                            if birth_date.fallback:
                                tcell += Html('em',
                                              self.rlocale.get_date(birth_date),
                                              inline=True)
                            else:
                                tcell += self.rlocale.get_date(birth_date)
                        else:
                            tcell += "&nbsp;"

                    # death column
                    if showdeath:
                        tcell = Html("td", class_="ColumnDeath", inline=True)
                        trow += tcell

                        death_date = _find_death_date(self.r_db, person)
                        if death_date is not None:
                            if death_date.fallback:
                                tcell += Html('em',
                                              self.rlocale.get_date(death_date),
                                              inline=True)
                            else:
                                tcell += self.rlocale.get_date(death_date)
                        else:
                            tcell += "&nbsp;"

                    # partner column
                    if showpartner:
                        tcell = Html("td", class_="ColumnPartner")
                        trow += tcell
                        family_list = person.get_family_handle_list()
                        if family_list:
                            fam_count = 0
                            for family_handle in family_list:
                                fam_count += 1
                                family = self.r_db.get_family_from_handle(
                                    family_handle)
                                partner_handle = utils.find_spouse(
                                    person, family)
                                if partner_handle:
                                    link = self.new_person_link(partner_handle,
                                                                uplink=True)
                                    if fam_count < len(family_list):
                                        if isinstance(link, Html):
                                            link.inside += ","
                                        else:
                                            link += ','
                                    tcell += link
                        else:
                            tcell += "&nbsp;"

                    # parents column
                    if showparents:
                        parent_hdl_list = person.get_parent_family_handle_list()
                        if parent_hdl_list:
                            parent_hdl = parent_hdl_list[0]
                            fam = self.r_db.get_family_from_handle(parent_hdl)
                            f_id = fam.get_father_handle()
                            m_id = fam.get_mother_handle()
                            mother = father = None
                            if f_id:
                                father = self.r_db.get_person_from_handle(f_id)
                                if father:
                                    father_name = self.get_name(father)
                            if m_id:
                                mother = self.r_db.get_person_from_handle(m_id)
                                if mother:
                                    mother_name = self.get_name(mother)
                            if mother and father:
                                tcell = Html("span", father_name,
                                             class_="father fatherNmother")
                                tcell += Html("span", mother_name,
                                              class_="mother")
                            elif mother:
                                tcell = Html("span", mother_name,
                                             class_="mother", inline=True)
                            elif father:
                                tcell = Html("span", father_name,
                                             class_="father", inline=True)
                            samerow = False
                        else:
                            tcell = "&nbsp;" # pylint: disable=R0204
                            samerow = True
                        trow += Html("td", tcell,
                                     class_="ColumnParents", inline=samerow)

        # add clearline for proper styling
        # add footer section
        footer = self.write_footer(ldatec)
        body += (FULLCLEAR, footer)

        # send page out for processing
        # and close the file
        self.xhtml_writer(surnamepage, output_file, sio, ldatec)
Exemple #30
0
    def find_parents(self):
        """ find the parents """
        # we need to start with all of our "people of interest"
        ancestors_not_yet_processed = set(self._interest_set)

        # now we find all the immediate ancestors of our people of interest

        while ancestors_not_yet_processed:
            handle = ancestors_not_yet_processed.pop()

            # One of 2 things can happen here:
            #   1) we already know about this person and he/she is already
            #      in our list
            #   2) this is someone new, and we need to remember him/her
            #
            # In the first case, there isn't anything else to do, so we simply
            # go back to the top and pop the next person off the list.
            #
            # In the second case, we need to add this person to our list, and
            # then go through all of the parents this person has to find more
            # people of interest.

            if handle not in self._people:

                person = self._db.get_person_from_handle(handle)

                # remember this person!
                self._people.add(handle)

                # see if a family exists between this person and someone else
                # we have on our list of people we're going to output -- if
                # there is a family, then remember it for when it comes time
                # to link spouses together
                for family_handle in person.get_family_handle_list():
                    family = self._db.get_family_from_handle(family_handle)
                    if not family:
                        continue
                    spouse_handle = utils.find_spouse(person, family)
                    if spouse_handle:
                        if (spouse_handle in self._people or
                                spouse_handle in ancestors_not_yet_processed):
                            self._families.add(family_handle)

                # if we have a limit on the number of people, and we've
                # reached that limit, then don't attempt to find any
                # more ancestors
                if (self._limitparents and
                        (self._maxparents <
                         len(ancestors_not_yet_processed) + len(self._people))):
                    # get back to the top of the while loop so we can finish
                    # processing the people queued up in the "not yet
                    # processed" list
                    continue

                # queue the parents of the person we're processing
                for family_handle in person.get_parent_family_handle_list():
                    family = self._db.get_family_from_handle(family_handle)

                    father_handle = family.get_father_handle()
                    if father_handle:
                        father = self._db.get_person_from_handle(father_handle)
                        if father:
                            ancestors_not_yet_processed.add(father_handle)
                            self._families.add(family_handle)

                    mother_handle = family.get_mother_handle()
                    if mother_handle:
                        mother = self._db.get_person_from_handle(mother_handle)
                        if mother:
                            ancestors_not_yet_processed.add(mother_handle)
                            self._families.add(family_handle)
Exemple #31
0
    def recurse(self, person_handle, g_level, s_level):
        """traverse the descendants recursively
        until either the end of a line is found,
        or until we reach the maximum number of generations
        or we reach the max number of spouses
        that we want to deal with"""

        if not person_handle:
            return
        if g_level > self.max_generations:
            return  # one generation too many
        if s_level > 0 and s_level == self.max_spouses:
            return
        #if person_handle in self.people_seen: return

        person = self.database.get_person_from_handle(person_handle)
        family_handles = person.get_family_handle_list()
        if s_level == 0:
            val = family_handles[0] if family_handles else None
            self.__this_slevel = s_level
            self._add_person((g_level, s_level), person_handle, val)

            if self.__bold_now == 1:
                self.__bold_now = 0

            if not self.can_recurse():
                self.continue_recursion()
                return

        if s_level == 1:
            tmp_bold = self.__bold_now
            self.__bold_now = 0

        for family_handle in family_handles:
            #Marriage box if the option is there.
            self._add_marriage((g_level, s_level + 1),
                                person_handle, family_handle)

            if not self.can_recurse():
                self.continue_recursion()
                return

            family = self.database.get_family_from_handle(family_handle)

            spouse_handle = ReportUtils.find_spouse(person, family)
            if self.max_spouses > s_level:
                self.__this_slevel = s_level + 1
                self._add_person((g_level, s_level + 1),
                                  spouse_handle, family_handle)

                if not self.can_recurse:
                    self.continue_recursion()
                    return

            mykids = [kid.ref for kid in family.get_child_ref_list()]

            if self.can_recurse():
                for child_ref in mykids:
                    self.recurse(child_ref, g_level + 1, 0)
            else:
                self.continue_recursion()

            if self.max_spouses > s_level:
                #spouse_handle = ReportUtils.find_spouse(person,family)
                self.recurse(spouse_handle, g_level, s_level + 1)

        if s_level == 1:
            self.__bold_now = tmp_bold
Exemple #32
0
    def __init__(self, report, title, surname, ppl_handle_list):
        """
        @param: report          -- The instance of the main report class for
                                   this report
        @param: title           -- Is the title of the web page
        @param: surname         -- The surname to use
        @param: ppl_handle_list -- The list of people for whom we need to create
                                   a page.
        """
        BasePage.__init__(self, report, title)

        # module variables
        showbirth = report.options['showbirth']
        showdeath = report.options['showdeath']
        showpartner = report.options['showpartner']
        showparents = report.options['showparents']

        if surname == '':
            surname = self._("<absent>")

        output_file, sio = self.report.create_file(name_to_md5(surname), "srn")
        self.uplink = True
        (surnamepage, head,
         body) = self.write_header("%s - %s" % (self._("Surname"), surname))
        ldatec = 0

        # begin SurnameDetail division
        with Html("div", class_="content", id="SurnameDetail") as surnamedetail:
            body += surnamedetail

            # section title
            # In case the user choose a format name like "*SURNAME*"
            # We must display this field in upper case. So we use
            # the english format of format_name to find if this is
            # the case.
            name_format = self.report.options['name_format']
            nme_format = _nd.name_formats[name_format][1]
            if "SURNAME" in nme_format:
                surnamed = surname.upper()
            else:
                surnamed = surname
            surnamedetail += Html("h3", html_escape(surnamed), inline=True)

            # feature request 2356: avoid genitive form
            msg = self._("This page contains an index of all the individuals "
                         "in the database with the surname of %s. "
                         "Selecting the person&#8217;s name "
                         "will take you to that person&#8217;s "
                         "individual page.") % html_escape(surname)
            surnamedetail += Html("p", msg, id="description")

            # begin surname table and thead
            with Html("table", class_="infolist primobjlist surname") as table:
                surnamedetail += table
                thead = Html("thead")
                table += thead

                trow = Html("tr")
                thead += trow

                # Name Column
                trow += Html("th", self._("Given Name"), class_="ColumnName",
                             inline=True)

                if showbirth:
                    trow += Html("th", self._("Birth"), class_="ColumnDate",
                                 inline=True)

                if showdeath:
                    trow += Html("th", self._("Death"), class_="ColumnDate",
                                 inline=True)

                if showpartner:
                    trow += Html("th", self._("Partner"),
                                 class_="ColumnPartner",
                                 inline=True)

                if showparents:
                    trow += Html("th", self._("Parents"),
                                 class_="ColumnParents",
                                 inline=True)

                # begin table body
                tbody = Html("tbody")
                table += tbody

                for person_handle in sorted(ppl_handle_list,
                                            key=self.sort_on_given_and_birth):

                    person = self.r_db.get_person_from_handle(person_handle)
                    if person.get_change_time() > ldatec:
                        ldatec = person.get_change_time()
                    trow = Html("tr")
                    tbody += trow

                    # firstname column
                    link = self.new_person_link(person_handle, uplink=True,
                                                person=person,
                                                name_style=_NAME_STYLE_FIRST)
                    trow += Html("td", link, class_="ColumnName")

                    # birth column
                    if showbirth:
                        tcell = Html("td", class_="ColumnBirth", inline=True)
                        trow += tcell

                        birth_date = _find_birth_date(self.r_db, person)
                        if birth_date is not None:
                            if birth_date.fallback:
                                tcell += Html('em',
                                              self.rlocale.get_date(birth_date),
                                              inline=True)
                            else:
                                tcell += self.rlocale.get_date(birth_date)
                        else:
                            tcell += "&nbsp;"

                    # death column
                    if showdeath:
                        tcell = Html("td", class_="ColumnDeath", inline=True)
                        trow += tcell

                        death_date = _find_death_date(self.r_db, person)
                        if death_date is not None:
                            if death_date.fallback:
                                tcell += Html('em',
                                              self.rlocale.get_date(death_date),
                                              inline=True)
                            else:
                                tcell += self.rlocale.get_date(death_date)
                        else:
                            tcell += "&nbsp;"

                    # partner column
                    if showpartner:
                        tcell = Html("td", class_="ColumnPartner")
                        trow += tcell
                        family_list = person.get_family_handle_list()
                        if family_list:
                            fam_count = 0
                            for family_handle in family_list:
                                fam_count += 1
                                family = self.r_db.get_family_from_handle(
                                    family_handle)
                                partner_handle = utils.find_spouse(
                                    person, family)
                                if partner_handle:
                                    link = self.new_person_link(partner_handle,
                                                                uplink=True)
                                    if fam_count < len(family_list):
                                        if isinstance(link, Html):
                                            link.inside += ","
                                        else:
                                            link += ','
                                    tcell += link
                        else:
                            tcell += "&nbsp;"

                    # parents column
                    if showparents:
                        parent_hdl_list = person.get_parent_family_handle_list()
                        if parent_hdl_list:
                            parent_hdl = parent_hdl_list[0]
                            fam = self.r_db.get_family_from_handle(parent_hdl)
                            f_id = fam.get_father_handle()
                            m_id = fam.get_mother_handle()
                            mother = father = None
                            if f_id:
                                father = self.r_db.get_person_from_handle(f_id)
                                if father:
                                    father_name = self.get_name(father)
                            if m_id:
                                mother = self.r_db.get_person_from_handle(m_id)
                                if mother:
                                    mother_name = self.get_name(mother)
                            if mother and father:
                                tcell = Html("span", father_name,
                                             class_="father fatherNmother")
                                tcell += Html("span", mother_name,
                                              class_="mother")
                            elif mother:
                                tcell = Html("span", mother_name,
                                             class_="mother", inline=True)
                            elif father:
                                tcell = Html("span", father_name,
                                             class_="father", inline=True)
                            samerow = False
                        else:
                            tcell = "&nbsp;" # pylint: disable=R0204
                            samerow = True
                        trow += Html("td", tcell,
                                     class_="ColumnParents", inline=samerow)

        # add clearline for proper styling
        # add footer section
        footer = self.write_footer(ldatec)
        body += (FULLCLEAR, footer)

        # send page out for processing
        # and close the file
        self.xhtml_writer(surnamepage, output_file, sio, ldatec)
Exemple #33
0
    def findRelatedPeople(self) :

        self.progress.set_pass(
            # translators: leave all/any {...} untranslated
            #TRANS: No singular form is needed.
            ngettext("Finding relationships between {number_of} person",
                     "Finding relationships between {number_of} people",
                     self.numberOfPeopleInDatabase
                    ).format(number_of=self.numberOfPeopleInDatabase),
            self.numberOfPeopleInDatabase)

        # as long as we have people we haven't processed yet, keep looping
        while len(self.handlesOfPeopleToBeProcessed) > 0:
            handle = self.handlesOfPeopleToBeProcessed.pop()

### DEBUG DEBUG DEBUG
#            if len(self.handlesOfPeopleAlreadyProcessed) > 50:
#                break
###

            # see if we've already processed this person
            if handle in self.handlesOfPeopleAlreadyProcessed:
                continue

            person = self.db.get_person_from_handle(handle)

            # if we get here, then we're dealing with someone new
            self.progress.step()

            # remember that we've now seen this person
            self.handlesOfPeopleAlreadyProcessed.add(handle)

            # we have 4 things to do:  find (1) spouses, (2) parents, siblings(3), and (4) children

            # step 1 -- spouses
            for familyHandle in person.get_family_handle_list():
                family = self.db.get_family_from_handle(familyHandle)
                spouseHandle = utils.find_spouse(person, family)
                if spouseHandle and \
                  spouseHandle not in self.handlesOfPeopleAlreadyProcessed:
                    self.handlesOfPeopleToBeProcessed.add(spouseHandle)

            # step 2 -- parents
            for familyHandle in person.get_parent_family_handle_list():
                family = self.db.get_family_from_handle(familyHandle)
                fatherHandle = family.get_father_handle()
                motherHandle = family.get_mother_handle()
                if fatherHandle and \
                  fatherHandle not in self.handlesOfPeopleAlreadyProcessed:
                    self.handlesOfPeopleToBeProcessed.add(fatherHandle)
                if motherHandle and \
                  motherHandle not in self.handlesOfPeopleAlreadyProcessed:
                    self.handlesOfPeopleToBeProcessed.add(motherHandle)

            # step 3 -- siblings
            for familyHandle in person.get_parent_family_handle_list():
                family = self.db.get_family_from_handle(familyHandle)
                for childRef in family.get_child_ref_list():
                    childHandle = childRef.ref
                    if childHandle and \
                      childHandle not in self.handlesOfPeopleAlreadyProcessed:
                        self.handlesOfPeopleToBeProcessed.add(childHandle)

            # step 4 -- children
            for familyHandle in person.get_family_handle_list():
                family = self.db.get_family_from_handle(familyHandle)
                for childRef in family.get_child_ref_list():
                    childHandle = childRef.ref
                    if childHandle and \
                      childHandle not in self.handlesOfPeopleAlreadyProcessed:
                        self.handlesOfPeopleToBeProcessed.add(childHandle)
Exemple #34
0
    def findRelatedPeople(self):

        self.progress.set_pass(
            # translators: leave all/any {...} untranslated
            #TRANS: No singular form is needed.
            ngettext("Finding relationships between {number_of} person",
                     "Finding relationships between {number_of} people",
                     self.numberOfPeopleInDatabase).format(
                         number_of=self.numberOfPeopleInDatabase),
            self.numberOfPeopleInDatabase)

        # as long as we have people we haven't processed yet, keep looping
        while len(self.handlesOfPeopleToBeProcessed) > 0:
            handle = self.handlesOfPeopleToBeProcessed.pop()

            ### DEBUG DEBUG DEBUG
            #            if len(self.handlesOfPeopleAlreadyProcessed) > 50:
            #                break
            ###

            # see if we've already processed this person
            if handle in self.handlesOfPeopleAlreadyProcessed:
                continue

            person = self.db.get_person_from_handle(handle)

            # if we get here, then we're dealing with someone new
            self.progress.step()

            # remember that we've now seen this person
            self.handlesOfPeopleAlreadyProcessed.add(handle)

            # we have 4 things to do:  find (1) spouses, (2) parents, siblings(3), and (4) children

            # step 1 -- spouses
            for familyHandle in person.get_family_handle_list():
                family = self.db.get_family_from_handle(familyHandle)
                spouseHandle = utils.find_spouse(person, family)
                if spouseHandle and \
                  spouseHandle not in self.handlesOfPeopleAlreadyProcessed:
                    self.handlesOfPeopleToBeProcessed.add(spouseHandle)

            # step 2 -- parents
            for familyHandle in person.get_parent_family_handle_list():
                family = self.db.get_family_from_handle(familyHandle)
                fatherHandle = family.get_father_handle()
                motherHandle = family.get_mother_handle()
                if fatherHandle and \
                  fatherHandle not in self.handlesOfPeopleAlreadyProcessed:
                    self.handlesOfPeopleToBeProcessed.add(fatherHandle)
                if motherHandle and \
                  motherHandle not in self.handlesOfPeopleAlreadyProcessed:
                    self.handlesOfPeopleToBeProcessed.add(motherHandle)

            # step 3 -- siblings
            for familyHandle in person.get_parent_family_handle_list():
                family = self.db.get_family_from_handle(familyHandle)
                for childRef in family.get_child_ref_list():
                    childHandle = childRef.ref
                    if childHandle and \
                      childHandle not in self.handlesOfPeopleAlreadyProcessed:
                        self.handlesOfPeopleToBeProcessed.add(childHandle)

            # step 4 -- children
            for familyHandle in person.get_family_handle_list():
                family = self.db.get_family_from_handle(familyHandle)
                for childRef in family.get_child_ref_list():
                    childHandle = childRef.ref
                    if childHandle and \
                      childHandle not in self.handlesOfPeopleAlreadyProcessed:
                        self.handlesOfPeopleToBeProcessed.add(childHandle)
Exemple #35
0
    def recurse(self, person_handle, g_level, s_level):
        """traverse the descendants recursively
        until either the end of a line is found,
        or until we reach the maximum number of generations
        or we reach the max number of spouses
        that we want to deal with"""

        if not person_handle:
            return
        if g_level > self.max_generations:
            return  # one generation too many
        if s_level > 0 and s_level == self.max_spouses:
            return
        #if person_handle in self.people_seen: return

        person = self.database.get_person_from_handle(person_handle)
        family_handles = person.get_family_handle_list()
        if s_level == 0:
            val = family_handles[0] if family_handles else None
            self.__this_slevel = s_level
            self._add_person((g_level, s_level), person_handle, val)

            if self.__bold_now == 1:
                self.__bold_now = 0

            if not self.can_recurse():
                self.continue_recursion()
                return

        if s_level == 1:
            tmp_bold = self.__bold_now
            self.__bold_now = 0

        for family_handle in family_handles:
            #Marriage box if the option is there.
            self._add_marriage((g_level, s_level + 1),
                                person_handle, family_handle)

            if not self.can_recurse():
                self.continue_recursion()
                return

            family = self.database.get_family_from_handle(family_handle)

            spouse_handle = utils.find_spouse(person, family)
            if self.max_spouses > s_level:
                self.__this_slevel = s_level + 1
                self._add_person((g_level, s_level + 1),
                                  spouse_handle, family_handle)

                if not self.can_recurse:
                    self.continue_recursion()
                    return

            mykids = [kid.ref for kid in family.get_child_ref_list()]

            if self.can_recurse():
                for child_ref in mykids:
                    self.recurse(child_ref, g_level + 1, 0)
            else:
                self.continue_recursion()

            if self.max_spouses > s_level:
                #spouse_handle = utils.find_spouse(person,family)
                self.recurse(spouse_handle, g_level, s_level + 1)

        if s_level == 1:
            self.__bold_now = tmp_bold
Exemple #36
0
    def remove_uninteresting_parents(self):
        """ remove any uninteresting parents """
        # start with all the people we've already identified
        unprocessed_parents = set(self._people)

        while len(unprocessed_parents) > 0:
            handle = unprocessed_parents.pop()
            person = self._db.get_person_from_handle(handle)
            if not person:
                continue

            # There are a few things we're going to need,
            # so look it all up right now; such as:
            # - who is the child?
            # - how many children?
            # - parents?
            # - spouse?
            # - is a person of interest?
            # - spouse of a person of interest?
            # - same surname as a person of interest?
            # - spouse has the same surname as a person of interest?

            child_handle = None
            child_count = 0
            spouse_handle = None
            spouse_count = 0
            father_handle = None
            mother_handle = None
            spouse_father_handle = None
            spouse_mother_handle = None
            spouse_surname = ""
            surname = person.get_primary_name().get_surname()
            surname = surname.encode('iso-8859-1', 'xmlcharrefreplace')

            # first we get the person's father and mother
            for family_handle in person.get_parent_family_handle_list():
                family = self._db.get_family_from_handle(family_handle)
                handle = family.get_father_handle()
                if handle in self._people:
                    father_handle = handle
                handle = family.get_mother_handle()
                if handle in self._people:
                    mother_handle = handle

            # now see how many spouses this person has
            for family_handle in person.get_family_handle_list():
                family = self._db.get_family_from_handle(family_handle)
                handle = utils.find_spouse(person, family)
                if handle in self._people:
                    spouse_count += 1
                    spouse = self._db.get_person_from_handle(handle)
                    spouse_handle = handle
                    spouse_surname = spouse.get_primary_name().get_surname()
                    spouse_surname = spouse_surname.encode(
                        'iso-8859-1', 'xmlcharrefreplace')

                    # see if the spouse has parents
                    if not spouse_father_handle and not spouse_mother_handle:
                        for family_handle in \
                                spouse.get_parent_family_handle_list():
                            family = self._db.get_family_from_handle(
                                family_handle)
                            handle = family.get_father_handle()
                            if handle in self._people:
                                spouse_father_handle = handle
                            handle = family.get_mother_handle()
                            if handle in self._people:
                                spouse_mother_handle = handle

            # get the number of children that we think might be interesting
            for family_handle in person.get_family_handle_list():
                family = self._db.get_family_from_handle(family_handle)
                for child_ref in family.get_child_ref_list():
                    if child_ref.ref in self._people:
                        child_count += 1
                        child_handle = child_ref.ref

            # we now have everything we need -- start looking for reasons
            # why this is a person we need to keep in our list, and loop
            # back to the top as soon as a reason is discovered

            # if this person has many children of interest, then we
            # automatically keep this person
            if child_count > 1:
                continue

            # if this person has many spouses of interest, then we
            # automatically keep this person
            if spouse_count > 1:
                continue

            # if this person has parents, then we automatically keep
            # this person
            if father_handle is not None or mother_handle is not None:
                continue

            # if the spouse has parents, then we automatically keep
            # this person
            if (spouse_father_handle is not None or
                    spouse_mother_handle is not None):
                continue

            # if this is a person of interest, then we automatically keep
            if person.get_handle() in self._interest_set:
                continue

            # if the spouse is a person of interest, then we keep
            if spouse_handle in self._interest_set:
                continue

            # if the surname (or the spouse's surname) matches a person
            # of interest, then we automatically keep this person
            keep_this_person = False
            for person_of_interest_handle in self._interest_set:
                person_of_interest = self._db.get_person_from_handle(
                    person_of_interest_handle)
                surname_of_interest = person_of_interest.get_primary_name()
                surname_of_interest = surname_of_interest.get_surname().encode(
                    'iso-8859-1', 'xmlcharrefreplace')
                if (surname_of_interest == surname or
                        surname_of_interest == spouse_surname):
                    keep_this_person = True
                    break

            if keep_this_person:
                continue

            # if we have a special colour to use for this person,
            # then we automatically keep this person
            if surname in self._surnamecolors:
                continue

            # if we have a special colour to use for the spouse,
            # then we automatically keep this person
            if spouse_surname in self._surnamecolors:
                continue

            # took us a while,
            # but if we get here then we can remove this person
            self._deleted_people += 1
            self._people.remove(person.get_handle())

            # we can also remove any families to which this person belonged
            for family_handle in person.get_family_handle_list():
                if family_handle in self._families:
                    self._deleted_families += 1
                    self._families.remove(family_handle)

            # if we have a spouse, then ensure we queue up the spouse
            if spouse_handle:
                if spouse_handle not in unprocessed_parents:
                    unprocessed_parents.add(spouse_handle)

            # if we have a child, then ensure we queue up the child
            if child_handle:
                if child_handle not in unprocessed_parents:
                    unprocessed_parents.add(child_handle)
Exemple #37
0
    def __process_person(self, person, rank, ahnentafel, person_key):
        """
        Recursively build the Family Sheet for this person and all children
        with spouses.

        @param person: Person object for the key person of the Family Sheet.
        @param rank: Numerical distance between the central person in the
            database and the person in the parameter (the number of births
            needed to connect them).
        @param ahnentafel: "Ahnentafel" number of the common ancestor of the
            central person in the database and the person in the parameter,
            seen from the side of the central person in the database.
        @param person_key: Family Sheet key to be printed on the top right of
            the corner.
        """

        # List of (person, rank, ahnentafel, person_key) tuples for persons to
        # process recursively after this one.
        more_sheets = []

        # Numbering of spouses (integer, but printed in roman numbers).
        spouse_index = 0

        # Numbering of children (integer, but printed as lowercase letters).
        child_index = 0

        # Source references to print as footnotes.
        self.__citation_index = 0
        self.__citations = []

        # Notes to print as footnotes.
        self.__note_index = 0
        self.__notes = []

        # --- Now let the party begin! ---

        head_name = str(
            _Name_get_styled(person.get_primary_name(),
                             _Name_CALLNAME_DONTUSE))
        mark2 = docgen.IndexMark(head_name, docgen.INDEX_TYPE_TOC, 2)

        self.doc.start_paragraph('FSR-Key')
        self.doc.write_text(person_key, mark2)
        self.doc.end_paragraph()

        self.doc.start_table(None, 'FSR-Table')

        # Main person
        self.doc.start_row()
        self.doc.start_cell('FSR-HeadCell', 3)
        self.__dump_person(person, False, None)
        self.doc.end_cell()
        self.doc.end_row()

        # Spouses
        for family_handle in person.get_family_handle_list():
            family = self.database.get_family_from_handle(family_handle)

            spouse_index += 1

            spouse_handle = utils.find_spouse(person, family)
            if spouse_handle:
                spouse = self.database.get_person_from_handle(spouse_handle)
            else:
                spouse = None

            # Determine relationship between the center person and the spouse.
            # If the spouse has a closer blood relationship than the current
            # person, we refer to the Family Sheet of the spouse instead of
            # printing the child list, because all children are more closely
            # related to the center person via the spouse than via the current
            # person. The same happens if the relationship is on the same
            # level, but the relationship via the spouse goes via a common
            # ancestor with a lower Ahnentafel numbering (i.e. a relationship
            # stronger father-sided). In these cases, refer_spouse will be set
            # to True.
            (spouse_rank, spouse_at, spouse_key) = \
                    self.__calc_person_key(spouse)
            if self.recurse != FamilySheetOptions.RECURSE_ALL:
                refer_spouse = (spouse_rank != -1 and \
                        (spouse_rank < rank or
                            (spouse_rank == rank and spouse_at < ahnentafel)))
            else:
                refer_spouse = False

            self.doc.start_row()

            self.doc.start_cell('FSR-NumberCell', 1)
            self.doc.start_paragraph('FSR-Number')
            self.doc.write_text(utils.roman(spouse_index))
            self.doc.end_paragraph()
            self.doc.end_cell()

            self.doc.start_cell('FSR-DataCell', 2)
            self.__dump_family(family, spouse)
            if refer_spouse:
                self.doc.start_paragraph('FSR-Normal')
                self.doc.write_text(_("\u2192 %s") % spouse_key)
                self.doc.end_paragraph()
            self.doc.end_cell()

            self.doc.end_row()

            if refer_spouse:
                # Spouse with closer relationship than current person? Don't
                # print children on this Family Sheet (but count them for the
                # numbering).
                child_index += len(family.get_child_ref_list())
                continue

            # Children
            for child_ref in family.get_child_ref_list():
                child = self.database.get_person_from_handle(child_ref.ref)
                child_letter = string.ascii_lowercase[child_index]

                self.doc.start_row()

                self.doc.start_cell('FSR-EmptyCell', 1)
                self.doc.end_cell()

                self.doc.start_cell('FSR-NumberCell', 1)
                self.doc.start_paragraph('FSR-Number')
                self.doc.write_text(child_letter)
                self.doc.end_paragraph()
                self.doc.end_cell()

                self.doc.start_cell('FSR-DataCell', 1)

                has_spouses = (child.get_family_handle_list() != [])

                self.__dump_person(child, has_spouses, child_ref)

                if has_spouses:
                    # We have to recalculate the key for this person, it could
                    # be closer related if it is a direct ancestor of the
                    # central person or one of its spouses.
                    (child_rank, child_at, child_key) = \
                            self.__calc_person_key(child)

                    self.doc.start_paragraph('FSR-Normal')
                    self.doc.write_text(_("\u2192 %s") % child_key)
                    self.doc.end_paragraph()

                    # We recursively print this child *only* if its
                    # relationship with the central person is closest via the
                    # current person. This way, we avoid that a person is
                    # printed recursively from more than one of its ancestors.
                    if child_key == person_key + child_letter or \
                            self.recurse == FamilySheetOptions.RECURSE_ALL:
                        more_sheets.append(
                            (child, child_rank, child_at, child_key))

                self.doc.end_cell()

                self.doc.end_row()

                child_index += 1

        self.doc.start_row()
        self.doc.start_cell('FSR-FootCell', 3)
        self.doc.end_cell()
        self.doc.end_row()

        self.doc.end_table()

        self.__dump_sources()
        self.__dump_notes()

        # Now print the sheets for the children.
        if self.recurse != FamilySheetOptions.RECURSE_NONE:
            for (child, child_rank, child_at, child_key) in more_sheets:
                self.doc.page_break()
                self.__process_person(child, child_rank, child_at, child_key)
Exemple #38
0
    def display(self, tobj, person):
        """Fill text buffer tobj with detailed info on person person."""
        normal = tobj.create_tag()
        normal.set_property("indent", 10)
        normal.set_property("pixels-above-lines", 1)
        normal.set_property("pixels-below-lines", 1)
        indent = tobj.create_tag()
        indent.set_property("indent", 30)
        indent.set_property("pixels-above-lines", 1)
        indent.set_property("pixels-below-lines", 1)
        title = tobj.create_tag()
        title.set_property("weight", Pango.Weight.BOLD)
        title.set_property("scale", 1.2)
        self.add(tobj, title, name_displayer.display(person))
        self.add(tobj, normal, "%s:\t%s" % (_("ID"), person.get_gramps_id()))
        self.add(tobj, normal, "%s:\t%s" % (_("Gender"), sex[person.get_gender()]))
        bref = person.get_birth_ref()
        if bref:
            self.add(tobj, normal, "%s:\t%s" % (_("Birth"), self.get_event_info(bref.ref)))
        dref = person.get_death_ref()
        if dref:
            self.add(tobj, normal, "%s:\t%s" % (_("Death"), self.get_event_info(dref.ref)))

        nlist = person.get_alternate_names()
        if len(nlist) > 0:
            self.add(tobj, title, _("Alternate Names"))
            for name in nlist:
                self.add(tobj, normal, name_displayer.display_name(name))

        elist = person.get_event_ref_list()
        if len(elist) > 0:
            self.add(tobj, title, _("Events"))
            for event_ref in person.get_event_ref_list():
                event_handle = event_ref.ref
                role = event_ref.get_role()
                name = str(self.database.get_event_from_handle(event_handle).get_type())
                if role.is_primary():
                    self.add(tobj, normal, "%s:\t%s" % (name, self.get_event_info(event_handle)))
                else:
                    self.add(tobj, normal, "%s (%s):\t%s" % (name, role, self.get_event_info(event_handle)))
        plist = person.get_parent_family_handle_list()

        if len(plist) > 0:
            self.add(tobj, title, _("Parents"))
            for fid in person.get_parent_family_handle_list():
                (fname, mname, gid) = self.get_parent_info(fid)
                self.add(tobj, normal, "%s:\t%s" % (_("Family ID"), gid))
                if fname:
                    self.add(tobj, indent, "%s:\t%s" % (_("Father"), fname))
                if mname:
                    self.add(tobj, indent, "%s:\t%s" % (_("Mother"), mname))
        else:
            self.add(tobj, normal, _("No parents found"))

        self.add(tobj, title, _("Spouses"))
        slist = person.get_family_handle_list()
        if len(slist) > 0:
            for fid in slist:
                (fname, mname, pid) = self.get_parent_info(fid)
                family = self.database.get_family_from_handle(fid)
                self.add(tobj, normal, "%s:\t%s" % (_("Family ID"), pid))
                spouse_id = ReportUtils.find_spouse(person, family)
                if spouse_id:
                    spouse = self.database.get_person_from_handle(spouse_id)
                    self.add(tobj, indent, "%s:\t%s" % (_("Spouse"), name_of(spouse)))
                relstr = str(family.get_relationship())
                self.add(tobj, indent, "%s:\t%s" % (_("Type"), relstr))
                event = ReportUtils.find_marriage(self.database, family)
                if event:
                    self.add(tobj, indent, "%s:\t%s" % (_("Marriage"), self.get_event_info(event.get_handle())))
                for child_ref in family.get_child_ref_list():
                    child = self.database.get_person_from_handle(child_ref.ref)
                    self.add(tobj, indent, "%s:\t%s" % (_("Child"), name_of(child)))
        else:
            self.add(tobj, normal, _("No spouses or children found"))

        alist = person.get_address_list()
        if len(alist) > 0:
            self.add(tobj, title, _("Addresses"))
            for addr in alist:
                location = ", ".join(
                    [
                        addr.get_street(),
                        addr.get_city(),
                        addr.get_state(),
                        addr.get_country(),
                        addr.get_postal_code(),
                        addr.get_phone(),
                    ]
                )
                self.add(tobj, normal, location.strip())
Exemple #39
0
    def __calc_person_key(self, person):
        """
        The person key is a unique identifier that is built from the
        relationship to the default person. It consists of the "Ahnentafel"
        number of the common ancestor of the person with the default person,
        and then a letter representing the child number for each generation
        from the common ancestor to the person.

        If more than one common ancestor exists, the common ancestor with the
        lowest "Ahnentafel" number has precedence.

        For example, the second child of the third child of the father of the
        mother of the central person gets the person key "6cb".
        """

        relationship = get_relationship_calculator()

        default_person = self.database.get_default_person()

        # No home person set.
        if default_person is None:
            return (-1, 0, "")

        # First try direct relationship.
        spousestring = ""
        info, msg = relationship.get_relationship_distance_new(self.database,
                                                               default_person,
                                                               person,
                                                               all_dist=True)
        info = relationship.collapse_relations(info)[0]
        (rank, ancestor_handle, default_rel, default_fam, person_rel,
         person_fam) = info

        # Then try relationship to any spouse.
        if rank == -1:
            index = 0
            for family_handle in default_person.get_family_handle_list():
                index += 1
                family = self.database.get_family_from_handle(family_handle)
                spouse_handle = utils.find_spouse(default_person, family)
                spouse = self.database.get_person_from_handle(spouse_handle)
                info, msg = relationship.get_relationship_distance_new(
                    self.database, spouse, person, all_dist=True)
                info = relationship.collapse_relations(info)[0]
                (rank, ancestor_handle, default_rel, default_fam, person_rel,
                 person_fam) = info
                if rank != -1:
                    spousestring = utils.roman(index)
                    break
            # If no relationship found at all, exit here.
            if rank == -1:
                return (rank, 0, "")

        # Calculate Ahnentafel number of common ancestor.
        ahnentafel = 1
        for rel in default_rel:
            ahnentafel *= 2
            if rel in (relationship.REL_MOTHER,
                       relationship.REL_MOTHER_NOTBIRTH):
                ahnentafel += 1

        # Find out child letters.
        child = person
        childletters = ""
        for rel in person_rel:
            family_handle = child.get_main_parents_family_handle()
            family = self.database.get_family_from_handle(family_handle)
            if rel in (relationship.REL_MOTHER,
                       relationship.REL_MOTHER_NOTBIRTH):
                parent_handle = family.get_mother_handle()
            else:
                parent_handle = family.get_father_handle()
            parent = self.database.get_person_from_handle(parent_handle)
            # Count *all* children from this parent
            childletter = "?"
            index = 0
            for family_handle in parent.get_family_handle_list():
                family = self.database.get_family_from_handle(family_handle)
                for child_ref in family.get_child_ref_list():
                    if child_ref.ref == child.get_handle():
                        childletter = string.ascii_lowercase[index]
                        break
                    index += 1
                else:
                    continue
                break
            childletters = childletter + childletters
            child = parent

        return (rank, ahnentafel,
                "%s%s%s" % (spousestring, ahnentafel, childletters))