Пример #1
0
 def link_place(self, menu, event, lat, lon):
     """
     Link an existing place using longitude and latitude of location centered
     on the map
     If we have a place history, we must show all places to avoid an empty
     place selection in the PlaceSelection.
     """
     if self.uistate.get_active('Place'):
         self._createmap(None)
     selector = SelectPlace(self.dbstate, self.uistate, [])
     place = selector.run()
     if place:
         parent_list = place.get_placeref_list()
         if len(parent_list) > 0:
             parent = parent_list[0].ref
         else:
             parent = None
         places_handle = self.dbstate.db.iter_place_handles()
         nb_places = 0
         gids = ""
         place_title = _pd.display(self.dbstate.db, place)
         for place_hdl in places_handle:
             plce = self.dbstate.db.get_place_from_handle(place_hdl)
             plce_title = _pd.display(self.dbstate.db, plce)
             if plce_title == place_title:
                 nb_places += 1
                 if gids == "":
                     gids = plce.gramps_id
                 else:
                     # TODO for Arabic, should the next comma be translated?
                     gids = gids + ", " + plce.gramps_id
         if nb_places > 1:
             from gramps.gui.dialog import WarningDialog
             WarningDialog(
                   _('You have at least two places with the same title.'),
                   _("The title of the places is:\n%(title)s\n"
                     "The following places are similar: %(gid)s\n"
                     "You should eiher rename the places or merge them.\n\n"
                     "%(bold_start)s"
                     "I can't proceed with your request"
                     "%(bold_end)s.\n") % {
                         'bold_start' : '<b>',
                         'bold_end'   : '</b>',
                         'title': '<b>' + place_title + '</b>',
                         'gid': gids},
                    parent=self.uistate.window
                   )
         else:
             self.mark = [None, None, None, None, None, None, None,
                          None, None, place.gramps_id, None, None]
             self.select_fct = PlaceSelection(self.uistate,
                                              self.dbstate,
                                              self.osm,
                                              self.selection_layer,
                                              self.place_list,
                                              lat,
                                              lon,
                                              self.__edit_place,
                                              parent)
Пример #2
0
    def match(self, lat, lon):
        """
        coordinates matching.
        """
        rds = float(self.radius)
        self.places = []

        # place
        for entry in self.place_list:
            if (math.hypot(lat-float(entry[3]),
                           lon-float(entry[4])) <= rds) == True:
                # Do we already have this place ? avoid duplicates
                (country, state, county,
                 place, other) = self.get_location(entry[9])
                if not [country, state, county, place, other] in self.places:
                    self.places.append([country, state, county, place, other])
        self.warning = False
        for place in self.dbstate.db.iter_places():
            latn = place.get_latitude()
            lonn = place.get_longitude()
            if latn and lonn:
                latn, ignore = conv_lat_lon(latn, "0", "D.D8")
                if not latn:
                    if not self.warning:
                        self.close()
                    warn1 = _("you have a wrong latitude for:")
                    warn2 = _pd.display(self.dbstate.db, place) + "\n\n<b>"
                    warn2 += _("Please, correct this before linking") + "</b>"
                    WarningDialog(warn1, warn2, parent=self.uistate.window)
                    self.warning = True
                    continue
                ignore, lonn = conv_lat_lon("0", lonn, "D.D8")
                if not lonn:
                    if not self.warning:
                        self.close()
                    warn1 = _("you have a wrong longitude for:") + "\n"
                    warn2 = _pd.display(self.dbstate.db, place) + "\n\n<b>"
                    warn2 += _("Please, correct this before linking") + "</b>"
                    WarningDialog(warn1, warn2, parent=self.uistate.window)
                    self.warning = True
                    continue
                if (math.hypot(lat-float(latn),
                               lon-float(lonn)) <= rds) == True:
                    (country, state, county,
                     place, other) = self.get_location(place.get_gramps_id())
                    if not [country, state, county,
                            place, other] in self.places:
                        self.places.append([country, state, county,
                                            place, other])
Пример #3
0
 def main(self):
     self.reset_main()
     if self.gui.get_child().get_child() == self.results_win:
         self.gui.get_child().remove(self.results_win)
         self.gui.get_child().add(self.mainwin)
     active_handle = self.get_active('Place')
     self.top.get_object("edit_but").set_sensitive(False)
     self.top.get_object("find_but").set_sensitive(False)
     self.top.get_object("title_entry").set_sensitive(False)
     if active_handle:
         self.place = self.dbstate.db.get_place_from_handle(active_handle)
         self.mainwin.hide()
         if self.place:
             self.set_has_data(True)
             title = _pd.display(self.dbstate.db, self.place)
             item = self.top.get_object("title_entry")
             item.set_text(title)
             self.top.get_object("edit_but").set_sensitive(True)
             self.top.get_object("find_but").set_sensitive(True)
             self.top.get_object("title_entry").set_sensitive(True)
         else:
             self.set_has_data(False)
         self.mainwin.show()
     else:
         self.set_has_data(False)
Пример #4
0
 def on_find_clicked(self, dummy):
     """ find a matching place.  First try in the db, then try in the
     GeoNames. """
     self.res_store.clear()
     self.top.get_object("select_but").set_sensitive(False)
     if self.geo_stage:
         self.search_geo()
     else:
         self.geo_stage = True
         item = self.top.get_object("title_entry")
         title = item.get_text()
         self.places = self.lookup_places_by_name(title)
         for index, place in enumerate(self.places):
             # make sure the place found isn't self, or a place
             # enclosed by the working place
             if place.handle != self.place.handle and not located_in(
                     self.dbstate.db, place.handle, self.place.handle):
                 title = _pd.display(self.dbstate.db, place)
                 self.res_store.append(row=(index, title,
                                            str(place.place_type)))
         if len(self.res_store) > 0:
             self.res_lbl.set_text(_('%s\nLocal\nMatches') %
                                   len(self.res_store))
             self.find_but.set_label(_("Find GeoNames"))
         else:
             self.search_geo()
Пример #5
0
 def _create_one_place(self, place):
     """
     Create one entry for one place with a lat/lon.
     """
     if place is None:
         return
     if self.nbplaces >= self._config.get("geography.max_places"):
         return
     descr = _pd.display(self.dbstate.db, place)
     longitude = place.get_longitude()
     latitude = place.get_latitude()
     latitude, longitude = conv_lat_lon(latitude, longitude, "D.D8")
     self.load_kml_files(place)
     # place.get_longitude and place.get_latitude return
     # one string. We have coordinates when the two values
     # contains non null string.
     if longitude and latitude:
         colour = self.plc_color[int(place.get_type())+1]
         if int(place.get_type()) == PlaceType.CUSTOM:
             try:
                 colour = (str(place.get_type()),
                           self.plc_custom_color[str(place.get_type())])
             except:
                 colour = self.plc_color[PlaceType.CUSTOM + 1]
         self._append_to_places_list(descr, None, "",
                                     latitude, longitude,
                                     None, None,
                                     EventType.UNKNOWN,
                                     None, # person.gramps_id
                                     place.gramps_id,
                                     None, # event.gramps_id
                                     None, # family.gramps_id
                                     color=colour
                                    )
Пример #6
0
    def __write_place(self, handle, place_nbr):
        """
        This procedure writes out the details of a single place
        """
        place = self.database.get_place_from_handle(handle)
        location = get_main_location(self.database, place)

        place_details = [
            self._("Gramps ID: %s ") % place.get_gramps_id(),
            self._("Street: %s ") % location.get(PlaceType.STREET, ''),
            self._("Parish: %s ") % location.get(PlaceType.PARISH, ''),
            self._("Locality: %s ") % location.get(PlaceType.LOCALITY, ''),
            self._("City: %s ") % location.get(PlaceType.CITY, ''),
            self._("County: %s ") % location.get(PlaceType.COUNTY, ''),
            self._("State: %s") % location.get(PlaceType.STATE, ''),
            self._("Country: %s ") % location.get(PlaceType.COUNTRY, '')]
        self.doc.start_paragraph("PLC-PlaceTitle")
        place_title = place_displayer.display(self.database, place)
        self.doc.write_text(("%(nbr)s. %(place)s") %
                                {'nbr' : place_nbr,
                                 'place' : place_title})
        self.doc.end_paragraph()

        for item in place_details:
            self.doc.start_paragraph("PLC-PlaceDetails")
            self.doc.write_text(item)
            self.doc.end_paragraph()
Пример #7
0
 def name_from_gramps_id(self, gramps_id):
     if self.namespace == 'Person':
         person = self.db.get_person_from_gramps_id(gramps_id)
         name = _nd.display_name(person.get_primary_name())
     elif self.namespace == 'Family':
         family = self.db.get_family_from_gramps_id(gramps_id)
         name = family_name(family, self.db)
     elif self.namespace == 'Event':
         event = self.db.get_event_from_gramps_id(gramps_id)
         name = str(event.get_type)
     elif self.namespace == 'Place':
         place = self.db.get_place_from_gramps_id(gramps_id)
         name = _pd.display(self.db, place)
     elif self.namespace == 'Source':
         source = self.db.get_source_from_gramps_id(gramps_id)
         name = source.get_title()
     elif self.namespace == 'Citation':
         citation = self.db.get_citation_from_gramps_id(gramps_id)
         name = citation.get_page()
     elif self.namespace == 'Media':
         obj = self.db.get_media_from_gramps_id(gramps_id)
         name = obj.get_path()
     elif self.namespace == 'Repository':
         repo = self.db.get_repository_from_gramps_id(gramps_id)
         name = repo.get_name()
     elif self.namespace == 'Note':
         note = self.db.get_note_from_gramps_id(gramps_id)
         name = note.get()
     return name
Пример #8
0
    def calc_url(self):
        """ Determine the url to use
            Logic: use lat lon if present
                   otherwise use city and country if present
                   otherwise use description of the place
        """
        place = self._get_first_place()[0]
        latitude, longitude = self._lat_lon(place)
        if longitude and latitude:
            self.url = "http://www.openstreetmap.org/" \
                        "?lat=%s&lon=%s&zoom=15" % (latitude, longitude)

            return

        location = get_main_location(self.database, place)
        city = location.get(PlaceType.CITY)
        country = location.get(PlaceType.COUNTRY)
        if city and country:
            self.url = "http://nominatim.openstreetmap.org/"\
                        "search.php?q=%s%%2C%s" % (city, country)
            return

        titledescr = place_displayer.display(self.database, place)
        self.url = "http://nominatim.openstreetmap.org/"\
                        "search.php?q=%s" % '+'.join(titledescr.split())
Пример #9
0
 def _create_one_place(self,place):
     """
     Create one entry for one place with a lat/lon.
     """
     if place is None:
         return
     if self.nbplaces >= self._config.get("geography.max_places"):
         return
     descr = _pd.display(self.dbstate.db, place)
     longitude = place.get_longitude()
     latitude = place.get_latitude()
     latitude, longitude = conv_lat_lon(latitude, longitude, "D.D8")
     # place.get_longitude and place.get_latitude return
     # one string. We have coordinates when the two values
     # contains non null string.
     if ( longitude and latitude ):
         self._append_to_places_list(descr, None, "",
                                     latitude, longitude,
                                     None, None,
                                     EventType.UNKNOWN,
                                     None, # person.gramps_id
                                     place.gramps_id,
                                     None, # event.gramps_id
                                     None # family.gramps_id
                                    )
Пример #10
0
 def get_menu_title(self):
     if self.obj and self.obj.get_handle():
         title = place_displayer.display(self.db, self.obj)
         dialog_title = _('Place: %s')  % title
     else:
         dialog_title = _('New Place')
     return dialog_title
Пример #11
0
    def __write_place(self, handle, place_nbr):
        """
        This procedure writes out the details of a single place
        """
        place = self._db.get_place_from_handle(handle)

        place_details = [self._("Gramps ID: %s ") % place.get_gramps_id()]
        for level in get_location_list(self._db, place):
            # translators: needed for French, ignore otherwise
            place_details.append(self._("%(str1)s: %(str2)s"
                                       ) % {'str1': self._(level[1].xml_str()),
                                            'str2': level[0]})

        place_names = ''
        all_names = place.get_all_names()
        if len(all_names) > 1 or __debug__:
            for place_name in all_names:
                if place_names != '':
                    # translators: needed for Arabic, ignore otherwise
                    place_names += self._(", ")
                place_names += '%s' % place_name.get_value()
                if place_name.get_language() != '' or __debug__:
                    place_names += ' (%s)' % place_name.get_language()
            place_details += [self._("places|All Names: %s") % place_names,]
        self.doc.start_paragraph("PLC-PlaceTitle")
        place_title = _pd.display(self._db, place, None, self.place_format)
        self.doc.write_text(("%(nbr)s. %(place)s") % {'nbr' : place_nbr,
                                                      'place' : place_title})
        self.doc.end_paragraph()

        for item in place_details:
            self.doc.start_paragraph("PLC-PlaceDetails")
            self.doc.write_text(item)
            self.doc.end_paragraph()
Пример #12
0
 def getPlaceKey(self, group_entry):
     """
     Return the place description to use when sorting the place records.
     """
     p_handle = group_entry[_REF_HANDLE_POS]
     place = self.database.get_place_from_handle(p_handle)
     title = place_displayer.display(self.database, place)
     return title.upper()
Пример #13
0
    def save(self, *obj):
        self.ok_button.set_sensitive(False)
        if self.object_is_empty():
            ErrorDialog(_("Cannot save place"),
                        _("No data exists for this place. Please "
                          "enter data or cancel the edit."))
            self.ok_button.set_sensitive(True)
            return

        if self.obj.get_name().strip() == '':
            msg1 = _("Cannot save location. Name not entered.")
            msg2 = _("You must enter a name before saving.") 
            ErrorDialog(msg1, msg2)
            self.ok_button.set_sensitive(True)
            return

        (uses_dupe_id, id) = self._uses_duplicate_id()
        if uses_dupe_id:
            prim_object = self.get_from_gramps_id(id)
            name = place_displayer.display(self.db, prim_object)
            msg1 = _("Cannot save place. ID already exists.")
            msg2 = _("You have attempted to use the existing Gramps ID with "
                         "value %(id)s. This value is already used by '" 
                         "%(prim_object)s'. Please enter a different ID or leave "
                         "blank to get the next available ID value.") % {
                         'id' : id, 'prim_object' : name }
            ErrorDialog(msg1, msg2)
            self.ok_button.set_sensitive(True)
            return

        with DbTxn('', self.db) as trans:
            place_title = place_displayer.display(self.db, self.obj)
            if not self.obj.get_handle():
                self.db.add_place(self.obj, trans)
                msg = _("Add Place (%s)") % place_title
            else:
                if not self.obj.get_gramps_id():
                    self.obj.set_gramps_id(self.db.find_next_place_gramps_id())
                self.db.commit_place(self.obj, trans)
                msg = _("Edit Place (%s)") % place_title
            trans.set_description(msg)
        
        self.close()
        if self.callback:
            self.callback(self.obj)
Пример #14
0
 def column_title(self, data):
     handle = data[0]
     cached, value = self.get_cached_value(handle, "PLACE")
     if not cached:
         place = Place()
         place.unserialize(data)
         value = place_displayer.display(self.db, place)
         self.set_cached_value(handle, "PLACE", value)
     return value
Пример #15
0
 def get_or_create_place(self, place_name):
     "Return the requested place object tuple-packed with a new indicator."
     LOG.debug("get_or_create_place: looking for: %s", place_name)
     for place_handle in self.db.iter_place_handles():
         place = self.db.get_place_from_handle(place_handle)
         place_title = place_displayer.display(self.db, place)
         if place_title == place_name:
             return (0, place)
     place = Place()
     place.set_title(place_name)
     self.db.add_place(place, self.trans)
     return (1, place)
Пример #16
0
    def save(self, *obj):
        self.ok_button.set_sensitive(False)

        if self.obj.get_name().get_value().strip() == '':
            msg1 = _("Cannot save place. Name not entered.")
            msg2 = _("You must enter a name before saving.")
            ErrorDialog(msg1, msg2, parent=self.window)
            self.ok_button.set_sensitive(True)
            return

        (uses_dupe_id, id) = self._uses_duplicate_id()
        if uses_dupe_id:
            prim_object = self.get_from_gramps_id(id)
            name = place_displayer.display(self.db, prim_object)
            msg1 = _("Cannot save place. ID already exists.")
            msg2 = _("You have attempted to use the existing Gramps ID with "
                         "value %(id)s. This value is already used by '"
                         "%(prim_object)s'. Please enter a different ID or leave "
                         "blank to get the next available ID value.") % {
                         'id' : id, 'prim_object' : name }
            ErrorDialog(msg1, msg2, parent=self.window)
            self.ok_button.set_sensitive(True)
            return

        place_title = place_displayer.display(self.db, self.obj)
        if not self.obj.handle:
            with DbTxn(_("Add Place (%s)") % place_title,
                       self.db) as trans:
                self.db.add_place(self.obj, trans)
        else:
            if self.data_has_changed():
                with DbTxn(_("Edit Place (%s)") % place_title,
                           self.db) as trans:
                    if not self.obj.get_gramps_id():
                        self.obj.set_gramps_id(self.db.find_next_place_gramps_id())
                    self.db.commit_place(self.obj, trans)

        self._do_close()
        if self.callback:
            self.callback(self.obj)
Пример #17
0
 def get_subject(self):
     """ Return a string that describes the subject of the report. """
     subject = ""
     if self.__filter.get_filter().get_name():
         # Use the selected filter's name, if any
         subject += self.__filter.get_filter().get_name()
     if self.__places.get_value():
         # Add places selected individually, if any
         for place_id in self.__places.get_value().split():
             if subject:
                 subject += " + "
             place = self.__db.get_place_from_gramps_id(place_id)
             subject += _pd.display(self.__db, place)
     return subject
Пример #18
0
    def __write_place(self, handle, place_nbr):
        """
        This procedure writes out the details of a single place
        """
        place = self.database.get_place_from_handle(handle)
        location = get_main_location(self.database, place)

        city = location.get(PlaceType.CITY)

        place_title = _pd.display(self.database, place)
        if city == '' and place_title:
            city = place_title

        return city
Пример #19
0
    def write_place(self):
        handles = sorted(self.database.get_place_handles(), key=self._getPlaceTimestamp)

        if len(handles) > 0:
            self._table_begin(_("Places Changed"), "PlaceTable")
            self._table_header(_('ID'), _('Place'), _('Changed On'))

            for handle in reversed(handles[-10:]):
                place = self.database.get_place_from_handle(handle)
                if place is not None:
                    self._table_row(place.gramps_id,
                                    place_displayer.display(self.database, place),
                                    self._convert_date(place.change))
            self._table_end()
Пример #20
0
    def calc_url(self):
        """ Determine the url to use on maps.google.com
            Logic: use lat lon if present
                   otherwise use description of the place
        """
        place = self._get_first_place()[0]
        latitude, longitude = self._lat_lon(place)
        if longitude and latitude:
            self.url = "http://maps.google.com/maps/mm?sll=%s,%s&z=15" % (latitude,
                                                               longitude)
            return

        titledescr = place_displayer.display(self.database, place)
        self.url = "http://maps.google.com/maps?q=%s" % \
                                            '+'.join(titledescr.split())
Пример #21
0
    def calc_url(self):
        """ Determine the url to use
            Logic: Use lat lon if present
                   otherwise use description of the place
        """
        place = self._get_first_place()[0]
        latitude, longitude = self._lat_lon(place)
        if longitude and latitude:
            self.url = "http://www.openstreetmap.org/" \
                        "?lat=%s&lon=%s&zoom=15" % (latitude, longitude)

            return

        titledescr = place_displayer.display(self.database, place)
        self.url = "http://nominatim.openstreetmap.org/"\
                        "search.php?q=%s" % '+'.join(titledescr.split())
Пример #22
0
 def entry_change(self, entry):
     value = entry.get_text()
     if value.isnumeric() or value == "":
         self.last = value # This entry is numeric and valid.
     else:
         entry.set_text(self.last) # reset to the last valid entry
     _db = self.dbstate.db
     active_reference = self.uistate.get_active('Place')
     place_name = None
     if active_reference:
         place = _db.get_place_from_handle(active_reference)
         place_name = _pd.display(self.dbstate.db, place)
     if place_name is None:
         self.set_tooltip_text(self.tooltip)
     else:
         self.set_tooltip_text(place_name)
Пример #23
0
    def __init__(self, dbstate, user, options_class, name, callback=None):
        uistate = user.uistate
        self.label = _('Check Place title')
        tool.BatchTool.__init__(self, dbstate, user, options_class, name)
        if self.fail:
            return

        ManagedWindow.__init__(self,uistate,[], self.__class__)
        self.set_window(Gtk.Window(),Gtk.Label(),'')

        # retrieve options CLI?
        #copy = self.options.handler.options_dict['copy']
        #clean = self.options.handler.options_dict['clean']

        self.db = dbstate.db

        self.total = self.db.get_number_of_places()
        self.progress = ProgressMeter(_('Checking Place Titles'), '',
                                      parent=uistate.window)
        self.progress.set_pass(_('Looking for place fields'),
                               self.total)

        self.name_list = []
        count = 0
        for handle in self.db.get_place_handles(True):
            self.progress.step()
            place = self.db.get_place_from_handle(handle)
            title = place.title
            descr = place_displayer.display(self.db, place)
            if title != (descr and ""):
                count += 1
            if title != "":
                self.name_list.append((handle.decode('utf8'), title, descr))

        self.progress.close()

        if self.name_list:
            self.display()
            OkDialog(_('Differences'),
                     '%s/%s' % (count, self.total),
                     parent=uistate.window)
        else:
            self.progress.close()
            self.close()
            OkDialog(_('No need modifications'),
                     _("No changes need."),
                     parent=uistate.window)
Пример #24
0
def _build_title(db, place):
    """ Builds descrition string for title parameter in url """
    descr = place_displayer.display(db, place)
    location = get_main_location(db, place)
    parish = location.get(PlaceType.PARISH)
    city = location.get(PlaceType.CITY)
    state = location.get(PlaceType.STATE)
    title_descr = ""
    if descr:
        title_descr += descr.strip()
    if parish:
        title_descr += ', ' + parish.strip() + _(" parish")
    if city:
        title_descr += ', ' + city.strip()
    if state:
        title_descr += ', ' + state.strip() + _(" state")
    return _strip_leading_comma(title_descr)
Пример #25
0
    def write_place(self):
        """ Find and write Places """
        handles = sorted(self.database.get_place_handles(),
                         key=self._get_place_timestamp)

        if handles:
            self._table_begin(_("Places Changed"), "PlaceTable")
            self._table_header(_('ID'), _('Place'), _('Changed On'))

            for handle in reversed(handles[-10:]):
                place = self.database.get_place_from_handle(handle)
                if place is not None:
                    self._table_row(place.gramps_id,
                                    place_displayer.display(self.database,
                                                            place),
                                    format_time(place.change))
            self._table_end()
Пример #26
0
    def __write_place(self, handle, place_nbr):
        """
        This procedure writes out the details of a single place
        """
        place = self.database.get_place_from_handle(handle)
        location = get_main_location(self.database, place)
        city = ''
        for pl_type in [PlaceType.HAMLET, PlaceType.VILLAGE,
                            PlaceType.TOWN, PlaceType.CITY]:
            if location.get(pl_type):
                city = location.get(pl_type)
                break

        place_title = _pd.display(self.database, place)
        if city == '' and place_title:
            return place_title

        return city
Пример #27
0
    def write_kml_point_data(self):
        """
        Writes the point data of the kml/kmz file.
        """
        self.kml_file.write('<Document>\n')
        self.kml_file.write('    <name>GrampsPlaces</name>\n')
        for place, descr in self._all_places():
            latitude, longitude = self._lat_lon(place)
            if latitude == None or longitude == None:
                location = get_main_location(self.database, place)
                LOG.warning(" %s : Missing coordinates(latitude/longitude): \
                             Skipping entry: " % (location))
                continue
            if not descr:
                descr = place_displayer.display(self.database, place)
            location = get_main_location(self.database, place)
            parish_descr = location.get(PlaceType.PARISH)
            if parish_descr == None:
                parish_descr = ""
            city = location.get(PlaceType.CITY)
            county = location.get(PlaceType.COUNTY)
            city_county_descr = _combine(city, county)

            state = location.get(PlaceType.STATE)
            country = location.get(PlaceType.COUNTRY)
            state_country_descr = _combine(state, country)
            id = place.get_gramps_id()

            self.kml_file.write('    <Placemark id="%s">\n' % id)
            self.kml_file.write("        <name>%s</name>\n" % descr)
            self.kml_file.write("        <description>\n")
            self.kml_file.write("            <![CDATA[\n")
            self.kml_file.write("              %s\n" %  parish_descr)
            self.kml_file.write("              %s\n" %  city_county_descr)
            self.kml_file.write("              %s\n" %  state_country_descr)
            self.kml_file.write("            ]]>\n")
            self.kml_file.write("        </description>\n")
            self.kml_file.write("        <Point>\n")
            self.kml_file.write("            <coordinates>%s" % longitude)
            self.kml_file.write(",%s</coordinates>\n" % latitude)
            self.kml_file.write("        </Point>\n")
            self.kml_file.write("    </Placemark>\n")
        self.kml_file.write("</Document>\n")
Пример #28
0
    def _write_place(self, place_handle):
        """
        Generate a table row with the place record information.
        """
        place = self.database.get_place_from_handle(place_handle)

        self.doc.start_row()

        self.doc.start_cell('TR-TableCell')
        self.doc.start_paragraph('TR-Normal')
        self.doc.write_text(place.get_gramps_id())
        self.doc.end_paragraph()
        self.doc.end_cell()

        self.doc.start_cell('TR-TableCell', 3)
        self.doc.start_paragraph('TR-Normal')
        self.doc.write_text(place_displayer.display(self.database, place))
        self.doc.end_paragraph()
        self.doc.end_cell()

        self.doc.end_row()
Пример #29
0
def _Event_get_place_text(event, database, placeholder=False):
    """
    Return a textual representation of the event's place to be used in textual
    context. This is basically "in " + the place title.

    @param placeholder: whether a series of underscores should be inserted as a
        placeholder if the place is missing.
    """

    place_handle = event.get_place_handle()

    if place_handle:
        place = database.get_place_from_handle(place_handle)
        place_title = place_displayer.display(database, place)
        text = _("in %(place)s") % {'place': place_title}
    elif placeholder and event.get_type() in _Event_needs_date_place:
        text = _("in %(place)s") % {'place': "__________"}
    else:
        text = ""

    return text
Пример #30
0
def get_gendex_data(database, event_ref):
    """
    Given an event, return the date and place a strings

    @param: database  -- The database
    @param: event_ref -- The event reference
    """
    doe = ""  # date of event
    poe = ""  # place of event
    if event_ref and event_ref.ref:
        event = database.get_event_from_handle(event_ref.ref)
        if event:
            date = event.get_date_object()
            doe = format_date(date)
            if event.get_place_handle():
                place_handle = event.get_place_handle()
                if place_handle:
                    place = database.get_place_from_handle(place_handle)
                    if place:
                        poe = _pd.display(database, place, date)
    return doe, poe
Пример #31
0
    def display_place(self, place):
        """
        Display details of the active place.
        """
        self.load_place_image(place)
        title = place_displayer.display(self.dbstate.db, place)
        self.title.set_text(title)

        self.clear_grid()
        self.add_row(_('Name'), place.get_name().get_value())
        self.add_row(_('Type'), place.get_type())
        self.display_separator()
        self.display_alt_names(place)
        self.display_separator()
        lat, lon = conv_lat_lon(place.get_latitude(),
                                place.get_longitude(),
                                format='DEG')
        if lat:
            self.add_row(_('Latitude'), lat)
        if lon:
            self.add_row(_('Longitude'), lon)
Пример #32
0
    def display_place(self, place):
        """
        Display details of the active place.
        """
        self.load_place_image(place)
        title = place_displayer.display(self.dbstate.db, place)
        self.title.set_text(title)

        self.clear_grid()
        self.add_row(_('Name'), place.get_name().get_value())
        self.add_row(_('Type'), place.get_type())
        self.display_separator()
        self.display_alt_names(place)
        self.display_separator()
        lat, lon = conv_lat_lon(place.get_latitude(),
                                place.get_longitude(),
                                format='DEG')
        if lat:
            self.add_row(_('Latitude'), lat)
        if lon:
            self.add_row(_('Longitude'), lon)
Пример #33
0
    def _write_place(self, place_handle):
        """
        Generate a table row with the place record information.
        """
        place = self.database.get_place_from_handle(place_handle)

        self.doc.start_row()

        self.doc.start_cell('TR-TableCell')
        self.doc.start_paragraph('TR-Normal')
        self.doc.write_text(place.get_gramps_id())
        self.doc.end_paragraph()
        self.doc.end_cell()

        self.doc.start_cell('TR-TableCell', 3)
        self.doc.start_paragraph('TR-Normal')
        self.doc.write_text(place_displayer.display(self.database, place))
        self.doc.end_paragraph()
        self.doc.end_cell()

        self.doc.end_row()
Пример #34
0
def get_gendex_data(database, event_ref):
    """
    Given an event, return the date and place a strings

    @param: database  -- The database
    @param: event_ref -- The event reference
    """
    doe = "" # date of event
    poe = "" # place of event
    if event_ref and event_ref.ref:
        event = database.get_event_from_handle(event_ref.ref)
        if event:
            date = event.get_date_object()
            doe = format_date(date)
            if event.get_place_handle():
                place_handle = event.get_place_handle()
                if place_handle:
                    place = database.get_place_from_handle(place_handle)
                    if place:
                        poe = _pd.display(database, place, date)
    return doe, poe
Пример #35
0
    def write_kml_point_data(self):
        """
        Writes the point data of the kml/kmz file.
        """
        self.kml_file.write('<Document>\n')
        self.kml_file.write('    <name>GrampsPlaces</name>\n')
        for place, descr in self._all_places():
            latitude, longitude = self._lat_lon(place)
            if latitude == None or longitude == None:
                continue
            if not descr:
                descr = place_displayer.display(self.database, place)
            location = get_main_location(self.database, place)
            parish_descr = location.get(PlaceType.PARISH)
            if parish_descr == None:
                parish_descr = ""
            city = location.get(PlaceType.CITY)
            county = location.get(PlaceType.COUNTY)
            city_county_descr = _combine(city, county)

            state = location.get(PlaceType.STATE)
            country = location.get(PlaceType.COUNTRY)
            state_country_descr = _combine(state, country)
            id = place.get_gramps_id()

            self.kml_file.write('    <Placemark id="%s">\n' % id)
            self.kml_file.write("        <name>%s</name>\n" % descr)
            self.kml_file.write("        <description>\n")
            self.kml_file.write("            <![CDATA[\n")
            self.kml_file.write("              %s\n" %  parish_descr)
            self.kml_file.write("              %s\n" %  city_county_descr)
            self.kml_file.write("              %s\n" %  state_country_descr)
            self.kml_file.write("            ]]>\n")
            self.kml_file.write("        </description>\n")
            self.kml_file.write("        <Point>\n")
            self.kml_file.write("            <coordinates>%s" % longitude)
            self.kml_file.write(",%s</coordinates>\n" % latitude)
            self.kml_file.write("        </Point>\n")
            self.kml_file.write("    </Placemark>\n")
        self.kml_file.write("</Document>\n")
Пример #36
0
 def get_name_id(self, handle):
     if self.namespace == 'Person':
         person = self.db.get_person_from_handle(handle)
         name = _nd.sorted(person)
         gid = person.get_gramps_id()
     elif self.namespace == 'Family':
         family = self.db.get_family_from_handle(handle)
         name = family_name(family, self.db)
         gid = family.get_gramps_id()
     elif self.namespace == 'Event':
         event = self.db.get_event_from_handle(handle)
         name = event.get_description()
         gid = event.get_gramps_id()
     elif self.namespace == 'Source':
         source = self.db.get_source_from_handle(handle)
         name = source.get_title()
         gid = source.get_gramps_id()
     elif self.namespace == 'Citation':
         citation = self.db.get_citation_from_handle(handle)
         name = citation.get_page()
         gid = citation.get_gramps_id()
     elif self.namespace == 'Place':
         place = self.db.get_place_from_handle(handle)
         name = _pd.display(self.db, place)
         gid = place.get_gramps_id()
     elif self.namespace == 'Media':
         obj = self.db.get_object_from_handle(handle)
         name = obj.get_description()
         gid = obj.get_gramps_id()
     elif self.namespace == 'Repository':
         repo = self.db.get_repository_from_handle(handle)
         name = repo.get_name()
         gid = repo.get_gramps_id()
     elif self.namespace == 'Note':
         note = self.db.get_note_from_handle(handle)
         name = note.get().replace('\n', ' ')
         if len(name) > 80:
             name = name[:80] + "..."
         gid = note.get_gramps_id()
     return (name, gid)
Пример #37
0
    def __write_place(self, handle, place_nbr):
        """
        This procedure writes out the details of a single place
        """
        place = self._db.get_place_from_handle(handle)

        place_details = [self._("Gramps ID: %s ") % place.get_gramps_id()]
        for level in get_location_list(self._db, place):
            # translators: needed for French, ignore otherwise
            place_details.append(
                self._("%(str1)s: %(str2)s") % {
                    'str1': self._(level[1].xml_str()),
                    'str2': level[0]
                })

        place_names = ''
        all_names = place.get_all_names()
        if len(all_names) > 1 or __debug__:
            for place_name in all_names:
                if place_names != '':
                    # translators: needed for Arabic, ignore otherwise
                    place_names += self._(", ")
                place_names += '%s' % place_name.get_value()
                if place_name.get_language() != '' or __debug__:
                    place_names += ' (%s)' % place_name.get_language()
            place_details += [
                self._("places|All Names: %s") % place_names,
            ]
        self.doc.start_paragraph("PLC-PlaceTitle")
        place_title = _pd.display(self._db, place)
        self.doc.write_text(("%(nbr)s. %(place)s") % {
            'nbr': place_nbr,
            'place': place_title
        })
        self.doc.end_paragraph()

        for item in place_details:
            self.doc.start_paragraph("PLC-PlaceDetails")
            self.doc.write_text(item)
            self.doc.end_paragraph()
Пример #38
0
def sort_places(dbase, handle_list, rlocale=glocale):
    """
    will sort the database place
    """
    pname_sub = defaultdict(list)
    sortnames = {}

    for place_handle in handle_list:
        place = dbase.get_place_from_handle(place_handle)
        pname = _pd.display(dbase, place)
        sortnames[place_handle] = pname
        pname_sub[pname].append(place_handle)

    sorted_lists = []
    temp_list = sorted(pname_sub, key=rlocale.sort_key)

    for name in temp_list:
        if isinstance(name, bytes):
            name = name.decode('utf-8')
        sorted_lists.append((name, pname_sub[name][0]))

    return sorted_lists
    def __get_simple_event(self, event_ref):
        if event_ref:
            event = self.database.get_event_from_handle(event_ref.ref)
            event_date = event.get_date_object()
            date_text = self._get_date_text(event_date)
            # date_text = datehandler.displayer.display(event_date)
            place_handle = event.get_place_handle()
            description = event.get_description()
            event_type = event.get_type()
        else:
            date_text = ""
            event_type = None
            description = ""

        if event_ref and place_handle:
            place = self.database.get_place_from_handle(place_handle)
            place_text = place_displayer.display(self.database, place,
                                                 event_date)
        else:
            place_text = ""

        return event_type, date_text, place_text, description
Пример #40
0
 def _create_one_place(self, place):
     """
     Create one entry for one place with a lat/lon.
     """
     if place is None:
         return
     if self.nbplaces >= self._config.get("geography.max_places"):
         return
     descr = _pd.display(self.dbstate.db, place)
     longitude = place.get_longitude()
     latitude = place.get_latitude()
     latitude, longitude = conv_lat_lon(latitude, longitude, "D.D8")
     self.load_kml_files(place)
     # place.get_longitude and place.get_latitude return
     # one string. We have coordinates when the two values
     # contains non null string.
     if longitude and latitude:
         colour = self.plc_color[int(place.get_type()) + 1]
         if int(place.get_type()) == PlaceType.CUSTOM:
             try:
                 colour = (str(place.get_type()),
                           self.plc_custom_color[str(place.get_type())])
             except:
                 colour = self.plc_color[PlaceType.CUSTOM + 1]
         self._append_to_places_list(
             descr,
             None,
             "",
             latitude,
             longitude,
             None,
             None,
             EventType.UNKNOWN,
             None,  # person.gramps_id
             place.gramps_id,
             None,  # event.gramps_id
             None,  # family.gramps_id
             color=colour)
Пример #41
0
    def calc_url(self):
        """ Determine the url to use on maps.google.com
            Logic: use lat lon if present
                   otherwise use city and country if present
                   otherwise use description of the place
        """
        place = self._get_first_place()[0]
        latitude, longitude = self._lat_lon(place)
        if longitude and latitude:
            self.url = "http://maps.google.com/maps/mm?sll=%s,%s&z=15" % (
                latitude, longitude)
            return

        location = get_main_location(self.database, place)
        city = location.get(PlaceType.CITY)
        country = location.get(PlaceType.COUNTRY)
        if city and country:
            self.url = "http://maps.google.com/maps?q=%s,%s" % (city, country)
            return

        titledescr = place_displayer.display(self.database, place)
        self.url = "http://maps.google.com/maps?q=%s" % \
                                            '+'.join(titledescr.split())
Пример #42
0
 def sort_val_from_handle(self, handle):
     if self.namespace == 'Person':
         name = self.db.get_person_from_handle(handle).get_primary_name()
         sortname = _nd.sort_string(name)
     elif self.namespace == 'Family':
         sortname = family_name(self.db.get_family_from_handle(handle),
                                self.db)
     elif self.namespace == 'Event':
         sortname = self.db.get_event_from_handle(handle).get_description()
     elif self.namespace == 'Source':
         sortname = self.db.get_source_from_handle(handle).get_title()
     elif self.namespace == 'Citation':
         sortname = self.db.get_citation_from_handle(handle).get_page()
     elif self.namespace == 'Place':
         place = self.db.get_place_from_handle(handle)
         sortname = _pd.display(self.db, place)
     elif self.namespace == 'Media':
         sortname = self.db.get_object_from_handle(handle).get_description()
     elif self.namespace == 'Repository':
         sortname = self.db.get_repository_from_handle(handle).get_name()
     elif self.namespace == 'Note':
         gid = self.db.get_note_from_handle(handle).get_gramps_id()
         sortname = gid
     return (sortname, handle)
Пример #43
0
    def query_response(self):
        place_title = place_displayer.display(self.db, self.obj)
        with DbTxn(_("Delete Place (%s)") % place_title, self.db) as trans:
            self.db.disable_signals()

            place_handle = self.obj.get_handle()

            for handle in self.person_list:
                person = self.db.get_person_from_handle(handle)
                person.remove_handle_references('Place', place_handle)
                self.db.commit_person(person, trans)

            for handle in self.family_list:
                family = self.db.get_family_from_handle(handle)
                family.remove_handle_references('Place', place_handle)
                self.db.commit_family(family, trans)

            for handle in self.event_list:
                event = self.db.get_event_from_handle(handle)
                event.remove_handle_references('Place', place_handle)
                self.db.commit_event(event, trans)

            self.db.enable_signals()
            self.db.remove_place(place_handle, trans)
Пример #44
0
    def __init__(self,
                 dbstate,
                 uistate,
                 track,
                 handle1,
                 handle2,
                 callback=None):
        ManagedWindow.__init__(self, uistate, track, self.__class__)
        self.dbstate = dbstate
        database = dbstate.db
        self.callback = callback
        self.pl1 = database.get_place_from_handle(handle1)
        self.pl2 = database.get_place_from_handle(handle2)

        self.define_glade('mergeplace', _GLADE_FILE)
        self.set_window(self._gladeobj.toplevel,
                        self.get_widget('place_title'), _("Merge Places"))
        self.setup_configs('interface.merge-place', 500, 250)

        # Detailed selection widgets
        if not config.get('preferences.place-auto'):
            title1 = self.pl1.get_title()
            title2 = self.pl2.get_title()
            entry1 = self.get_widget("title1")
            entry2 = self.get_widget("title2")
            entry1.set_text(title1)
            entry2.set_text(title2)
            if entry1.get_text() == entry2.get_text():
                for widget_name in ('title1', 'title2', 'title_btn1',
                                    'title_btn2'):
                    self.get_widget(widget_name).set_sensitive(False)
            for widget_name in ('title1', 'title2', 'title_btn1',
                                'title_btn2'):
                self.get_widget(widget_name).show()

        for widget_name in ('name_btn1', 'name_btn2'):
            self.get_widget(widget_name).set_label(PLACE_NAME)
        entry1 = self.get_widget("name1")
        entry2 = self.get_widget("name2")
        entry1.set_text(self.pl1.get_name().get_value())
        entry2.set_text(self.pl2.get_name().get_value())
        if entry1.get_text() == entry2.get_text():
            for widget_name in ('name1', 'name2', 'name_btn1', 'name_btn2'):
                self.get_widget(widget_name).set_sensitive(False)

        entry1 = self.get_widget("type1")
        entry2 = self.get_widget("type2")
        entry1.set_text(str(self.pl1.get_type()))
        entry2.set_text(str(self.pl2.get_type()))
        if entry1.get_text() == entry2.get_text():
            for widget_name in ('type1', 'type2', 'type_btn1', 'type_btn2'):
                self.get_widget(widget_name).set_sensitive(False)

        entry1 = self.get_widget("code1")
        entry2 = self.get_widget("code2")
        entry1.set_text(self.pl1.get_code())
        entry2.set_text(self.pl2.get_code())
        if entry1.get_text() == entry2.get_text():
            for widget_name in ('code1', 'code2', 'code_btn1', 'code_btn2'):
                self.get_widget(widget_name).set_sensitive(False)

        entry1 = self.get_widget("lat1")
        entry2 = self.get_widget("lat2")
        entry1.set_text(self.pl1.get_latitude())
        entry2.set_text(self.pl2.get_latitude())
        if entry1.get_text() == entry2.get_text():
            for widget_name in ('lat1', 'lat2', 'lat_btn1', 'lat_btn2'):
                self.get_widget(widget_name).set_sensitive(False)

        entry1 = self.get_widget("long1")
        entry2 = self.get_widget("long2")
        entry1.set_text(self.pl1.get_longitude())
        entry2.set_text(self.pl2.get_longitude())
        if entry1.get_text() == entry2.get_text():
            for widget_name in ('long1', 'long2', 'long_btn1', 'long_btn2'):
                self.get_widget(widget_name).set_sensitive(False)

        gramps1 = self.pl1.get_gramps_id()
        gramps2 = self.pl2.get_gramps_id()
        entry1 = self.get_widget("gramps1")
        entry2 = self.get_widget("gramps2")
        entry1.set_text(gramps1)
        entry2.set_text(gramps2)
        if entry1.get_text() == entry2.get_text():
            for widget_name in ('gramps1', 'gramps2', 'gramps_btn1',
                                'gramps_btn2'):
                self.get_widget(widget_name).set_sensitive(False)

        # Main window widgets that determine which handle survives
        title1 = place_displayer.display(database, self.pl1)
        title2 = place_displayer.display(database, self.pl2)
        rbutton1 = self.get_widget("handle_btn1")
        rbutton_label1 = self.get_widget("label_handle_btn1")
        rbutton_label2 = self.get_widget("label_handle_btn2")
        rbutton_label1.set_label(title1 + " [" + gramps1 + "] " +
                                 str(self.pl1.place_type))
        rbutton_label2.set_label(title2 + " [" + gramps2 + "] " +
                                 str(self.pl2.place_type))
        rbutton1.connect("toggled", self.on_handle1_toggled)

        self.connect_button('place_help', self.cb_help)
        self.connect_button('place_ok', self.cb_merge)
        self.connect_button('place_cancel', self.close)
        self.show()
Пример #45
0
 def update_title(self):
     new_title = place_displayer.display(self.db, self.source)
     self.top.get_object("preview_title").set_text(new_title)
Пример #46
0
    def display(self):

        self.top = Glade("changenames.glade")
        window = self.top.toplevel
        self.top.connect_signals({
            "destroy_passed_object" : self.close,
            "on_ok_clicked" : self.on_ok_clicked,
            "on_help_clicked" : self.on_help_clicked,
            "on_delete_event"   : self.close,
            })

        self.list = self.top.get_object("list")
        self.set_window(window, self.top.get_object('title'), self.label)
        lbl = self.top.get_object('info')
        lbl.set_line_wrap(True)
        lbl.set_text(
            _('Below is a list of Places with the possible data that can '
              'be extracted from the place title. Select the places you '
              'wish Gramps to convert.'))

        self.model = Gtk.ListStore(GObject.TYPE_BOOLEAN, GObject.TYPE_STRING,
                                   GObject.TYPE_STRING, GObject.TYPE_STRING,
                                   GObject.TYPE_STRING, GObject.TYPE_STRING,
                                   GObject.TYPE_STRING)

        r = Gtk.CellRendererToggle()
        r.connect('toggled', self.toggled)
        c = Gtk.TreeViewColumn(_('Select'), r, active=0)
        self.list.append_column(c)

        for (title, col) in COLS:
            render = Gtk.CellRendererText()
            if col > 1:
                render.set_property('editable', True)
                render.connect('edited', self.__change_name, col)

            self.list.append_column(
                Gtk.TreeViewColumn(title, render, text=col))
        self.list.set_model(self.model)

        self.iter_list = []
        self.progress.set_pass(_('Building display'), len(self.name_list))
        for (id, data) in self.name_list:

            place = self.db.get_place_from_handle(id)
            descr = place_displayer.display(self.db, place)

            handle = self.model.append()
            self.model.set_value(handle, 0, True)
            self.model.set_value(handle, 1, descr)
            if data[0]:
                self.model.set_value(handle, 2, data[0])
            if data[1]:
                self.model.set_value(handle, 3, data[1])
            if data[2]:
                self.model.set_value(handle, 4, data[2])
            if data[3]:
                self.model.set_value(handle, 5, data[3])
            self.model.set_value(handle, 6, id)
            self.iter_list.append(handle)
            self.progress.step()
        self.progress.close()

        self.show()
Пример #47
0
    def write_places(self):
        """ write the places associated with the tag """
        plist = self.database.get_place_handles()
        filter_class = GenericFilterFactory('Place')
        a_filter = filter_class()
        a_filter.add_rule(rules.place.HasTag([self.tag]))
        place_list = a_filter.apply(self.database, plist)

        if not place_list:
            return

        self.doc.start_paragraph("TR-Heading")
        header = self._("Places")
        mark = IndexMark(header, INDEX_TYPE_TOC, 2)
        self.doc.write_text(header, mark)
        self.doc.end_paragraph()

        self.doc.start_table('PlaceTable', 'TR-Table')

        self.doc.start_row()

        self.doc.start_cell('TR-TableCell')
        self.doc.start_paragraph('TR-Normal-Bold')
        self.doc.write_text(self._("Id"))
        self.doc.end_paragraph()
        self.doc.end_cell()

        self.doc.start_cell('TR-TableCell')
        self.doc.start_paragraph('TR-Normal-Bold')
        self.doc.write_text(self._("Title"))
        self.doc.end_paragraph()
        self.doc.end_cell()

        self.doc.start_cell('TR-TableCell')
        self.doc.start_paragraph('TR-Normal-Bold')
        self.doc.write_text(self._("Name"))
        self.doc.end_paragraph()
        self.doc.end_cell()

        self.doc.start_cell('TR-TableCell')
        self.doc.start_paragraph('TR-Normal-Bold')
        self.doc.write_text(self._("Type"))
        self.doc.end_paragraph()
        self.doc.end_cell()

        self.doc.end_row()

        for place_handle in place_list:
            place = self.database.get_place_from_handle(place_handle)
            place_title = _pd.display(self.database, place)

            self.doc.start_row()

            self.doc.start_cell('TR-TableCell')
            self.doc.start_paragraph('TR-Normal')
            self.doc.write_text(place.get_gramps_id())
            self.doc.end_paragraph()
            self.doc.end_cell()

            self.doc.start_cell('TR-TableCell')
            self.doc.start_paragraph('TR-Normal')
            self.doc.write_text(place_title)
            self.doc.end_paragraph()
            self.doc.end_cell()

            self.doc.start_cell('TR-TableCell')
            self.doc.start_paragraph('TR-Normal')
            self.doc.write_text(place.get_name().get_value())
            self.doc.end_paragraph()
            self.doc.end_cell()

            self.doc.start_cell('TR-TableCell')
            self.doc.start_paragraph('TR-Normal')
            self.doc.write_text(str(place.get_type()))
            self.doc.end_paragraph()
            self.doc.end_cell()

            self.doc.end_row()

        self.doc.end_table()
Пример #48
0
    def print_object(self, level, o):

        if issubclass(o.__class__, gramps.gen.lib.address.Address):
            # Details of address are printed by the subclass conditions,
            # primarily by LocationBase, because address is a subclass of
            # LocationBase
            pass

        if issubclass(o.__class__, gramps.gen.lib.addressbase.AddressBase):
            for address in o.get_address_list():
                self.print_header(level, _("Address"), ref=address)
                self.print_object(level + 1, address)

        if isinstance(o, gramps.gen.lib.Attribute):
            # The unique information about attributes (the type) is printed by
            # AttributeBase
            pass

        if issubclass(o.__class__, gramps.gen.lib.attrbase.AttributeBase):
            for attribute in o.get_attribute_list():
                self.print_header(level,
                                  _("Attribute") + ". ",
                                  type_desc=str(attribute.get_type()),
                                  obj_type=attribute.get_value(),
                                  privacy=attribute.get_privacy(),
                                  ref=attribute)
                self.print_object(level + 1, attribute)

        if isinstance(o, gramps.gen.lib.ChildRef):
            # The unique information about ChildRef (the father relation and
            # mother relation) is printed by the main write_report function
            pass

        if issubclass(o.__class__, gramps.gen.lib.citationbase.CitationBase):
            if self.print_citations:
                self.print_header(level, "CitationBase tbd")

                for citation_handle in o.get_citation_list():
                    citation = self.database.get_citation_from_handle(
                        citation_handle)
                    self.print_object(level + 1, citation)

        if isinstance(o, gramps.gen.lib.Citation):
            # the unique information about Citation (the page) is printed by the
            # bibliography code. The other unique information, the confidence is
            # printed here
            if o.get_confidence_level() != gramps.gen.lib.Citation.CONF_NORMAL:
                self.doc.start_paragraph("PE-Level%d" % min(level, 32))
                self.doc.start_bold()
                self.doc.write_text(_("Confidence") + " : ")
                self.doc.end_bold()
                self.doc.write_text(
                    conf_strings.get(o.get_confidence_level(), _('Unknown')))
                self.doc.end_paragraph()

            if self.print_citations:
                source_handle = o.get_reference_handle()
                source = self.database.get_source_from_handle(source_handle)
                self.print_object(level + 1, source)

        if issubclass(o.__class__, gramps.gen.lib.datebase.DateBase):
            if o.get_date_object() and not o.get_date_object().is_empty():
                self.doc.start_paragraph("PE-Level%d" % min(level, 32))
                self.doc.start_bold()
                self.doc.write_text(_("Date") + " : ")
                self.doc.end_bold()
                self.doc.write_text(displayer.display(o.get_date_object()))
                self.doc.end_paragraph()

        if isinstance(o, gramps.gen.lib.Event):
            # The event type is printed by the main write_report function
            self.doc.start_paragraph("PE-Level%d" % min(level, 32))
            self.doc.start_bold()
            self.doc.write_text(_("Description") + " : ")
            self.doc.end_bold()
            self.doc.write_text(str(o.get_description()))
            self.doc.end_paragraph()

        if issubclass(o.__class__, gramps.gen.lib.eventref.EventRef):
            # The unique information about EventRef (the EventRoleType) is
            # printed by the main write_report function
            event = self.database.get_event_from_handle(
                o.get_reference_handle())
            self.print_header(level,
                              _("Event"),
                              event.get_gramps_id(),
                              _("Event type"),
                              str(event.get_type()),
                              event.get_privacy(),
                              ref=event)
            self.print_object(level + 1, event)

        if isinstance(o, gramps.gen.lib.Family):
            # The unique information about Family (father, mother and children,
            # FamilyRelType and event references) are printed by the main
            # write_report function
            pass

        if isinstance(o, gramps.gen.lib.LdsOrd):
            # The Ordinance type is printed by LdsOrdBase
            self.doc.start_paragraph("PE-Level%d" % min(level, 32))
            self.doc.start_bold()
            self.doc.write_text(_("Temple and status") + " : ")
            self.doc.end_bold()
            self.doc.write_text(", ".join(
                (TEMPLES.name(o.get_temple()), o.status2str())))
            self.doc.end_paragraph()

            f_h = o.get_family_handle()
            if f_h:
                family = self.database.get_family_from_handle(f_h)
                self.print_family_summary(level + 1, family,
                                          _("LDS Ordinance family"))

        if issubclass(o.__class__, gramps.gen.lib.ldsordbase.LdsOrdBase):
            for ldsord in o.get_lds_ord_list():
                self.print_header(level,
                                  _("LDS "),
                                  type_desc=_("Ordinance"),
                                  obj_type=ldsord.type2str(),
                                  privacy=ldsord.get_privacy(),
                                  ref=ldsord)
                self.print_object(level + 1, ldsord)

        if isinstance(o, gramps.gen.lib.Location):
            # The unique information about location (Parish) is printed by
            # Place. Location otherwise serves as a pointer to a LocationBase
            # object
            pass

        if issubclass(o.__class__, gramps.gen.lib.locationbase.LocationBase):
            self.doc.start_paragraph("PE-Level%d" % min(level, 32))
            self.doc.start_bold()
            self.doc.write_text(
                _("Street, City, County, State, Postal Code, "
                  "Country, Phone number") + " : ")
            self.doc.end_bold()
            self.doc.write_text(", ".join(
                (o.get_street(), o.get_city(), o.get_county(), o.get_state(),
                 o.get_postal_code(), o.get_country(), o.get_phone())))
            self.doc.end_paragraph()

        if issubclass(o.__class__, gramps.gen.lib.mediabase.MediaBase):
            for mediaref in o.get_media_list():
                self.print_header(level, _("Media Reference"), ref=mediaref)
                self.print_object(level + 1, mediaref)

        if isinstance(o, gramps.gen.lib.Media):
            # thumb is not printed. The mime type is printed by MediaRef
            self.doc.start_paragraph("PE-Level%d" % min(level, 32))
            self.doc.start_bold()
            self.doc.write_text(_("Description and Path") + " : ")
            self.doc.end_bold()
            self.doc.write_text(o.get_description() + ", ")
            path = o.get_path()
            if path:
                mark = IndexMark(
                    "file://:" + media_path_full(self.database, path),
                    LOCAL_HYPERLINK)
                self.doc.write_text(path, mark=mark)
            self.doc.end_paragraph()

            mime_type = o.get_mime_type()
            if mime_type and mime_type.startswith("image"):
                filename = media_path_full(self.database, o.get_path())
                if os.path.exists(filename):
                    self.doc.start_paragraph("PE-Level%d" % min(level, 32))
                    self.doc.add_media(filename, "single", 4.0, 4.0)
                    self.doc.end_paragraph()
                else:
                    self._user.warn(
                        _("Could not add photo to page"),
                        "%s: %s" % (filename, _('File does not exist')))

        if isinstance(o, gramps.gen.lib.MediaRef):
            media_handle = o.get_reference_handle()
            media = self.database.get_media_from_handle(media_handle)

            if o.get_rectangle():
                self.doc.start_paragraph("PE-Level%d" % min(level, 32))
                self.doc.start_bold()
                self.doc.write_text(_("Referenced Region") + " : ")
                self.doc.end_bold()
                self.doc.write_text(", ".join(
                    (("%d" % i) for i in o.get_rectangle())))
                self.doc.end_paragraph()

                mime_type = media.get_mime_type()
                if mime_type and mime_type.startswith("image"):
                    filename = media_path_full(self.database, media.get_path())
                    if os.path.exists(filename):
                        self.doc.start_paragraph("PE-Level%d" % min(level, 32))
                        self.doc.add_media(filename,
                                           "single",
                                           4.0,
                                           4.0,
                                           crop=o.get_rectangle())
                        self.doc.end_paragraph()

            desc = get_description(media.get_mime_type())
            if not desc:
                desc = _("unknown")
            self.print_header(level,
                              _("Media Object"),
                              media.get_gramps_id(),
                              _("Mime type"),
                              desc,
                              media.get_privacy(),
                              ref=media)
            self.print_object(level + 1, media)

        if isinstance(o, gramps.gen.lib.Name):
            # group_as, sort_as and display_as are not printed. NameType is
            # printed by the main write_report function
            self.doc.start_paragraph("PE-Level%d" % min(level, 32))
            self.doc.start_bold()
            self.doc.write_text(
                _("Given name(s): Title, Given, Suffix, "
                  "Call Name, Nick Name, Family Nick Name") + " : ")
            self.doc.end_bold()
            self.doc.write_text(", ".join(
                (o.get_title(), o.get_first_name(), o.get_suffix(),
                 o.get_call_name(), o.get_nick_name(),
                 o.get_family_nick_name())))
            self.doc.end_paragraph()

        if isinstance(o, gramps.gen.lib.Note):
            # The NoteType is printed by NoteBase. Whether the note is flowed or
            # not is not printed, but affects the way the note appears
            self.doc.write_styled_note(
                o.get_styledtext(),
                o.get_format(),
                "PE-Level%d" % min(level, 32),
                contains_html=o.get_type() ==
                gramps.gen.lib.notetype.NoteType.HTML_CODE)

        if issubclass(o.__class__, gramps.gen.lib.notebase.NoteBase):
            for n_h in o.get_note_list():
                note = self.database.get_note_from_handle(n_h)
                self.print_header(level, _("Note"), note.get_gramps_id(),
                                  _("Note type"), str(note.get_type()),
                                  note.get_privacy())
                self.print_object(level + 1, note)

        if issubclass(o.__class__, gramps.gen.lib.Person):
            # This is printed by the main write-report function
            pass

        if isinstance(o, gramps.gen.lib.Place):
            # The title, name, type, code and lat/long are printed by PlaceBase
            for placeref in o.get_placeref_list():
                self.print_header(level, _("Parent Place"))
                self.print_object(level + 1, placeref)


#            location = o.get_main_location()
#            if location.get_parish():
#                self.print_header(level, _("Main Location"),
#                                  type_desc=_("Parish"),
#                                  obj_type=location.get_parish())
#            else:
#                self.print_header(level, _("Main Location"))
#
#            self.print_object(level+1, location)
#
            for location in o.get_alternate_locations():
                if location.get_parish():
                    self.print_header(level,
                                      _("Alternate Location"),
                                      type_desc=_("Parish"),
                                      obj_type=location.get_parish())
                else:
                    self.print_header(level, _("Alternate Location"))
                self.print_object(level + 1, location)

        if issubclass(o.__class__, gramps.gen.lib.placebase.PlaceBase) or \
            issubclass(o.__class__, gramps.gen.lib.placeref.PlaceRef):
            if issubclass(o.__class__, gramps.gen.lib.placebase.PlaceBase):
                place_handle = o.get_place_handle()
            else:
                place_handle = o.get_reference_handle()
            if place_handle:
                place = self.database.get_place_from_handle(place_handle)
                if place:
                    place_title = place_displayer.display(self.database, place)
                    self.print_header(level,
                                      _("Place"),
                                      place.get_gramps_id(),
                                      _("Place Title"),
                                      place_title,
                                      privacy=place.get_privacy(),
                                      ref=place)
                    self.doc.start_paragraph("PE-Level%d" % min(level + 1, 32))
                    self.doc.start_bold()
                    self.doc.write_text(_("Name") + " : ")
                    self.doc.end_bold()
                    self.doc.write_text(place.get_name().value)
                    self.doc.start_bold()
                    self.doc.write_text(" " + _("Type") + " : ")
                    self.doc.end_bold()
                    self.doc.write_text(str(place.get_type()))
                    self.doc.start_bold()
                    self.doc.write_text(" " + _("Code") + " : ")
                    self.doc.end_bold()
                    self.doc.write_text(place.get_code())
                    self.doc.end_paragraph()

                    for name in place.get_alternative_names():
                        self.doc.start_paragraph("PE-Level%d" %
                                                 min(level + 1, 32))
                        self.doc.start_bold()
                        self.doc.write_text(_("Alternative Name") + " : ")
                        self.doc.end_bold()
                        self.doc.write_text(name.value)
                        self.doc.end_paragraph()

                    if place.get_longitude() or place.get_latitude():
                        self.doc.start_paragraph("PE-Level%d" %
                                                 min(level + 1, 32))
                        self.doc.start_bold()
                        self.doc.write_text(_("Latitude, Longitude") + " : ")
                        self.doc.end_bold()
                        self.doc.write_text(", ".join(
                            (place.get_longitude(), place.get_latitude())))
                        self.doc.end_paragraph()

                    self.print_object(level + 1, place)

        if issubclass(o.__class__,
                      gramps.gen.lib.primaryobj.BasicPrimaryObject):
            # The Gramps ID is printed by the enclosing object
            pass

        if issubclass(o.__class__, gramps.gen.lib.privacybase.PrivacyBase):
            # The privacy is printed by the enclosing object
            pass

        if isinstance(o, gramps.gen.lib.RepoRef):
            # The media type is printed by source
            self.doc.start_paragraph("PE-Level%d" % min(level, 32))
            self.doc.start_bold()
            self.doc.write_text(_("Call number") + " : ")
            self.doc.end_bold()
            self.doc.write_text(o.get_call_number())
            self.doc.end_paragraph()

            repository_handle = o.get_reference_handle()
            repository = self.database.get_repository_from_handle(
                repository_handle)
            self.print_header(level,
                              _("Repository"),
                              repository.get_gramps_id(),
                              _("Repository type"),
                              str(repository.get_type()),
                              privacy=repository.get_privacy())
            self.print_object(level + 1, repository)

        if isinstance(o, gramps.gen.lib.Repository):
            # the repository type is printed by RepoRef
            pass

        if isinstance(o, gramps.gen.lib.Source):
            # The title, author, abbreviation and publication information are
            # printed by the bibliography code
            #            data_map = o.get_data_map()
            #            for key in data_map.keys():
            #                self.doc.start_paragraph("PE-Level%d" % min(level, 32))
            #                self.doc.start_bold()
            #                self.doc.write_text(_("Data") + ". " + key + " : ")
            #                self.doc.end_bold()
            #                self.doc.write_text(data_map[key])
            #                self.doc.end_paragraph()

            reporef_list = o.get_reporef_list()
            for reporef in reporef_list:
                self.print_header(level,
                                  _("Repository reference"),
                                  type_desc=_("Media type"),
                                  obj_type=str(reporef.get_media_type()),
                                  privacy=reporef.get_privacy())
                self.print_object(level + 1, reporef)

        if isinstance(o, gramps.gen.lib.Surname):
            if o.get_origintype():
                self.print_header(level,
                                  _("Surname"),
                                  type_desc=_("Origin type"),
                                  obj_type=str(o.get_origintype()))
            else:
                self.print_header(level, _("Surname"), privacy=o.get_privacy())
            self.doc.start_paragraph("PE-Level%d" % min(level + 1, 32))
            self.doc.start_bold()
            self.doc.write_text(_("Prefix, surname, connector") + " : ")
            self.doc.end_bold()
            self.doc.write_text(", ".join(
                (o.get_prefix(), o.get_surname(), o.get_connector())))
            if o.get_primary():
                self.doc.write_text(" " + _("{This is the primary surname}"))
            self.doc.end_paragraph()

        if isinstance(o, gramps.gen.lib.surnamebase.SurnameBase):
            surname_list = o.get_surname_list()
            for surname in surname_list:
                self.print_object(level, surname)

        if issubclass(o.__class__, gramps.gen.lib.tagbase.TagBase):
            for tag_handle in o.get_tag_list():
                tag = self.database.get_tag_from_handle(tag_handle)
                self.doc.start_paragraph("PE-Level%d" % min(level, 32))
                self.doc.start_bold()
                self.doc.write_text(_("Tag name") + " : ")
                self.doc.end_bold()
                self.doc.write_text(tag.get_name())
                self.doc.end_paragraph()
                self.print_object(level + 1, tag)

        if issubclass(o.__class__, gramps.gen.lib.Tag):
            # The tag name is printed by TagBase
            if o.get_color() != "#000000000000" or o.get_priority() != 0:
                self.doc.start_paragraph("PE-Level%d" % min(level, 32))
                self.doc.start_bold()
                self.doc.write_text(_("Tag colour and priority") + " : ")
                self.doc.end_bold()
                self.doc.write_text(o.get_color() + ", " +
                                    "%d" % o.get_priority())
                self.doc.end_paragraph()

        if issubclass(o.__class__, gramps.gen.lib.urlbase.UrlBase):
            for url in o.get_url_list():
                self.print_header(level,
                                  _("URL"),
                                  type_desc=_("Type"),
                                  obj_type=str(url.get_type()),
                                  privacy=url.get_privacy())
                self.print_object(level + 1, url)

        if isinstance(o, gramps.gen.lib.Url):
            self.doc.start_paragraph("PE-Level%d" % min(level, 32))
            self.doc.start_bold()
            self.doc.write_text(_("Description and Path") + " : ")
            self.doc.end_bold()
            self.doc.write_text(o.get_description() + ", ")
            path = o.get_path()
            if path:
                mark = IndexMark(path, LOCAL_HYPERLINK)
                self.doc.write_text(path, mark=mark)
            self.doc.end_paragraph()

        return o
Пример #49
0
    def list_people_changed(self, object_type):
        """
        List all records with last change date
        """
        nb_items = 0

        def sort_on_change(handle):
            """ sort records based on the last change time """
            obj = fct(handle)
            timestamp = obj.get_change_time()
            return timestamp

        if object_type == Person:
            fct = self.report.database.get_person_from_handle
            fct_link = self.new_person_link
        elif object_type == Family:
            fct = self.report.database.get_family_from_handle
            fct_link = self.family_link
        elif object_type == Event:
            fct = self.report.database.get_event_from_handle
        elif object_type == Place:
            fct = self.report.database.get_place_from_handle
            fct_link = self.place_link
        elif object_type == Source:
            fct = self.report.database.get_place_from_handle
            fct_link = self.source_link
        elif object_type == Repository:
            fct = self.report.database.get_place_from_handle
            fct_link = self.repository_link
        elif object_type == Media:
            fct = self.report.database.get_place_from_handle
        obj_list = sorted(self.report.obj_dict[object_type],
                          key=sort_on_change, reverse=True)
        with Html("table", class_="list", id="list") as section:
            for handle in obj_list:
                date = obj = None
                name = ""
                obj = fct(handle)
                if object_type == Person:
                    name = fct_link(handle)
                elif object_type == Family:
                    name = self.report.get_family_name(obj)
                    name = fct_link(handle, name)
                elif object_type == Event:
                    otype = obj.get_type()
                    date = obj.get_date_object()
                    if int(otype) in _EVENTMAP:
                        handle_list = set(
                            self.report.database.find_backlink_handles(
                                handle,
                                include_classes=['Family', 'Person']))
                    else:
                        handle_list = set(
                            self.report.database.find_backlink_handles(
                                handle,
                                include_classes=['Person']))
                    if handle_list:
                        name = Html("span", self._(otype.xml_str())+" ")
                        for obj_t, r_handle in handle_list:
                            if obj_t == 'Person':
                                name += self.new_person_link(r_handle)
                            else:
                                srbd = self.report.database
                                fam = srbd.get_family_from_handle(r_handle)
                                srgfn = self.report.get_family_name
                                name += self.family_link(r_handle, srgfn(fam))
                elif object_type == Place:
                    name = _pd.display(self.report.database, obj)
                    name = fct_link(handle, name)
                elif object_type == Source:
                    name = obj.get_title()
                    name = fct_link(handle, name)
                elif object_type == Repository:
                    name = obj.get_name()
                    name = fct_link(handle, name)
                elif object_type == Media:
                    name = obj.get_description()
                    url = self.report.build_url_fname_html(handle, "img")
                    name = Html("a", name, href=url, title=name)
                if obj:
                    timestamp = obj.get_change_time()
                    if timestamp - self.maxdays > 0:
                        nb_items += 1
                        if nb_items > self.nbr:
                            break
                        tims = localtime(timestamp)
                        odat = Date(tims.tm_year, tims.tm_mon, tims.tm_mday)
                        date = self.rlocale.date_displayer.display(odat)
                        date += strftime(' %X', tims)
                        row = Html("tr")
                        section += row
                        row += Html("td", date, class_="date")
                        row += Html("td", name)
        return section
Пример #50
0
 def _createpersonmarkers(self, dbstate, person, comment, fam_id):
     """
     Create all markers for the specified person.
     """
     self.cal = config.get('preferences.calendar-format-report')
     latitude = longitude = ""
     if person:
         # For each event, if we have a place, set a marker.
         for event_ref in person.get_event_ref_list():
             if not event_ref:
                 continue
             role = event_ref.get_role()
             event = dbstate.db.get_event_from_handle(event_ref.ref)
             eyear = event.get_date_object().to_calendar(
                 self.cal).get_year()
             place_handle = event.get_place_handle()
             if place_handle:
                 place = dbstate.db.get_place_from_handle(place_handle)
                 if place:
                     longitude = place.get_longitude()
                     latitude = place.get_latitude()
                     latitude, longitude = conv_lat_lon(
                         latitude, longitude, "D.D8")
                     descr = _pd.display(dbstate.db, place)
                     evt = EventType(event.get_type())
                     descr1 = _("%(eventtype)s : %(name)s") % {
                         'eventtype': evt,
                         'name': _nd.display(person)
                     }
                     # place.get_longitude and place.get_latitude return
                     # one string. We have coordinates when the two values
                     # contains non null string.
                     if longitude and latitude:
                         if not self._present_in_places_list(
                                 2, str(descr1 + descr + str(evt))):
                             self._append_to_places_list(
                                 descr, str(descr1 + descr + str(evt)),
                                 _nd.display(person),
                                 latitude, longitude, role, eyear,
                                 event.get_type(), person.gramps_id,
                                 place.gramps_id, event.gramps_id, fam_id)
                     else:
                         self._append_to_places_without_coord(
                             place.gramps_id, descr)
         family_list = person.get_family_handle_list()
         for family_hdl in family_list:
             family = self.dbstate.db.get_family_from_handle(family_hdl)
             if family is not None:
                 for event_ref in family.get_event_ref_list():
                     if event_ref:
                         event = dbstate.db.get_event_from_handle(
                             event_ref.ref)
                         role = event_ref.get_role()
                         if event.get_place_handle():
                             place_handle = event.get_place_handle()
                             if place_handle:
                                 place = dbstate.db.get_place_from_handle(
                                     place_handle)
                                 if place:
                                     longitude = place.get_longitude()
                                     latitude = place.get_latitude()
                                     (latitude, longitude) = conv_lat_lon(
                                         latitude, longitude, "D.D8")
                                     descr = _pd.display(dbstate.db, place)
                                     evt = EventType(event.get_type())
                                     (father_name, mother_name
                                      ) = self._get_father_and_mother_name(
                                          event)
                                     descr1 = "%s : %s - " % (evt,
                                                              father_name)
                                     descr1 = "%s%s" % (descr1, mother_name)
                                     eyear = event.get_date_object(
                                     ).to_calendar(self.cal).get_year()
                                     if longitude and latitude:
                                         if not self._present_in_places_list(
                                                 2,
                                                 str(descr1 + descr +
                                                     str(evt))):
                                             self._append_to_places_list(
                                                 descr,
                                                 str(descr1 + descr +
                                                     str(evt)),
                                                 _nd.display(person),
                                                 latitude, longitude, role,
                                                 eyear, event.get_type(),
                                                 person.gramps_id,
                                                 place.gramps_id,
                                                 event.gramps_id,
                                                 family.gramps_id)
                                     else:
                                         self._append_to_places_without_coord(
                                             place.gramps_id, descr)
Пример #51
0
 def longname(self):
     return place_displayer.display(self.db, self.place)
Пример #52
0
    def list_notes(self):
        """
        List all notes with last change date
        """
        nb_items = 0
        section = ""

        def sort_on_change(handle):
            """ sort records based on the last change time """
            fct = self.report.database.get_note_from_handle
            obj = fct(handle)
            timestamp = obj.get_change_time()
            return timestamp

        note_list = self.report.database.get_note_handles()
        obj_list = sorted(note_list, key=sort_on_change, reverse=True)
        with Html("table", class_="list", id="list") as section:
            for handle in obj_list:
                show = False
                date = obj = None
                obj = self.report.database.get_note_from_handle(handle)
                if obj:
                    text = html_escape(obj.get()[:50])
                    timestamp = obj.get_change_time()
                    if timestamp - self.maxdays > 0:
                        handle_list = set(
                            self.report.database.find_backlink_handles(
                                handle,
                                include_classes=['Person', 'Family', 'Event',
                                                 'Place', 'Media', 'Source',
                                                 'Citation', 'Repository',
                                                ]))
                        tims = localtime(timestamp)
                        odat = Date(tims.tm_year, tims.tm_mon, tims.tm_mday)
                        date = self.rlocale.date_displayer.display(odat)
                        date += strftime(' %X', tims)
                        if handle_list:
                            srbd = self.report.database
                            srbkref = self.report.bkref_dict
                            for obj_t, r_handle in handle_list:
                                if obj_t == 'Person':
                                    if r_handle in srbkref[Person]:
                                        name = self.new_person_link(r_handle)
                                        show = True
                                elif obj_t == 'Family':
                                    if r_handle in srbkref[Family]:
                                        fam = srbd.get_family_from_handle(
                                            r_handle)
                                        fam = self._("Family")
                                        name = self.family_link(r_handle, fam)
                                        if self.inc_families:
                                            show = True
                                elif obj_t == 'Place':
                                    if r_handle in srbkref[Place]:
                                        plc = srbd.get_place_from_handle(
                                            r_handle)
                                        plcn = _pd.display(self.report.database,
                                                           plc)
                                        name = self.place_link(r_handle, plcn)
                                        if self.inc_places:
                                            show = True
                                elif obj_t == 'Event':
                                    if r_handle in srbkref[Event]:
                                        evt = srbd.get_event_from_handle(
                                            r_handle)
                                        evtn = self._(evt.get_type().xml_str())
                                        name = self.event_link(r_handle, evtn)
                                        if self.inc_events:
                                            show = True
                                elif obj_t == 'Media':
                                    if r_handle in srbkref[Media]:
                                        media = srbd.get_media_from_handle(
                                            r_handle)
                                        evtn = media.get_description()
                                        name = self.media_link(r_handle, evtn,
                                                               evtn,
                                                               usedescr=False)
                                        if self.inc_gallery:
                                            show = True
                                elif obj_t == 'Citation':
                                    if r_handle in srbkref[Citation]:
                                        cit = srbd.get_event_from_handle(
                                            r_handle)
                                        citsrc = cit.source_handle
                                        evtn = self._("Citation")
                                        name = self.source_link(citsrc, evtn)
                                        if self.inc_sources:
                                            show = True
                                elif obj_t == 'Source':
                                    if r_handle in srbkref[Source]:
                                        src = srbd.get_source_from_handle(
                                            r_handle)
                                        evtn = src.get_title()
                                        name = self.source_link(r_handle, evtn)
                                        if self.inc_sources:
                                            show = True
                                elif obj_t == 'Repository':
                                    if r_handle in srbkref[Repository]:
                                        rep = srbd.get_repository_from_handle(
                                            r_handle)
                                        evtn = rep.get_name()
                                        name = self.repository_link(r_handle,
                                                                    evtn)
                                        if self.inc_repository:
                                            show = True
                        if show:
                            row = Html("tr")
                            section += row
                            row += Html("td", date, class_="date")
                            row += Html("td", text)
                            row += Html("td", name)
                            nb_items += 1
                            if nb_items > self.nbr:
                                break
        return section
Пример #53
0
 def _default_format(self, place):
     return _pd.display(self.database, place, date=self.date)
Пример #54
0
 def show_one_person(self, person):
     """
     Create all markers for each people's event in the database which has
     a lat/lon.
     """
     dbstate = self.dbstate
     self.load_kml_files(person)
     for event_ref in person.get_event_ref_list():
         if not event_ref:
             continue
         event = dbstate.db.get_event_from_handle(event_ref.ref)
         self.load_kml_files(event)
         role = event_ref.get_role()
         edate = event.get_date_object().to_calendar(self.cal)
         eyear = str("%04d" % edate.get_year()) + \
                     str("%02d" % edate.get_month()) + \
                     str("%02d" % edate.get_day())
         place_handle = event.get_place_handle()
         if place_handle and event_ref.ref not in self.event_list:
             self.event_list.append(event_ref.ref)
             place = dbstate.db.get_place_from_handle(place_handle)
             if place:
                 longitude = place.get_longitude()
                 latitude = place.get_latitude()
                 latitude, longitude = conv_lat_lon(latitude, longitude,
                                                    "D.D8")
                 descr = _pd.display(dbstate.db, place)
                 evt = EventType(event.get_type())
                 descr1 = _("%(eventtype)s : %(name)s") % {
                     'eventtype': evt,
                     'name': _nd.display(person)
                 }
                 self.load_kml_files(place)
                 # place.get_longitude and place.get_latitude return
                 # one string. We have coordinates when the two values
                 # contains non null string.
                 if longitude and latitude:
                     self.progress.step()
                     self._append_to_places_list(descr, evt,
                                                 _nd.display(person),
                                                 latitude, longitude,
                                                 descr1, eyear,
                                                 event.get_type(),
                                                 person.gramps_id,
                                                 place.gramps_id,
                                                 event.gramps_id, role)
                 else:
                     self._append_to_places_without_coord(
                         place.gramps_id, descr)
     family_list = person.get_family_handle_list()
     for family_hdl in family_list:
         family = self.dbstate.db.get_family_from_handle(family_hdl)
         if family is not None:
             fhandle = family_list[0]  # first is primary
             fam = dbstate.db.get_family_from_handle(fhandle)
             father = mother = None
             handle = fam.get_father_handle()
             if handle:
                 father = dbstate.db.get_person_from_handle(handle)
             descr1 = " - "
             if father:
                 self.already_done.append(handle)
                 descr1 = "%s - " % _nd.display(father)
             handle = fam.get_mother_handle()
             if handle:
                 self.already_done.append(handle)
                 mother = dbstate.db.get_person_from_handle(handle)
             if mother:
                 descr1 = "%s%s" % (descr1, _nd.display(mother))
             for event_ref in family.get_event_ref_list():
                 if event_ref:
                     event = dbstate.db.get_event_from_handle(event_ref.ref)
                     self.load_kml_files(event)
                     role = event_ref.get_role()
                     if event.get_place_handle():
                         place_handle = event.get_place_handle()
                         if (place_handle
                                 and event_ref.ref not in self.event_list):
                             self.event_list.append(event_ref.ref)
                             place = dbstate.db.get_place_from_handle(
                                 place_handle)
                             if place:
                                 longitude = place.get_longitude()
                                 latitude = place.get_latitude()
                                 (latitude, longitude) = conv_lat_lon(
                                     latitude, longitude, "D.D8")
                                 descr = _pd.display(dbstate.db, place)
                                 evt = EventType(event.get_type())
                                 edate = event.get_date_object()
                                 edate = edate.to_calendar(self.cal)
                                 eyear = str("%04d" % edate.get_year()) + \
                                             str("%02d" % edate.get_month())\
                                             + str("%02d" % edate.get_day())
                                 self.load_kml_files(place)
                                 if longitude and latitude:
                                     self.progress.step()
                                     self._append_to_places_list(
                                         descr, evt, _nd.display(person),
                                         latitude, longitude, descr1, eyear,
                                         event.get_type(), person.gramps_id,
                                         place.gramps_id, event.gramps_id,
                                         role)
                                 else:
                                     self._append_to_places_without_coord(
                                         place.gramps_id, descr)
     for pers in [
             self._get_parent(person, True),
             self._get_parent(person, False)
     ]:
         if pers:
             self.show_one_person(pers)
Пример #55
0
    def _createmap(self, active):
        """
        Create all markers for each people's event in the database which has
        a lat/lon.
        @param: active is mandatory but unused in this view. Fix : 10088
        """
        dbstate = self.dbstate
        self.cal = config.get('preferences.calendar-format-report')
        self.place_list = []
        self.place_without_coordinates = []
        self.places_found = []
        self.minlat = self.maxlat = self.minlon = self.maxlon = 0.0
        self.minyear = 9999
        self.maxyear = 0
        latitude = ""
        longitude = ""
        self.nbplaces = 0
        self.nbmarkers = 0
        self.message_layer.clear_messages()
        self.message_layer.set_font_attributes(None, None, None)
        self.kml_layer.clear()
        person_handle = self.uistate.get_active('Person')
        person = None
        if person_handle:
            person = dbstate.db.get_person_from_handle(person_handle)
        if person is not None:
            # For each event, if we have a place, set a marker.
            self.load_kml_files(person)
            self.message_layer.add_message(
                _("Person places for %s") % _nd.display(person))
            for event_ref in person.get_event_ref_list():
                if not event_ref:
                    continue
                event = dbstate.db.get_event_from_handle(event_ref.ref)
                self.load_kml_files(event)
                role = event_ref.get_role()
                eyear = str(
                "%04d" % event.get_date_object().to_calendar(self.cal).get_year()) + \
     str("%02d" % event.get_date_object().to_calendar(self.cal).get_month()) + \
     str("%02d" % event.get_date_object().to_calendar(self.cal).get_day())
                place_handle = event.get_place_handle()
                if place_handle:
                    place = dbstate.db.get_place_from_handle(place_handle)
                    if place:
                        longitude = place.get_longitude()
                        latitude = place.get_latitude()
                        latitude, longitude = conv_lat_lon(
                            latitude, longitude, "D.D8")
                        descr = _pd.display(dbstate.db, place)
                        evt = EventType(event.get_type())
                        descr1 = _("%(eventtype)s : %(name)s") % {
                            'eventtype': evt,
                            'name': _nd.display(person)
                        }
                        self.load_kml_files(place)
                        # place.get_longitude and place.get_latitude return
                        # one string. We have coordinates when the two values
                        # contains non null string.
                        if longitude and latitude:
                            self._append_to_places_list(
                                descr, evt, _nd.display(person),
                                latitude, longitude, descr1, eyear,
                                event.get_type(), person.gramps_id,
                                place.gramps_id, event.gramps_id, role)
                        else:
                            self._append_to_places_without_coord(
                                place.gramps_id, descr)
            family_list = person.get_family_handle_list()
            for family_hdl in family_list:
                family = self.dbstate.db.get_family_from_handle(family_hdl)
                if family is not None:
                    fhandle = family_list[0]  # first is primary
                    fam = dbstate.db.get_family_from_handle(fhandle)
                    father = mother = None
                    handle = fam.get_father_handle()
                    if handle:
                        father = dbstate.db.get_person_from_handle(handle)
                    descr1 = " - "
                    if father:
                        descr1 = "%s - " % _nd.display(father)
                    handle = fam.get_mother_handle()
                    if handle:
                        mother = dbstate.db.get_person_from_handle(handle)
                    if mother:
                        descr1 = "%s%s" % (descr1, _nd.display(mother))
                    for event_ref in family.get_event_ref_list():
                        if event_ref:
                            event = dbstate.db.get_event_from_handle(
                                event_ref.ref)
                            self.load_kml_files(event)
                            role = event_ref.get_role()
                            if event.get_place_handle():
                                place_handle = event.get_place_handle()
                                if place_handle:
                                    place = dbstate.db.get_place_from_handle(
                                        place_handle)
                                    if place:
                                        longitude = place.get_longitude()
                                        latitude = place.get_latitude()
                                        (latitude, longitude) = conv_lat_lon(
                                            latitude, longitude, "D.D8")
                                        descr = _pd.display(dbstate.db, place)
                                        evt = EventType(event.get_type())
                                        eyear = str(
                                        "%04d" % event.get_date_object().to_calendar(self.cal).get_year()) + \
     str("%02d" % event.get_date_object().to_calendar(self.cal).get_month()) + \
     str("%02d" % event.get_date_object().to_calendar(self.cal).get_day())
                                        self.load_kml_files(place)
                                        if longitude and latitude:
                                            self._append_to_places_list(
                                                descr, evt,
                                                _nd.display(person), latitude,
                                                longitude, descr1, eyear,
                                                event.get_type(),
                                                person.gramps_id,
                                                place.gramps_id,
                                                event.gramps_id, role)
                                        else:
                                            self._append_to_places_without_coord(
                                                place.gramps_id, descr)

            self.sort = sorted(self.place_list, key=operator.itemgetter(6))
            self._create_markers()
Пример #56
0
    def run(self, db):
        """
        Performs the actual extraction of information
        """

        self.progress = ProgressMeter(_('Checking Place Titles'), '')
        self.progress.set_pass(_('Looking for place fields'),
                               self.db.get_number_of_places())

        self.name_list = []
        self.place_import = PlaceImport(db)

        for place in db.iter_places():
            descr = place_displayer.display(db, place)
            self.progress.step()

            loc = get_main_location(db, place)
            location = ((loc.get(PlaceType.STREET, '')),
                        (loc.get(PlaceType.LOCALITY, '')),
                        (loc.get(PlaceType.PARISH, '')),
                        (loc.get(PlaceType.CITY, '')),
                        (loc.get(PlaceType.COUNTY, '')),
                        (loc.get(PlaceType.STATE, '')),
                        (loc.get(PlaceType.COUNTRY, '')))
            self.place_import.store_location(location, place.handle)

            if len(place.get_placeref_list()) == 0:

                match = CITY_STATE_ZIP.match(descr.strip())
                if match:
                    data = match.groups()
                    city = data[0]
                    state = data[2]
                    postal = data[5]

                    val = " ".join(state.strip().split()).upper()
                    if state:
                        new_state = STATE_MAP.get(val.upper())
                        if new_state:
                            self.name_list.append(
                                (place.handle, (city, new_state[0], postal,
                                          COUNTRY[new_state[1]])))
                    continue

                # Check if there is a left parant. in the string, might be Swedish laen.
                match = CITY_LAEN.match(descr.strip().replace(","," "))
                if match:
                    data = match.groups()
                    city = data[0]
                    state = '(' + data[1] + ')'
                    postal = None
                    val = " ".join(state.strip().split()).upper()
                    if state:
                        new_state = STATE_MAP.get(val.upper())
                        if new_state:
                            self.name_list.append(
                                (place.handle, (city, new_state[0], postal,
                                          COUNTRY[new_state[1]])))
                    continue
                match = CITY_STATE.match(descr.strip())
                if match:
                    data = match.groups()
                    city = data[0]
                    state = data[1]
                    postal = None
                    if state:
                        m0 = STATE_ZIP.match(state)
                        if m0:
                            (state, postal) = m0.groups()

                    val = " ".join(state.strip().split()).upper()
                    if state:
                        new_state = STATE_MAP.get(val.upper())
                        if new_state:
                            self.name_list.append(
                                (place.handle, (city, new_state[0], postal,
                                          COUNTRY[new_state[1]])))
                    continue

                val = " ".join(descr.strip().split()).upper()
                new_state = STATE_MAP.get(val)
                if new_state:
                    self.name_list.append(
                        (place.handle, (None, new_state[0], None,
                                  COUNTRY[new_state[1]])))
        self.progress.close()

        if self.name_list:
            self.display()
        else:
            self.close()
            from gramps.gui.dialog import OkDialog
            OkDialog(_('No modifications made'),
                     _("No place information could be extracted."))
Пример #57
0
    def load_model(self):
        """
        Objects can have very large backreferences. To avoid blocking the 
        interface up to the moment that the model is created, this method is 
        called via GLib.idle_add.
        WARNING: a consequence of above is that loading can still be happening
            while the GUI using this model is no longer used. Disconnect any
            methods before closing the GUI.
        """
        self.loading = True
        self.count = 0
        for ref in self.sref_list:
            self.count += 1
            dtype = ref[0]
            if dtype == 'Person':
                p = self.db.get_person_from_handle(ref[1])
                if not p:
                    continue
                gid = p.gramps_id
                handle = p.handle
                name = name_displayer.display(p)
            elif dtype == 'Family':
                p = self.db.get_family_from_handle(ref[1])
                if not p:
                    continue
                gid = p.gramps_id
                handle = p.handle
                name = family_name(p, self.db)
            elif dtype == 'Source':
                p = self.db.get_source_from_handle(ref[1])
                if not p:
                    continue
                gid = p.gramps_id
                handle = p.handle
                name = p.get_title()
            elif dtype == 'Citation':
                p = self.db.get_citation_from_handle(ref[1])
                if not p:
                    continue
                gid = p.gramps_id
                handle = p.handle
                name = p.get_page()
            elif dtype == 'Event':
                p = self.db.get_event_from_handle(ref[1])
                if not p:
                    continue
                gid = p.gramps_id
                handle = p.handle
                name = p.get_description()
                if name:
                    name = self.dispstr % {
                        'part1': str(p.get_type()),
                        'part2': name
                    }
                else:
                    name = str(p.get_type())
                part = get_participant_from_event(self.db, ref[1])
                if part:
                    name = self.dispstr % {'part1': name, 'part2': part}
            elif dtype == 'Place':
                p = self.db.get_place_from_handle(ref[1])
                if not p:
                    continue
                name = place_displayer.display(self.db, p)
                gid = p.gramps_id
                handle = p.handle
            elif dtype == 'Repository':
                p = self.db.get_repository_from_handle(ref[1])
                if not p:
                    continue
                name = p.get_name()
                gid = p.gramps_id
                handle = p.handle
            else:
                p = self.db.get_object_from_handle(ref[1])
                if not p:
                    continue
                name = p.get_description()
                gid = p.gramps_id
                handle = p.handle

            # dtype is the class name, i.e. is English
            # We need to use localized string in the model.
            # we also need to keep class names to get the object type,
            # but we don't need to show that in the view.
            self.append(row=[_(dtype), gid, name, handle, dtype])
            yield True
        self.loading = False
        yield False
Пример #58
0
 def _createmap_for_one_event(self, event):
     """
     Create all markers for each people's event in the database which has
     a lat/lon.
     """
     dbstate = self.dbstate
     if self.nbplaces >= self._config.get("geography.max_places"):
         return
     descr1 = descr2 = ""
     if event:
         place_handle = event.get_place_handle()
         eventyear = event.get_date_object().to_calendar(self.cal).get_year()
     else:
         place_handle = None
     if place_handle:
         place = dbstate.db.get_place_from_handle(place_handle)
         if place:
             descr1 = _pd.display(dbstate.db, place)
             longitude = place.get_longitude()
             latitude = place.get_latitude()
             latitude, longitude = conv_lat_lon(latitude, longitude, "D.D8")
             # place.get_longitude and place.get_latitude return
             # one string. We have coordinates when the two values
             # contains non null string.
             if longitude and latitude:
                 person_list = [
                     dbstate.db.get_person_from_handle(ref_handle)
                     for (ref_type, ref_handle) in
                         dbstate.db.find_backlink_handles(event.handle)
                             if ref_type == 'Person'
                               ]
                 if person_list:
                     for person in person_list:
                         if descr2 == "":
                             descr2 = ("%s") % _nd.display(person)
                         else:
                             descr2 = ("%s - %s") % (descr2,
                                                     _nd.display(person))
                 else:
                     # family list ?
                     family_list = [
                         dbstate.db.get_family_from_handle(ref_handle)
                         for (ref_type, ref_handle) in
                             dbstate.db.find_backlink_handles(event.handle)
                                 if ref_type == 'Family'
                                   ]
                     if family_list:
                         for family in family_list:
                             father = mother = None
                             hdle = family.get_father_handle()
                             if hdle:
                                 father = dbstate.db.get_person_from_handle(
                                                                        hdle)
                             hdle = family.get_mother_handle()
                             if hdle:
                                 mother = dbstate.db.get_person_from_handle(
                                                                        hdle)
                             descr2 = ("%(father)s - %(mother)s") % {
                'father': _nd.display(father) if father is not None else "?",
                'mother': _nd.display(mother) if mother is not None else "?"
                                           }
                     else:
                         descr2 = _("incomplete or unreferenced event ?")
                 self._append_to_places_list(descr1, None,
                                             None,
                                             latitude, longitude,
                                             descr2,
                                             eventyear,
                                             event.get_type(),
                                             None, # person.gramps_id
                                             place.gramps_id,
                                             event.gramps_id,
                                             None
                                             )
Пример #59
0
    def _createmap(self, person, color, place_list, reference):
        """
        Create all markers for each people's event in the database which has 
        a lat/lon.
        """
        dbstate = self.dbstate
        self.cal = config.get('preferences.calendar-format-report')
        self.place_list = place_list
        self.place_without_coordinates = []
        self.minlat = self.maxlat = self.minlon = self.maxlon = 0.0
        self.minyear = 9999
        self.maxyear = 0
        latitude = ""
        longitude = ""
        if person is not None:
            # For each event, if we have a place, set a marker.
            for event_ref in person.get_event_ref_list():
                if not event_ref:
                    continue
                event = dbstate.db.get_event_from_handle(event_ref.ref)
                role = event_ref.get_role()
                try:
                    date = event.get_date_object().to_calendar(self.cal)
                except:
                    continue
                eyear = str("%04d" % date.get_year()) + \
                          str("%02d" % date.get_month()) + \
                          str("%02d" % date.get_day())
                place_handle = event.get_place_handle()
                if place_handle:
                    place = dbstate.db.get_place_from_handle(place_handle)
                    if place:
                        longitude = place.get_longitude()
                        latitude = place.get_latitude()
                        latitude, longitude = conv_lat_lon(latitude,
                                                           longitude, "D.D8")
                        descr = _pd.display(dbstate.db, place)
                        evt = EventType(event.get_type())
                        descr1 = _("%(eventtype)s : %(name)s") % {
                                        'eventtype': evt,
                                        'name': _nd.display(person)}
                        # place.get_longitude and place.get_latitude return
                        # one string. We have coordinates when the two values
                        # contains non null string.
                        if ( longitude and latitude ):
                            self._append_to_places_list(descr, evt,
                                                        _nd.display(person),
                                                        latitude, longitude,
                                                        descr1, eyear,
                                                        event.get_type(),
                                                        person.gramps_id,
                                                        place.gramps_id,
                                                        event.gramps_id,
                                                        role
                                                        )
                        else:
                            self._append_to_places_without_coord(
                                                        place.gramps_id, descr)
            family_list = person.get_family_handle_list()
            descr1 = " - "
            for family_hdl in family_list:
                family = self.dbstate.db.get_family_from_handle(family_hdl)
                if family is not None:
                    fhandle = family_list[0] # first is primary
                    fam = dbstate.db.get_family_from_handle(fhandle)
                    handle = fam.get_father_handle()
                    father = dbstate.db.get_person_from_handle(handle)
                    if father:
                        descr1 = "%s - " % _nd.display(father)
                    handle = fam.get_mother_handle()
                    mother = dbstate.db.get_person_from_handle(handle)
                    if mother:
                        descr1 = "%s%s" % ( descr1, _nd.display(mother))
                    for event_ref in family.get_event_ref_list():
                        if event_ref:
                            event = dbstate.db.get_event_from_handle(
                                            event_ref.ref)
                            role = event_ref.get_role()
                            if event.get_place_handle():
                                place_handle = event.get_place_handle()
                                if place_handle:
                                    place = dbstate.db.get_place_from_handle(
                                                    place_handle)
                                    if place:
                                        longitude = place.get_longitude()
                                        latitude = place.get_latitude()
                                        latitude, longitude = conv_lat_lon(
                                                  latitude, longitude, "D.D8")
                                        descr = _pd.display(dbstate.db, place)
                                        evt = EventType(
                                                  event.get_type())
                                        eyear = str("%04d" % event.get_date_object().to_calendar(self.cal).get_year()) + \
                                                  str("%02d" % event.get_date_object().to_calendar(self.cal).get_month()) + \
                                                  str("%02d" % event.get_date_object().to_calendar(self.cal).get_day())
                                        if ( longitude and latitude ):
                                            self._append_to_places_list(descr,
                                                 evt, _nd.display(person),
                                                 latitude, longitude,
                                                 descr1, eyear,
                                                 event.get_type(),
                                                 person.gramps_id,
                                                 place.gramps_id,
                                                 event.gramps_id,
                                                 role
                                                 )
                                        else:
                                            self._append_to_places_without_coord( place.gramps_id, descr)

            sort1 = sorted(self.place_list, key=operator.itemgetter(6))
            self.draw(None, sort1, color, reference)
            # merge with the last results
            merge_list = []
            for the_list in self.sort, sort1 : merge_list += the_list
            self.sort = sorted(merge_list, key=operator.itemgetter(6))
Пример #60
0
 def get_label(self, place):
     place_title = place_displayer.display(self.db, place)
     return "%s [%s]" % (place_title, place.gramps_id)