Пример #1
0
    def __init__(self, dbstate, user, options_class, name, callback=None):
        uistate = user.uistate
        self.label = _("Gender Statistics tool")
        tool.Tool.__init__(self, dbstate, options_class, name)

        stats_list = []
        for name, value in dbstate.db.genderStats.stats.items():
            stats_list.append(
                (name,)
                + value
                + (_GENDER[dbstate.db.genderStats.guess_gender(name)],)
                )

        if uistate:
            ManagedWindow.__init__(self, uistate, [], self.__class__)

            titles = [(_('Name'), 0, 100),
                      (_('Male'), 1, 70, INTEGER),
                      (_('Female'), 2, 70, INTEGER),
                      (_('Unknown'), 3, 90, INTEGER),
                      (_('Guess'), 4, 70)]

            treeview = Gtk.TreeView()
            model = ListModel(treeview, titles)
            for entry in sorted(stats_list):
                model.add(entry, entry[0])

            s = Gtk.ScrolledWindow()
            s.add(treeview)
            dialog = Gtk.Dialog()
            dialog.add_button(_('_Close'), Gtk.ResponseType.CLOSE)
            dialog.connect('response', self._response)
            dialog.vbox.pack_start(s, expand=True, fill=True, padding=0)
            self.set_window(dialog, None, self.label)
            self.setup_configs('interface.dumpgenderstats', 420, 300)
            self.show()

        else:
            if len(_('Name')) < 16:
                print('%s%s%s' % (_('Name'),
                                  " " * (16 - len(_('Name'))),
                                  _('Male')),
                      '\t%s'*3 % (_('Female'), _('Unknown'), _('Guess')))
            else:
                print(_('Name'), '\t%s'*4 % (_('Male'), _('Female'),
                                             _('Unknown'), _('Guess')))
            print()
            for entry in sorted(stats_list):
                if len(entry[0]) < 16:
                    print('%s%s%s' % (entry[0],
                                      " " * (16 - len(entry[0])),
                                      entry[1]),
                          '\t%s'*3 % (entry[2:]))
                else:
                    print(entry[0], '\t%s'*4 % (entry[1:]))
Пример #2
0
class Backlinks(Gramplet):
    """
    Displays the back references for an object.
    """
    def init(self):
        self.gui.WIDGET = self.build_gui()
        self.gui.get_container_widget().remove(self.gui.textview)
        self.gui.get_container_widget().add(self.gui.WIDGET)
        self.gui.WIDGET.show()

    def build_gui(self):
        """
        Build the GUI interface.
        """
        top = Gtk.TreeView()
        titles = [(_('Type'), 1, 100),
                  (_('Name'), 2, 100),
                  ('', 3, 1), #hidden column for the handle
                  ('', 4, 1)] #hidden column for non-localized object type 
        self.model = ListModel(top, titles, event_func=self.cb_double_click)
        return top
        
    def display_backlinks(self, active_handle):
        """
        Display the back references for an object.
        """
        for classname, handle in \
                        self.dbstate.db.find_backlink_handles(active_handle):
            name = navigation_label(self.dbstate.db, classname, handle)[0]
            self.model.add((_(classname), name, handle, classname))
        self.set_has_data(self.model.count > 0)

    def get_has_data(self, active_handle):
        """
        Return True if the gramplet has data, else return False.
        """
        if active_handle is None:
            return False
        for handle in self.dbstate.db.find_backlink_handles(active_handle):
            return True
        return False
        
    def cb_double_click(self, treeview):
        """
        Handle double click on treeview.
        """
        (model, iter_) = treeview.get_selection().get_selected()
        if not iter_:
            return

        (objclass, handle) = (model.get_value(iter_, 3), 
                              model.get_value(iter_, 2))

        edit_object(self.dbstate, self.uistate, objclass, handle)
Пример #3
0
class Attributes(Gramplet):
    """
    Displays the attributes of an object.
    """
    def init(self):
        self.gui.WIDGET = self.build_gui()
        self.gui.get_container_widget().remove(self.gui.textview)
        self.gui.get_container_widget().add(self.gui.WIDGET)
        self.gui.WIDGET.show()

    def build_gui(self):
        """
        Build the GUI interface.
        """
        tip = _('Double-click on a row to view a quick report showing '
                'all people with the selected attribute.')
        self.set_tooltip(tip)
        top = Gtk.TreeView()
        titles = [(_('Key'), 1, 100),
                  (_('Value'), 2, 100)]
        self.model = ListModel(top, titles, event_func=self.display_report)
        return top

    def display_attributes(self, obj):
        """
        Display the attributes of an object.
        """
        for attr in obj.get_attribute_list():
            self.model.add((str(attr.get_type()), attr.get_value()))
        self.set_has_data(self.model.count > 0)

    def display_report(self, treeview):
        """
        Display the quick report for matching attribute key.
        """
        model, iter_ = treeview.get_selection().get_selected()
        if iter_:
            key = model.get_value(iter_, 0)
            run_quick_report_by_name(self.dbstate,
                                     self.uistate,
                                     'attribute_match',
                                     key)

    def get_has_data(self, obj):
        """
        Return True if the gramplet has data, else return False.
        """
        if obj is None:
            return False
        if obj.get_attribute_list():
            return True
        return False
Пример #4
0
    def __init__(self, dbstate, user, options_class, name, callback=None):
        uistate = user.uistate
        self.label = _("Associations state tool")
        tool.Tool.__init__(self, dbstate, options_class, name)
        if uistate:
            ManagedWindow.__init__(self,uistate,[],
                                                 self.__class__)

        stats_list = []

        plist = dbstate.db.get_person_handles(sort_handles=True)

        for handle in plist:
            person = dbstate.db.get_person_from_handle(handle)
            name1 = name_displayer.display(person)
            refs = person.get_person_ref_list()
            if refs:
                for ref in person.serialize()[-1]:
                    (a, b, c, two, value) = ref
                    person2 = dbstate.db.get_person_from_handle(two)
                    name2 = name_displayer.display(person2)
                    stats_list.append((name1, value, name2))

        if uistate:
            titles = [
                (_('Name'), 0, 200),
                (_('Type of link'), 1, 200),
                (_('Of'), 2, 200),
                ]

            treeview = Gtk.TreeView()
            model = ListModel(treeview, titles)
            for entry in stats_list:
                model.add(entry, entry[0])

            window = Gtk.Window()
            window.set_default_size(800, 600)
            s = Gtk.ScrolledWindow()
            s.add(treeview)
            window.add(s)
            window.show_all()
            self.set_window(window, None, self.label)
            self.show()

        else:
            print('\t%s'*3 % ('Name','Type of link','Of'))
            print()
            for entry in stats_list:
                print('\t%s'*3 % entry)
Пример #5
0
 def __init__(self, uistate, data, parent):
     super().__init__(uistate, [], self)
     self.window = Gtk.Dialog("Gramp")
     self.set_window(self.window, None, _("Database Information"))
     self.window.set_modal(True)
     self.ok = self.window.add_button(_("_OK"), Gtk.ResponseType.OK)
     self.ok.connect("clicked", self.on_ok_clicked)
     self.window.set_position(Gtk.WindowPosition.CENTER)
     self.window.set_default_size(600, 400)
     s = Gtk.ScrolledWindow()
     titles = [(_("Setting"), 0, 150), (_("Value"), 1, 400)]
     treeview = Gtk.TreeView()
     model = ListModel(treeview, titles)
     for key, value in sorted(data.items()):
         model.add((key, str(value)), key)
     s.add(treeview)
     self.window.vbox.pack_start(s, True, True, 0)
     self.show()
Пример #6
0
    def __init__(self, dbstate, user, options_class, name, callback=None):
        uistate = user.uistate
        self.label = _("Gender Statistics tool")
        tool.Tool.__init__(self, dbstate, options_class, name)
        if uistate:
            ManagedWindow.__init__(self,uistate,[],
                                                 self.__class__)

        stats_list = []
        for name, value in dbstate.db.genderStats.stats.items():
            stats_list.append(
                (name,)
                + value
                + (_GENDER[dbstate.db.genderStats.guess_gender(name)],)
                )

        if uistate:
            titles = [
                (_('Name'),0,100),
                (_('Male'),1,70,INTEGER),
                (_('Female'),2,70,INTEGER),
                (_('Unknown'),3,70,INTEGER),
                (_('Guess'),4,70)
                ]

            treeview = Gtk.TreeView()
            model = ListModel(treeview, titles)
            for entry in stats_list:
                model.add(entry, entry[0])

            window = Gtk.Window()
            window.set_default_size(400, 300)
            s = Gtk.ScrolledWindow()
            s.add(treeview)
            window.add(s)
            window.show_all()
            self.set_window(window, None, self.label)
            self.show()

        else:
            print('\t%s'*5 % ('Name','Male','Female','Unknown','Guess'))
            print()
            for entry in stats_list:
                print('\t%s'*5 % entry)
Пример #7
0
 def __init__(self, uistate, data, track):
     super().__init__(uistate, track, self, modal=True)
     self.window = Gtk.Dialog()
     self.set_window(self.window, None, _("Database Information"))
     self.setup_configs('interface.information', 600, 400)
     self.ok = self.window.add_button(_('_OK'), Gtk.ResponseType.OK)
     self.ok.connect('clicked', self.on_ok_clicked)
     s = Gtk.ScrolledWindow()
     titles = [
         (_('Setting'), 0, 150),
         (_('Value'), 1, 400)
     ]
     treeview = Gtk.TreeView()
     model = ListModel(treeview, titles)
     for key, value in sorted(data.items()):
         model.add((key, str(value),), key)
     s.add(treeview)
     self.window.vbox.pack_start(s, True, True, 0)
     self.show()
Пример #8
0
class Attributes(Gramplet):
    """
    Displays the attributes of an object.
    """
    def init(self):
        self.gui.WIDGET = self.build_gui()
        self.gui.get_container_widget().remove(self.gui.textview)
        self.gui.get_container_widget().add_with_viewport(self.gui.WIDGET)
        self.gui.WIDGET.show()

    def build_gui(self):
        """
        Build the GUI interface.
        """
        tip = _('Double-click on a row to edit the object containing the '
                'selected attribute.')
        self.set_tooltip(tip)
        top = Gtk.TreeView()
        titles = [(_('Date'), 1, 100),
                  ('', 1, 100),
                  (_('Key'), 2, 100),
                  (_('Value'), 3, 100),
                  ('', NOSORT, 50,)
                 ]
        self.model = ListModel(top, titles, event_func=self._display_editor)
        return top

    def add_attributes(self, obj, date_object=None):
        """
        Add the attributes of an object to the model.
        """
        event_date = event_sort = handle = ''
        if date_object is not None:
            event_date = gramps.gen.datehandler.displayer.display(date_object)
            event_sort = '%012d' % date_object.get_sort_value()

        try:
            handle = obj.get_handle()
        except AttributeError:
            handle = obj.ref
         
        for attr in obj.get_attribute_list():
            self.model.add((event_date,
                            event_sort,
                            str(attr.get_type()),
                            attr.get_value(),
                            handle
                            ))

    def display_attributes(self, obj):
        """
        Display the attributes of an object.
        """
        self.add_attributes(obj)

        for event_ref in obj.get_event_ref_list():
            event = self.dbstate.db.get_event_from_handle(event_ref.ref)
            event_date = event.get_date_object()
            self.add_attributes(event, event_date)
            self.add_attributes(event_ref, event_date)

        self.set_has_data(self.model.count > 0)
        
    def _display_editor(self, treeview):
        """
        Display the appropriate editor window for the attribute.
        """
        pass

    def get_has_data(self, obj):
        """
        Return True if the gramplet has data, else return False.
        """
        if obj is None: 
            return False
        if obj.get_attribute_list():
            return True
        for event_ref in obj.get_event_ref_list():
            if event_ref.get_attribute_list():
                return True
        return False

    def _get_event_ref(self, event):
        """
        Return the event reference belonging to the active person or
        family for the given event. 
        """
        for event_ref in self.object_for_update.get_event_ref_list():
            if event_ref.ref == event.get_handle():
                return event_ref
        return None

    def _object_edited(self, ref, event):
        pass
Пример #9
0
class GeoEvents(Gramplet, DbGUIElement):
    def __init__(self, gui, nav_group=0):
        Gramplet.__init__(self, gui, nav_group)
        DbGUIElement.__init__(self, self.dbstate.db)

    """
    Displays the events for a person or family.
    """

    def init(self):
        self.gui.WIDGET = self.build_gui()
        self.gui.get_container_widget().remove(self.gui.textview)
        self.gui.get_container_widget().add(self.gui.WIDGET)
        self.gui.WIDGET.show()

    def _connect_db_signals(self):
        """
        called on init of DbGUIElement, connect to db as required.
        """
        self.callman.register_callbacks({'event-update': self.changed})
        self.callman.connect_all(keys=['event'])

    def changed(self, handle):
        """
        Called when a registered event is updated.
        """
        self.update()

    def build_gui(self):
        """
        Build the GUI interface.
        """
        tip = _('Right-click on a row to edit the selected event'
                ' or the related place.')
        self.set_tooltip(tip)
        top = Gtk.TreeView()
        top.set_hover_selection(True)
        titles = [
            (
                '',
                NOSORT,
                50,
            ),
            (_('Type'), 1, 100),
            (_('Description'), 2, 250),
            (_('Date'), 3, 160),
            ('', NOSORT, 50),
            (_('Place'), 4, 300),
            (_('Id'), 5, 80),
            (_('Latitude'), 6, 130),
            (_('Longitude'), 7, 130),
        ]
        self.model = ListModel(top, titles, right_click=self.menu_edit)
        return top

    def add_event_ref(self, event_ref, spouse=None, name=""):
        """
        Add an event to the model.
        """
        self.callman.register_handles({'event': [event_ref.ref]})
        event = self.dbstate.db.get_event_from_handle(event_ref.ref)
        event_date = get_date(event)
        event_sort = '%012d' % event.get_date_object().get_sort_value()
        place_name = place_displayer.display_event(self.dbstate.db, event)
        place_handle = event.get_place_handle()
        place_id = latitude = longitude = ""
        if place_handle:
            plc = self.dbstate.db.get_place_from_handle(place_handle)
            if plc:
                place_id = plc.get_gramps_id()
                latitude = plc.get_latitude()
                longitude = plc.get_longitude()
                latitude, longitude = conv_lat_lon(latitude, longitude, "D.D8")

        description = event.get_description()
        if description == "":
            description = name

        self.model.add((event.get_handle(), str(event.get_type()), description,
                        event_date, event_sort, place_name, place_id, latitude,
                        longitude))

    def menu_edit(self, treeview, event):
        """
        Show a menu to select either Edit the selected event or
        the Place related to this event.
        """
        self.menu = Gtk.Menu()
        menu = self.menu
        menu.set_title(_('Edit'))
        title = _('Edit the event')
        add_item = Gtk.MenuItem(label=title)
        add_item.connect("activate", self.edit_event, treeview)
        add_item.show()
        menu.append(add_item)
        title = _('Edit the place')
        add_item = Gtk.MenuItem(label=title)
        add_item.connect("activate", self.edit_place, treeview)
        add_item.show()
        menu.append(add_item)
        menu.show()
        menu.popup(None, None, None, None, event.button, event.time)

    def edit_place(self, menuitem, treeview):
        """
        Edit the place related to the selected event.
        """
        model, iter_ = treeview.get_selection().get_selected()
        if iter_:
            handle = model.get_value(iter_, 0)
            try:
                event = self.dbstate.db.get_event_from_handle(handle)
                place_handle = event.get_place_handle()
                place_id = latitude = longitude = ""
                if place_handle:
                    plc = self.dbstate.db.get_place_from_handle(place_handle)
                    EditPlace(self.dbstate, self.uistate, [], plc)
            except WindowActiveError:
                pass

    def edit_event(self, menuitem, treeview):
        """
        Edit the selected event.
        """
        model, iter_ = treeview.get_selection().get_selected()
        if iter_:
            handle = model.get_value(iter_, 0)
            try:
                event = self.dbstate.db.get_event_from_handle(handle)
                EditEvent(self.dbstate, self.uistate, [], event)
            except WindowActiveError:
                pass
Пример #10
0
class ShowMatches(ManagedWindow):
    def __init__(self, dbstate, uistate, track, the_list, the_map, callback):
        ManagedWindow.__init__(self, uistate, track, self.__class__)

        self.dellist = {}
        self.list = the_list
        self.map = the_map
        self.length = len(self.list)
        self.update = callback
        self.db = dbstate.db
        self.dbstate = dbstate
        self.uistate = uistate

        top = Glade(toplevel="mergelist")
        window = top.toplevel
        self.set_window(window, top.get_object('title'), _('Potential Merges'))

        self.mlist = top.get_object("mlist")
        top.connect_signals({
            "destroy_passed_object": self.close,
            "on_do_merge_clicked": self.on_do_merge_clicked,
            "on_help_show_clicked": self.on_help_clicked,
            "on_delete_show_event": self.close,
            "on_merge_ok_clicked": self.__dummy,
            "on_help_clicked": self.__dummy,
            "on_delete_merge_event": self.__dummy,
            "on_delete_event": self.__dummy,
        })

        mtitles = [(_('Rating'), 3, 75), (_('First Person'), 1, 200),
                   (_('Second Person'), 2, 200), ('', -1, 0)]
        self.list = ListModel(self.mlist,
                              mtitles,
                              event_func=self.on_do_merge_clicked)

        self.redraw()
        self.show()

    def build_menu_names(self, obj):
        return (_("Merge candidates"), None)

    def on_help_clicked(self, obj):
        """Display the relevant portion of GRAMPS manual"""

        display_help(WIKI_HELP_PAGE, WIKI_HELP_SEC)

    def redraw(self):
        list = []
        for p1key, p1data in self.map.items():
            if p1key in self.dellist:
                continue
            (p2key, c) = p1data
            if p1key == p2key:
                continue
            list.append((c, p1key, p2key))

        self.list.clear()
        for (c, p1key, p2key) in list:
            c1 = "%5.2f" % c
            c2 = "%5.2f" % (100 - c)
            p1 = self.db.get_person_from_handle(p1key)
            p2 = self.db.get_person_from_handle(p2key)
            if not p1 or not p2:
                continue
            pn1 = name_displayer.display(p1)
            pn2 = name_displayer.display(p2)
            self.list.add([c1, pn1, pn2, c2], (p1key, p2key))

    def on_do_merge_clicked(self, obj):
        store, iter = self.list.selection.get_selected()
        if not iter:
            return

        (self.p1, self.p2) = self.list.get_object(iter)
        MergePerson(self.dbstate, self.uistate, self.p1, self.p2,
                    self.on_update, True)

    def on_update(self):
        if self.db.has_person_handle(self.p1):
            phoenix = self.p1
            titanic = self.p2
        else:
            phoenix = self.p2
            titanic = self.p1

        self.dellist[titanic] = phoenix
        for key, data in self.dellist.items():
            if data == titanic:
                self.dellist[key] = phoenix
        self.update()
        self.redraw()

    def update_and_destroy(self, obj):
        self.update(1)
        self.close()

    def __dummy(self, obj):
        """dummy callback, needed because a shared glade file is used for
        both toplevel windows and all signals must be handled.
        """
        pass
Пример #11
0
class Ancestor(Gramplet):

    def init(self):
        self.gui.WIDGET = self.build_gui()
        self.gui.get_container_widget().remove(self.gui.textview)
        self.gui.get_container_widget().add(self.gui.WIDGET)
        self.gui.WIDGET.show()

    def build_gui(self):
        """
        Build the GUI interface.
        """
        self.view = Gtk.TreeView()
        self.view.set_tooltip_column(3)
        titles = [(_('Name'), 0, 230),
                  (_('Birth'), 2, 100),
                  ('', NOSORT, 1),
                  ('', NOSORT, 1), # tooltip
                  ('', NOSORT, 100)] # handle
        self.model = ListModel(self.view, titles, list_mode="tree",
                               event_func=self.cb_double_click)
        return self.view

    def get_has_data(self, active_handle):
        """
        Return True if the gramplet has data, else return False.
        """
        if active_handle:
            person = self.dbstate.db.get_person_from_handle(active_handle)
            if person:
                family_handle = person.get_main_parents_family_handle()
                family = self.dbstate.db.get_family_from_handle(family_handle)
                if family and (family.get_father_handle() or
                               family.get_mother_handle()):
                    return True
        return False

    def cb_double_click(self, treeview):
        """
        Handle double click on treeview.
        """
        (model, iter_) = treeview.get_selection().get_selected()
        if not iter_:
            return

        try:
            handle = model.get_value(iter_, 4)
            person = self.dbstate.db.get_person_from_handle(handle)
            EditPerson(self.dbstate, self.uistate, [], person)
        except WindowActiveError:
            pass

    def db_changed(self):
        self.update()

    def active_changed(self, handle):
        self.update()

    def update_has_data(self):
        active_handle = self.get_active('Person')
        if active_handle:
            self.set_has_data(self.get_has_data(active_handle))
        else:
            self.set_has_data(False)

    def main(self):
        active_handle = self.get_active('Person')
        self.model.clear()
        if active_handle:
            self.add_to_tree(1, None, active_handle)
            self.view.expand_all()
            self.set_has_data(self.get_has_data(active_handle))
        else:
            self.set_has_data(False)

    def add_to_tree(self, depth, parent_id, person_handle):
        if depth > config.get('behavior.generation-depth'):
            return

        person = self.dbstate.db.get_person_from_handle(person_handle)
        name = name_displayer.display(person)

        birth = get_birth_or_fallback(self.dbstate.db, person)
        death = get_death_or_fallback(self.dbstate.db, person)

        birth_text = birth_date = birth_sort = ''
        if birth:
            birth_date = get_date(birth)
            birth_sort = '%012d' % birth.get_date_object().get_sort_value()
            birth_text = _('%(abbr)s %(date)s') % \
                         {'abbr': birth.type.get_abbreviation(),
                          'date': birth_date}

        death_date = death_sort = death_text = ''
        if death:
            death_date = get_date(death)
            death_sort = '%012d' % death.get_date_object().get_sort_value()
            death_text = _('%(abbr)s %(date)s') % \
                         {'abbr': death.type.get_abbreviation(),
                          'date': death_date}

        tooltip = name + '\n' + birth_text + '\n' + death_text

        label = _('%(depth)s. %(name)s') % {'depth': depth, 'name': name}
        item_id = self.model.add([label, birth_date, birth_sort,
                                  tooltip, person_handle], node=parent_id)

        family_handle = person.get_main_parents_family_handle()
        family = self.dbstate.db.get_family_from_handle(family_handle)
        if family:
            if family.get_father_handle():
                self.add_to_tree(depth + 1, item_id, family.get_father_handle())
            if family.get_mother_handle():
                self.add_to_tree(depth + 1, item_id, family.get_mother_handle())

        return item_id
Пример #12
0
class ShowMatches(ManagedWindow):

    def __init__(self, dbstate, uistate, track, the_list, the_map, callback):
        ManagedWindow.__init__(self,uistate,track,self.__class__)

        self.dellist = {}
        self.list = the_list
        self.map = the_map
        self.length = len(self.list)
        self.update = callback
        self.db = dbstate.db
        self.dbstate = dbstate
        self.uistate = uistate

        top = Glade(toplevel="mergelist")
        window = top.toplevel
        self.set_window(window, top.get_object('title'),
                        _('Potential Merges'))

        self.mlist = top.get_object("mlist")
        top.connect_signals({
            "destroy_passed_object" : self.close,
            "on_do_merge_clicked"   : self.on_do_merge_clicked,
            "on_help_show_clicked"  : self.on_help_clicked,
            "on_delete_show_event"  : self.close,
            "on_merge_ok_clicked"   : self.__dummy,
            "on_help_clicked"       : self.__dummy,
            "on_delete_merge_event" : self.__dummy,
            "on_delete_event"       : self.__dummy,
            })

        mtitles = [
                (_('Rating'),3,75),
                (_('First Person'),1,200),
                (_('Second Person'),2,200),
                ('',-1,0)
                ]
        self.list = ListModel(self.mlist,mtitles,
                              event_func=self.on_do_merge_clicked)

        self.redraw()
        self.show()

    def build_menu_names(self, obj):
        return (_("Merge candidates"),None)

    def on_help_clicked(self, obj):
        """Display the relevant portion of GRAMPS manual"""

        display_help(WIKI_HELP_PAGE , WIKI_HELP_SEC)
    def redraw(self):
        list = []
        for p1key, p1data in self.map.items():
            if p1key in self.dellist:
                continue
            (p2key,c) = p1data
            if p1key == p2key:
                continue
            list.append((c,p1key,p2key))

        self.list.clear()
        for (c,p1key,p2key) in list:
            c1 = "%5.2f" % c
            c2 = "%5.2f" % (100-c)
            p1 = self.db.get_person_from_handle(p1key)
            p2 = self.db.get_person_from_handle(p2key)
            if not p1 or not p2:
                continue
            pn1 = name_displayer.display(p1)
            pn2 = name_displayer.display(p2)
            self.list.add([c1, pn1, pn2,c2],(p1key,p2key))

    def on_do_merge_clicked(self, obj):
        store,iter = self.list.selection.get_selected()
        if not iter:
            return

        (self.p1,self.p2) = self.list.get_object(iter)
        MergePerson(self.dbstate, self.uistate, self.p1, self.p2,
                    self.on_update, True)

    def on_update(self):
        if self.db.has_person_handle(self.p1):
            phoenix = self.p1
            titanic = self.p2
        else:
            phoenix = self.p2
            titanic = self.p1

        self.dellist[titanic] = phoenix
        for key, data in self.dellist.items():
            if data == titanic:
                self.dellist[key] = phoenix
        self.update()
        self.redraw()

    def update_and_destroy(self, obj):
        self.update(1)
        self.close()

    def __dummy(self, obj):
        """dummy callback, needed because a shared glade file is used for
        both toplevel windows and all signals must be handled.
        """
        pass
Пример #13
0
class FamilyChildren(Children):
    """
    Displays the children of a family.
    """
    def build_gui(self):
        """
        Build the GUI interface.
        """
        tip = _('Double-click on a row to edit the selected child.')
        self.set_tooltip(tip)
        top = Gtk.TreeView()
        titles = [('', NOSORT, 50,),
                  (_('Child'), 1, 250),
                  (_('Birth Date'), 3, 100),
                  ('', 3, 100),
                  (_('Death Date'), 5, 100),
                  ('', 5, 100)]
        self.model = ListModel(top, titles, event_func=self.edit_person)
        return top

    def db_changed(self):
        self.connect(self.dbstate.db, 'family-update', self.update)
        self.connect_signal('Family', self.update)  # familiy active-changed
        self.connect(self.dbstate.db, 'person-update', self.update)

    def main(self):
        active_handle = self.get_active('Family')
        self.model.clear()
        if active_handle:
            family = self.dbstate.db.get_family_from_handle(active_handle)
            self.display_family(family)
        else:
            self.set_has_data(False)

    def update_has_data(self):
        active_handle = self.get_active('Family')
        if active_handle:
            active = self.dbstate.db.get_family_from_handle(active_handle)
            self.set_has_data(self.get_has_data(active))
        else:
            self.set_has_data(False)

    def get_has_data(self, active_family):
        """
        Return True if the gramplet has data, else return False.
        """
        if active_family is None:
            return False
        if active_family.get_child_ref_list():
            return True
        return False

    def display_family(self, family):
        """
        Display the children of given family.
        """
        for child_ref in family.get_child_ref_list():
            child = self.dbstate.db.get_person_from_handle(child_ref.ref)
            self.add_child(child)
        self.set_has_data(self.model.count > 0)

    def add_child(self, child):
        """
        Add a child to the model.
        """
        name = name_displayer.display(child)
        birth = get_birth_or_fallback(self.dbstate.db, child)
        birth_date, birth_sort, birth_place = self.get_date_place(birth)
        death = get_death_or_fallback(self.dbstate.db, child)
        death_date, death_sort, death_place = self.get_date_place(death)
        self.model.add((child.get_handle(),
                        name,
                        birth_date,
                        birth_sort,
                        death_date,
                        death_sort))
Пример #14
0
class Ancestor(Gramplet):
    def init(self):
        self.gui.WIDGET = self.build_gui()
        self.gui.get_container_widget().remove(self.gui.textview)
        self.gui.get_container_widget().add(self.gui.WIDGET)
        self.gui.WIDGET.show()

    def build_gui(self):
        """
        Build the GUI interface.
        """
        self.view = Gtk.TreeView()
        self.view.set_tooltip_column(3)
        titles = [
            (_('Name'), 0, 230),
            (_('Birth'), 2, 100),
            ('', NOSORT, 1),
            ('', NOSORT, 1),  # tooltip
            ('', NOSORT, 100)
        ]  # handle
        self.model = ListModel(self.view,
                               titles,
                               list_mode="tree",
                               event_func=self.cb_double_click)
        return self.view

    def get_has_data(self, active_handle):
        """
        Return True if the gramplet has data, else return False.
        """
        if active_handle:
            person = self.dbstate.db.get_person_from_handle(active_handle)
            if person:
                family_handle = person.get_main_parents_family_handle()
                family = self.dbstate.db.get_family_from_handle(family_handle)
                if family and (family.get_father_handle()
                               or family.get_mother_handle()):
                    return True
        return False

    def cb_double_click(self, treeview):
        """
        Handle double click on treeview.
        """
        (model, iter_) = treeview.get_selection().get_selected()
        if not iter_:
            return

        try:
            handle = model.get_value(iter_, 4)
            person = self.dbstate.db.get_person_from_handle(handle)
            EditPerson(self.dbstate, self.uistate, [], person)
        except WindowActiveError:
            pass

    def db_changed(self):
        self.update()

    def active_changed(self, handle):
        self.update()

    def update_has_data(self):
        active_handle = self.get_active('Person')
        if active_handle:
            self.set_has_data(self.get_has_data(active_handle))
        else:
            self.set_has_data(False)

    def main(self):
        active_handle = self.get_active('Person')
        self.model.clear()
        if active_handle:
            self.add_to_tree(1, None, active_handle)
            self.view.expand_all()
            self.set_has_data(self.get_has_data(active_handle))
        else:
            self.set_has_data(False)

    def add_to_tree(self, depth, parent_id, person_handle):
        if depth > config.get('behavior.generation-depth'):
            return

        person = self.dbstate.db.get_person_from_handle(person_handle)
        name = name_displayer.display(person)

        birth = get_birth_or_fallback(self.dbstate.db, person)
        death = get_death_or_fallback(self.dbstate.db, person)

        birth_text = birth_date = birth_sort = ''
        if birth:
            birth_date = get_date(birth)
            birth_sort = '%012d' % birth.get_date_object().get_sort_value()
            birth_text = _('%(abbr)s %(date)s') % \
                         {'abbr': birth.type.get_abbreviation(),
                          'date': birth_date}

        death_date = death_sort = death_text = ''
        if death:
            death_date = get_date(death)
            death_sort = '%012d' % death.get_date_object().get_sort_value()
            death_text = _('%(abbr)s %(date)s') % \
                         {'abbr': death.type.get_abbreviation(),
                          'date': death_date}

        tooltip = name + '\n' + birth_text + '\n' + death_text

        label = _('%(depth)s. %(name)s') % {'depth': depth, 'name': name}
        item_id = self.model.add(
            [label, birth_date, birth_sort, tooltip, person_handle],
            node=parent_id)

        family_handle = person.get_main_parents_family_handle()
        family = self.dbstate.db.get_family_from_handle(family_handle)
        if family:
            if family.get_father_handle():
                self.add_to_tree(depth + 1, item_id,
                                 family.get_father_handle())
            if family.get_mother_handle():
                self.add_to_tree(depth + 1, item_id,
                                 family.get_mother_handle())

        return item_id
Пример #15
0
class PersonResidence(Gramplet):
    """
    Displays residence events for a person.
    """
    def init(self):
        self.gui.WIDGET = self.build_gui()
        self.gui.get_container_widget().remove(self.gui.textview)
        self.gui.get_container_widget().add(self.gui.WIDGET)
        self.gui.WIDGET.show()

    def build_gui(self):
        """
        Build the GUI interface.
        """
        tip = _('Double-click on a row to edit the selected event.')
        self.set_tooltip(tip)
        top = Gtk.TreeView()
        titles = [('', NOSORT, 50,),
                  (_('Date'), 1, 200),
                  (_('Place'), 2, 200)]
        self.model = ListModel(top, titles, event_func=self.edit_event)
        return top

    def db_changed(self):
        self.dbstate.db.connect('person-update', self.update)

    def active_changed(self, handle):
        self.update()

    def update_has_data(self):
        active_handle = self.get_active('Person')
        if active_handle:
            active = self.dbstate.db.get_person_from_handle(active_handle)
            self.set_has_data(self.get_has_data(active))
        else:
            self.set_has_data(False)

    def get_has_data(self, active_person):
        """
        Return True if the gramplet has data, else return False.
        """
        if active_person:
            for event_ref in active_person.get_event_ref_list():
                if int(event_ref.get_role()) == EventRoleType.PRIMARY:
                    event = self.dbstate.db.get_event_from_handle(event_ref.ref)
                    if int(event.get_type()) == EventType.RESIDENCE:
                        return True
        return False

    def main(self): # return false finishes
        self.model.clear()
        active_handle = self.get_active('Person')
        if active_handle:
            active_person = self.dbstate.db.get_person_from_handle(active_handle)
            if active_person:
                self.display_person(active_person)
            else:
                self.set_has_data(False)
        else:
            self.set_has_data(False)

    def display_person(self, active_person):
        """
        Display the residence events of the active person.
        """
        count = 0
        for event_ref in active_person.get_event_ref_list():
            if int(event_ref.get_role()) == EventRoleType.PRIMARY:
                event = self.dbstate.db.get_event_from_handle(event_ref.ref)
                if int(event.get_type()) == EventType.RESIDENCE:
                    self.add_residence(event)
                    count += 1
        self.set_has_data(count > 0)

    def add_residence(self, event):
        """
        Add a residence event to the model.
        """
        date = get_date(event)
        place = ''
        handle = event.get_place_handle()
        if handle:
            place = place_displayer.display_event(self.dbstate.db, event)
        self.model.add((event.get_handle(), date, place))

    def edit_event(self, treeview):
        """
        Edit the selected event.
        """
        model, iter_ = treeview.get_selection().get_selected()
        if iter_:
            handle = model.get_value(iter_, 0)
            try:
                event = self.dbstate.db.get_event_from_handle(handle)
                EditEvent(self.dbstate, self.uistate, [], event)
            except WindowActiveError:
                pass
Пример #16
0
class Attributes(Gramplet):
    """
    Displays the attributes of an object.
    """
    def init(self):
        self.gui.WIDGET = self.build_gui()
        self.gui.get_container_widget().remove(self.gui.textview)
        self.gui.get_container_widget().add_with_viewport(self.gui.WIDGET)
        self.gui.WIDGET.show()

    def build_gui(self):
        """
        Build the GUI interface.
        """
        tip = _('Double-click on a row to edit the object containing the '
                'selected attribute.')
        self.set_tooltip(tip)
        top = Gtk.TreeView()
        titles = [(_('Date'), 1, 100), ('', 1, 100), (_('Key'), 2, 100),
                  (_('Value'), 3, 100), (
                      '',
                      NOSORT,
                      50,
                  )]
        self.model = ListModel(top, titles, event_func=self._display_editor)
        return top

    def add_attributes(self, obj, date_object=None):
        """
        Add the attributes of an object to the model.
        """
        event_date = event_sort = handle = ''
        if date_object is not None:
            event_date = gramps.gen.datehandler.displayer.display(date_object)
            event_sort = '%012d' % date_object.get_sort_value()

        try:
            handle = obj.get_handle()
        except AttributeError:
            handle = obj.ref

        for attr in obj.get_attribute_list():
            self.model.add((event_date, event_sort, str(attr.get_type()),
                            attr.get_value(), handle))

    def display_attributes(self, obj):
        """
        Display the attributes of an object.
        """
        self.add_attributes(obj)

        for event_ref in obj.get_event_ref_list():
            event = self.dbstate.db.get_event_from_handle(event_ref.ref)
            event_date = event.get_date_object()
            self.add_attributes(event, event_date)
            self.add_attributes(event_ref, event_date)

        self.set_has_data(self.model.count > 0)

    def _display_editor(self, treeview):
        """
        Display the appropriate editor window for the attribute.
        """
        pass

    def get_has_data(self, obj):
        """
        Return True if the gramplet has data, else return False.
        """
        if obj is None:
            return False
        if obj.get_attribute_list():
            return True
        for event_ref in obj.get_event_ref_list():
            if event_ref.get_attribute_list():
                return True
        return False

    def _get_event_ref(self, event):
        """
        Return the event reference belonging to the active person or
        family for the given event.
        """
        for event_ref in self.object_for_update.get_event_ref_list():
            if event_ref.ref == event.get_handle():
                return event_ref
        return None

    def _object_edited(self, ref, event):
        pass
Пример #17
0
class PersonChildren(Children):
    """
    Displays the children of a person.
    """
    def build_gui(self):
        """
        Build the GUI interface.
        """
        tip = _('Double-click on a row to edit the selected child.')
        self.set_tooltip(tip)
        top = Gtk.TreeView()
        titles = [('', NOSORT, 50,),
                  (_('Child'), 1, 250),
                  (_('Birth Date'), 3, 100),
                  ('', 3, 100),
                  (_('Death Date'), 5, 100),
                  ('', 5, 100),
                  (_('Spouse'), 6, 250)]
        self.model = ListModel(top, titles, event_func=self.edit_person)
        return top

    def db_changed(self):
        self.dbstate.db.connect('person-update', self.update)

    def active_changed(self, handle):
        self.update()

    def main(self):
        active_handle = self.get_active('Person')
        self.model.clear()
        if active_handle:
            self.display_person(active_handle)
        else:
            self.set_has_data(False)

    def update_has_data(self):
        active_handle = self.get_active('Person')
        if active_handle:
            active = self.dbstate.db.get_person_from_handle(active_handle)
            self.set_has_data(self.get_has_data(active))
        else:
            self.set_has_data(False)

    def get_has_data(self, active_person):
        """
        Return True if the gramplet has data, else return False.
        """
        if active_person is None:
            return False
        for family_handle in active_person.get_family_handle_list():
            family = self.dbstate.db.get_family_from_handle(family_handle)
            if family and family.get_child_ref_list():
                return True
        return False

    def display_person(self, active_handle):
        """
        Display the children of the active person.
        """
        active_person = self.dbstate.db.get_person_from_handle(active_handle)
        for family_handle in active_person.get_family_handle_list():
            family = self.dbstate.db.get_family_from_handle(family_handle)
            self.display_family(family, active_person)
        self.set_has_data(self.model.count > 0)

    def display_family(self, family, active_person):
        """
        Display the children of given family.
        """
        spouse_handle = find_spouse(active_person, family)
        if spouse_handle:
            spouse = self.dbstate.db.get_person_from_handle(spouse_handle)
        else:
            spouse = None

        for child_ref in family.get_child_ref_list():
            child = self.dbstate.db.get_person_from_handle(child_ref.ref)
            self.add_child(child, spouse)

    def add_child(self, child, spouse):
        """
        Add a child to the model.
        """
        name = name_displayer.display(child)
        if spouse:
            spouse = name_displayer.display(spouse)
        spouse = spouse or ''
        birth = get_birth_or_fallback(self.dbstate.db, child)
        birth_date, birth_sort, birth_place = self.get_date_place(birth)
        death = get_death_or_fallback(self.dbstate.db, child)
        death_date, death_sort, death_place = self.get_date_place(death)
        self.model.add((child.get_handle(),
                        name,
                        birth_date,
                        birth_sort,
                        death_date,
                        death_sort,
                        spouse))
Пример #18
0
class Citations(Gramplet, DbGUIElement):

    def __init__(self, gui, nav_group=0):
        Gramplet.__init__(self, gui, nav_group)
        DbGUIElement.__init__(self, self.dbstate.db)

    """
    Displays the citations for an object.
    """
    def init(self):
        self.gui.WIDGET = self.build_gui()
        self.gui.get_container_widget().remove(self.gui.textview)
        self.gui.get_container_widget().add(self.gui.WIDGET)
        self.gui.WIDGET.show()

    def _connect_db_signals(self):
        """
        called on init of DbGUIElement, connect to db as required.
        """
        self.callman.register_callbacks({'citation-update': self.changed,
                                         'person-update': self.changed,
                                         'family-update': self.changed,
                                         'event-update': self.changed,
                                         'media-update': self.changed,
                                         'place-update': self.changed})
        self.callman.connect_all(keys=['citation', 'family', 'person', 'event',
                                       'media', 'place'])

    def changed(self, handle):
        """
        Called when a registered citation is updated.
        """
        self.update()

    def build_gui(self):
        """
        Build the GUI interface.
        """
        tip = _('Double-click on a row to edit the selected source/citation.')
        self.set_tooltip(tip)
        top = Gtk.TreeView()
        titles = [('', NOSORT, 50,),
                  (_('Source/Citation'), 1, 350),
                  (_('Author'), 2, 200),
                  (_('Publisher'), 3, 150)]
        self.model = ListModel(top, titles, list_mode="tree",
                               event_func=self.invoke_editor)
        return top

    def add_citations(self, obj):
        for citation_handle in obj.get_citation_list():
            self.add_citation_ref(citation_handle)

    def add_name_citations(self, obj):
        names = [obj.get_primary_name()] + obj.get_alternate_names()
        for name in names:
            self.add_citations(name)

    def add_attribute_citations(self, obj):
        for attr in obj.get_attribute_list():
            self.add_citations(attr)

    def add_mediaref_citations(self, obj):
        for media_ref in obj.get_media_list():
            self.add_citations(media_ref)
            self.add_attribute_citations(media_ref)
            media = self.dbstate.db.get_media_from_handle(media_ref.ref)
            self.add_media_citations(media)

    def add_media_citations(self, media):
        self.callman.register_handles({'media': [media.handle]})
        self.add_citations(media)
        self.add_attribute_citations(media)

    def add_eventref_citations(self, obj):
        for event_ref in obj.get_event_ref_list():
            self.add_attribute_citations(event_ref)
            event = self.dbstate.db.get_event_from_handle(event_ref.ref)
            self.add_event_citations(event)

    def add_event_citations(self, event):
        self.callman.register_handles({'event': [event.handle]})
        self.add_citations(event)
        self.add_attribute_citations(event)
        self.add_mediaref_citations(event)
        place_handle = event.get_place_handle()
        if place_handle:
            place = self.dbstate.db.get_place_from_handle(place_handle)
            if place:
                self.add_place_citations(place)

    def add_place_citations(self, place):
        self.callman.register_handles({'place': [place.handle]})
        self.add_citations(place)
        self.add_mediaref_citations(place)

    def add_address_citations(self, obj):
        for address in obj.get_address_list():
            self.add_citations(address)

    def add_lds_citations(self, obj):
        for lds in obj.get_lds_ord_list():
            self.add_citations(lds)
            place_handle = lds.get_place_handle()
            if place_handle:
                place = self.dbstate.db.get_place_from_handle(place_handle)
                if place:
                    self.add_place_citations(place)

    def add_association_citations(self, obj):
        for assoc in obj.get_person_ref_list():
            self.add_citations(assoc)

    def add_citation_ref(self, citation_handle):
        """
        Add a citation to the model.
        """
        self.callman.register_handles({'citation': [citation_handle]})
        citation = self.dbstate.db.get_citation_from_handle(citation_handle)
        page = citation.get_page()
        if not page:
            page = _('<No Citation>')
        source_handle = citation.get_reference_handle()
        source = self.dbstate.db.get_source_from_handle(source_handle)
        title = source.get_title()
        author = source.get_author()
        publisher = source.get_publication_info()

        if source_handle not in self.source_nodes:
            node = self.model.add([source_handle, title, author, publisher])
            self.source_nodes[source_handle] = node

        self.model.add([citation_handle, page, '', ''],
                       node=self.source_nodes[source_handle])

    def check_citations(self, obj):
        return True if obj.get_citation_list() else False

    def check_name_citations(self, obj):
        names = [obj.get_primary_name()] + obj.get_alternate_names()
        for name in names:
            if self.check_citations(name):
                return True
        return False

    def check_attribute_citations(self, obj):
        for attr in obj.get_attribute_list():
            if self.check_citations(attr):
                return True
        return False

    def check_mediaref_citations(self, obj):
        for media_ref in obj.get_media_list():
            if self.check_citations(media_ref):
                return True
            if self.check_attribute_citations(media_ref):
                return True
            media = self.dbstate.db.get_media_from_handle(media_ref.ref)
            if self.check_media_citations(media):
                return True
        return False

    def check_media_citations(self, media):
        if self.check_citations(media):
            return True
        if self.check_attribute_citations(media):
            return True
        return False

    def check_eventref_citations(self, obj):
        if obj:
            for event_ref in obj.get_event_ref_list():
                if self.check_attribute_citations(event_ref):
                    return True
                event = self.dbstate.db.get_event_from_handle(event_ref.ref)
                if self.check_event_citations(event):
                    return True
        return False

    def check_event_citations(self, event):
        if self.check_citations(event):
            return True
        if self.check_attribute_citations(event):
            return True
        if self.check_mediaref_citations(event):
            return True
        place_handle = event.get_place_handle()
        if place_handle:
            place = self.dbstate.db.get_place_from_handle(place_handle)
            if place and self.check_place_citations(place):
                return True
        return False

    def check_place_citations(self, place):
        if self.check_citations(place):
            return True
        if self.check_mediaref_citations(place):
            return True
        return False

    def check_address_citations(self, obj):
        for address in obj.get_address_list():
            if self.check_citations(address):
                return True
        return False

    def check_lds_citations(self, obj):
        for lds in obj.get_lds_ord_list():
            if self.check_citations(lds):
                return True
            place_handle = lds.get_place_handle()
            if place_handle:
                place = self.dbstate.db.get_place_from_handle(place_handle)
                if place and self.check_place_citations(place):
                    return True
        return False

    def check_association_citations(self, obj):
        for assoc in obj.get_person_ref_list():
            if self.check_citations(assoc):
                return True
        return False

    def invoke_editor(self, treeview):
        """
        Edit the selected source or citation.
        """
        model, iter_ = treeview.get_selection().get_selected()
        if iter_:
            handle = model.get_value(iter_, 0)
            # bug 9094.
            # str(model.get_path(iter_)) return something like NNN:MMM
            # So if we have only NNN, it's a node
            # removing the str() solves the problem.
            if len(model.get_path(iter_)) == 1:
                self.edit_source(handle)
            else:
                self.edit_citation(handle)

    def edit_source(self, handle):
        """
        Edit the selected source.
        """
        try:
            source = self.dbstate.db.get_source_from_handle(handle)
            EditSource(self.dbstate, self.uistate, [], source)
        except WindowActiveError:
            pass

    def edit_citation(self, handle):
        """
        Edit the selected citation.
        """
        try:
            citation = self.dbstate.db.get_citation_from_handle(handle)
            source_handle = citation.get_reference_handle()
            source = self.dbstate.db.get_source_from_handle(source_handle)
            EditCitation(self.dbstate, self.uistate, [], citation, source)
        except WindowActiveError:
            pass
Пример #19
0
class Events(Gramplet, DbGUIElement):
    def __init__(self, gui, nav_group=0):
        Gramplet.__init__(self, gui, nav_group)
        DbGUIElement.__init__(self, self.dbstate.db)

    """
    Displays the events for a person or family.
    """

    def init(self):
        self.gui.WIDGET = self.build_gui()
        self.gui.get_container_widget().remove(self.gui.textview)
        self.gui.get_container_widget().add(self.gui.WIDGET)
        self.gui.WIDGET.show()

    def _connect_db_signals(self):
        """
        called on init of DbGUIElement, connect to db as required.
        """
        self.callman.register_callbacks({'event-update': self.changed})
        self.callman.connect_all(keys=['event'])

    def changed(self, handle):
        """
        Called when a registered event is updated.
        """
        self.update()

    def build_gui(self):
        """
        Build the GUI interface.
        """
        tip = _('Double-click on a row to edit the selected event.')
        self.set_tooltip(tip)
        top = Gtk.TreeView()
        titles = [(
            '',
            NOSORT,
            50,
        ), (_('Type'), 1, 100), (_('Description'), 2, 150),
                  (_('Date'), 3, 100), ('', NOSORT, 50), (_('Age'), 4, 100),
                  ('', NOSORT, 50), (_('Place'), 5, 400),
                  (_('Main Participants'), 6, 200), (_('Role'), 7, 100)]
        self.model = ListModel(top, titles, event_func=self.edit_event)
        return top

    def add_event_ref(self, event_ref, spouse=None):
        """
        Add an event to the model.
        """
        self.callman.register_handles({'event': [event_ref.ref]})
        event = self.dbstate.db.get_event_from_handle(event_ref.ref)
        event_date = get_date(event)
        event_sort = '%012d' % event.get_date_object().get_sort_value()
        person_age = self.column_age(event)
        person_age_sort = self.column_sort_age(event)
        place = place_displayer.display_event(self.dbstate.db, event)

        participants = get_participant_from_event(self.dbstate.db,
                                                  event_ref.ref)

        self.model.add((event.get_handle(), str(event.get_type()),
                        event.get_description(), event_date, event_sort,
                        person_age, person_age_sort, place, participants,
                        str(event_ref.get_role())))

    def column_age(self, event):
        """
        Returns a string representation of age in years.  Change
        precision=2 for "year, month", or precision=3 for "year,
        month, days"
        """
        date = event.get_date_object()
        start_date = self.cached_start_date
        if date and start_date:
            return (date - start_date).format(precision=age_precision)
        else:
            return ""

    def column_sort_age(self, event):
        """
        Returns a string version of number of days of age.
        """
        date = event.get_date_object()
        start_date = self.cached_start_date
        if date and start_date:
            return "%09d" % int(date - start_date)
        else:
            return ""

    def edit_event(self, treeview):
        """
        Edit the selected event.
        """
        model, iter_ = treeview.get_selection().get_selected()
        if iter_:
            handle = model.get_value(iter_, 0)
            try:
                event = self.dbstate.db.get_event_from_handle(handle)
                EditEvent(self.dbstate, self.uistate, [], event)
            except WindowActiveError:
                pass
Пример #20
0
class Participants(Gramplet, DbGUIElement):
    """
    Displays the participants of an event.
    """
    def __init__(self, gui, nav_group=0):
        Gramplet.__init__(self, gui, nav_group)
        DbGUIElement.__init__(self, self.dbstate.db)

    def init(self):
        self.gui.WIDGET = self.build_gui()
        self.gui.get_container_widget().remove(self.gui.textview)
        self.gui.get_container_widget().add_with_viewport(self.gui.WIDGET)
        self.gui.WIDGET.show()

    def _connect_db_signals(self):
        """
        called on init of DbGUIElement, connect to db as required.
        """
        self.callman.register_callbacks({'person-update': self.changed, 
                                         'event-update': self.changed})
        self.callman.connect_all(keys=['person', 'event'])
        #self.dbstate.db.connect('person-update', self.update)
        self.connect_signal('Event', self.update)
    
    def changed(self, handle):
        """
        Called when a registered person is updated.
        """
        self.update()

    def build_gui(self):
        """
        Build the GUI interface.
        """
        tip = _('Double-click on a row to edit the selected participant.')
        self.set_tooltip(tip)
        top = Gtk.TreeView()
        titles = [('', NOSORT, 50,),
                  (_('Name'), 1, 250),
                  (_('Role'), 2, 80),
                  (_('Birth Date'), 3, 100),
                  ('', 3, 100),
                  (_('Spouses'), 4, 200)]
        self.model = ListModel(top, titles, event_func=self.edit_person)
        return top
        
    def display_participants(self, active_handle):
        """
        Display the participants of an event.
        """
        for classname, handle in \
                        self.dbstate.db.find_backlink_handles(active_handle):
            if classname == 'Person':
                self.display_person(handle, active_handle)
            elif classname == 'Family':
                self.display_family(handle, active_handle)
        self.set_has_data(self.model.count > 0)

    def display_person(self, handle, event_handle):
        """
        Display a participant in the event.
        """
        person = self.dbstate.db.get_person_from_handle(handle)
        role = self.get_role(person, event_handle)
        self.add_person(person, role)

    def display_family(self, handle, event_handle):
        """
        Display a participant in the event.
        """
        family = self.dbstate.db.get_family_from_handle(handle)
        role = self.get_role(family, event_handle)

        mother_handle = family.get_mother_handle()
        mother = self.dbstate.db.get_person_from_handle(mother_handle)
        self.add_person(mother, role)

        father_handle = family.get_father_handle()
        father = self.dbstate.db.get_person_from_handle(father_handle)
        self.add_person(father, role)

    def add_person(self, person, role):
        """
        Add a person to the model.
        """
        self.callman.register_handles({'person': [person.get_handle()]})
        name = displayer.display(person)
        spouses = self.get_spouses(person)
        birth = get_birth_or_fallback(self.dbstate.db, person)
        self.callman.register_handles({'event': [birth.get_handle()]})
        birth_date, birth_sort, birth_place = self.get_date_place(birth)
        self.model.add((person.get_handle(),
                        name,
                        role,
                        birth_date,
                        birth_sort,
                        spouses))

    def get_role(self, obj, event_handle):
        """
        Get the role of a person or family in an event.
        """
        for event_ref in obj.get_event_ref_list():
            if event_ref.ref == event_handle:
                return str(event_ref.get_role())
        return None

    def get_spouses(self, person):
        """
        Get the spouses of a given person.
        """
        spouses = []
        for handle in person.get_family_handle_list():
            family = self.dbstate.db.get_family_from_handle(handle)
            father_handle = family.get_father_handle()
            if father_handle and father_handle != person.get_handle():
                self.callman.register_handles({'person': [father_handle]})
                father = self.dbstate.db.get_person_from_handle(father_handle)
                spouses.append(displayer.display(father))
            mother_handle = family.get_mother_handle()
            if mother_handle and mother_handle != person.get_handle():
                self.callman.register_handles({'person': [mother_handle]})
                mother = self.dbstate.db.get_person_from_handle(mother_handle)
                spouses.append(displayer.display(mother))
        return ' | '.join(spouses)

    def get_date_place(self, event):
        """
        Return the date and place of the given event.
        """
        event_date = ''
        event_place = ''
        event_sort = '%012d' % 0
        if event:
            event_date = get_date(event)
            event_sort = '%012d' % event.get_date_object().get_sort_value()
            handle = event.get_place_handle()
            if handle:
                place = self.dbstate.db.get_place_from_handle(handle)
                event_place = place.get_title()
        return (event_date, event_sort, event_place)

    def edit_person(self, treeview):
        """
        Edit the selected child.
        """
        model, iter_ = treeview.get_selection().get_selected()
        if iter_:
            handle = model.get_value(iter_, 0)
            try:
                person = self.dbstate.db.get_person_from_handle(handle)
                EditPerson(self.dbstate, self.uistate, [], person)
            except WindowActiveError:
                pass

    def get_has_data(self, active_handle):
        """
        Return True if the gramplet has data, else return False.
        """
        if active_handle is None:
            return False
        for handle in self.dbstate.db.find_backlink_handles(active_handle):
            return True
        return False
        
    def update_has_data(self):
        active_handle = self.get_active('Event')
        self.set_has_data(self.get_has_data(active_handle))
    
    def main(self):
        active_handle = self.get_active('Event')
        self.model.clear()
        self.callman.unregister_all()
        if active_handle:
            self.display_participants(active_handle)
        else:
            self.set_has_data(False)
Пример #21
0
class GeoEvents(Gramplet, DbGUIElement):

    def __init__(self, gui, nav_group=0):
        Gramplet.__init__(self, gui, nav_group)
        DbGUIElement.__init__(self, self.dbstate.db)

    """
    Displays the events for a person or family.
    """
    def init(self):
        self.gui.WIDGET = self.build_gui()
        self.gui.get_container_widget().remove(self.gui.textview)
        self.gui.get_container_widget().add(self.gui.WIDGET)
        self.gui.WIDGET.show()

    def _connect_db_signals(self):
        """
        called on init of DbGUIElement, connect to db as required.
        """
        self.callman.register_callbacks({'event-update': self.changed})
        self.callman.connect_all(keys=['event'])

    def changed(self, handle):
        """
        Called when a registered event is updated.
        """
        self.update()

    def build_gui(self):
        """
        Build the GUI interface.
        """
        tip = _('Right-click on a row to edit the selected event'
                ' or the related place.')
        self.set_tooltip(tip)
        top = Gtk.TreeView()
        top.set_hover_selection(True)
        titles = [('', NOSORT, 50,),
                  (_('Type'), 1, 100),
                  (_('Description'), 2, 250),
                  (_('Date'), 3, 160),
                  ('', NOSORT, 50),
                  (_('Place'), 4, 300),
                  (_('Id'), 5, 80),
                  (_('Latitude'), 6, 130),
                  (_('Longitude'), 7, 130),
                  ]
        self.model = ListModel(top, titles, right_click=self.menu_edit)
        return top

    def add_event_ref(self, event_ref, spouse=None, name=""):
        """
        Add an event to the model.
        """
        self.callman.register_handles({'event': [event_ref.ref]})
        event = self.dbstate.db.get_event_from_handle(event_ref.ref)
        event_date = get_date(event)
        event_sort = '%012d' % event.get_date_object().get_sort_value()
        place_name = place_displayer.display_event(self.dbstate.db, event)
        place_handle = event.get_place_handle()
        place_id = latitude = longitude = ""
        if place_handle:
            plc = self.dbstate.db.get_place_from_handle(place_handle)
            if plc:
                place_id = plc.get_gramps_id()
                latitude = plc.get_latitude()
                longitude = plc.get_longitude()
                latitude, longitude = conv_lat_lon(latitude, longitude, "D.D8")

        description = event.get_description()
        if description == "":
            description = name

        self.model.add((event.get_handle(),
                        str(event.get_type()),
                        description,
                        event_date,
                        event_sort,
                        place_name,
                        place_id,
                        latitude,
                        longitude
                        ))

    def menu_edit(self, treeview, event):
        """
        Show a menu to select either Edit the selected event or
        the Place related to this event.
        """
        self.menu = Gtk.Menu()
        menu = self.menu
        menu.set_title(_('Edit'))
        title = _('Edit the event')
        add_item = Gtk.MenuItem(label=title)
        add_item.connect("activate", self.edit_event, treeview)
        add_item.show()
        menu.append(add_item)
        title = _('Edit the place')
        add_item = Gtk.MenuItem(label=title)
        add_item.connect("activate", self.edit_place, treeview)
        add_item.show()
        menu.append(add_item)
        menu.show()
        menu.popup(None, None, None, None, event.button, event.time)

    def edit_place(self, menuitem, treeview):
        """
        Edit the place related to the selected event.
        """
        model, iter_ = treeview.get_selection().get_selected()
        if iter_:
            handle = model.get_value(iter_, 0)
            try:
                event = self.dbstate.db.get_event_from_handle(handle)
                place_handle = event.get_place_handle()
                place_id = latitude = longitude = ""
                if place_handle:
                    plc = self.dbstate.db.get_place_from_handle(place_handle)
                    EditPlace(self.dbstate, self.uistate, [], plc)
            except WindowActiveError:
                pass

    def edit_event(self, menuitem, treeview):
        """
        Edit the selected event.
        """
        model, iter_ = treeview.get_selection().get_selected()
        if iter_:
            handle = model.get_value(iter_, 0)
            try:
                event = self.dbstate.db.get_event_from_handle(handle)
                EditEvent(self.dbstate, self.uistate, [], event)
            except WindowActiveError:
                pass
Пример #22
0
class MetadataView(Gtk.TreeView):

    def __init__(self):
        Gtk.TreeView.__init__(self)
        self.sections = {}
        titles = [(_('Key'), 1, 235),
                  (_('Value'), 2, 325)]
        self.model = ListModel(self, titles, list_mode="tree")

    def display_exif_tags(self, full_path):
        """
        Display the exif tags.
        """
        self.sections = {}
        self.model.clear()

        if not os.path.exists(full_path):
            return False

        retval = False
        with open(full_path, 'rb') as fd:
            try:
                buf = fd.read()
                metadata = GExiv2.Metadata()
                metadata.open_buf(buf)

                get_human = metadata.get_tag_interpreted_string

                for section, key, key2, func in TAGS:
                    if not key in metadata.get_exif_tags():
                        continue

                    if func is not None:
                        if key2 is None:
                            human_value = func(metadata[key])
                        else:
                            if key2 in metadata.get_exif_tags():
                                human_value = func(metadata[key], metadata[key2])
                            else:
                                human_value = func(metadata[key], None)
                    else:
                        human_value = get_human(key)
                        if key2 in metadata.get_exif_tags():
                            human_value += ' ' + get_human(key2)

                    label = metadata.get_tag_label(key)
                    node = self.__add_section(section)
                    if human_value is None:
                        human_value = ''
                    self.model.add((label, human_value), node=node)

                    self.model.tree.expand_all()
                    retval = self.model.count > 0
            except:
                pass

        return retval

    def __add_section(self, section):
        """
        Add the section heading node to the model.
        """
        if section not in self.sections:
            node = self.model.add([section, ''])
            self.sections[section] = node
        else:
            node = self.sections[section]
        return node

    def get_has_data(self, full_path):
        """
        Return True if the gramplet has data, else return False.
        """
        if not os.path.exists(full_path):
            return False
        with open(full_path, 'rb') as fd:
            retval = False
            try:
                buf = fd.read()
                metadata = GExiv2.Metadata()
                metadata.open_buf(buf)
                for tag in TAGS:
                    if tag in metadata.get_exif_tags():
                        retval = True
                        break
            except:
                pass

        return retval
Пример #23
0
class Locations(Gramplet, DbGUIElement):
    """
    Gramplet showing the locations of a place over time.
    """
    def __init__(self, gui, nav_group=0):
        Gramplet.__init__(self, gui, nav_group)
        DbGUIElement.__init__(self, self.dbstate.db)

    def init(self):
        self.gui.WIDGET = self.build_gui()
        self.gui.get_container_widget().remove(self.gui.textview)
        self.gui.get_container_widget().add(self.gui.WIDGET)
        self.gui.WIDGET.show()

    def _connect_db_signals(self):
        """
        called on init of DbGUIElement, connect to db as required.
        """
        self.callman.register_callbacks({'place-update': self.changed})
        self.callman.connect_all(keys=['place'])

    def db_changed(self):
        self.connect_signal('Place', self.update)

    def changed(self, handle):
        """
        Called when a registered place is updated.
        """
        self.update()

    def build_gui(self):
        """
        Build the GUI interface.
        """
        tip = _('Double-click on a row to edit the selected place.')
        self.set_tooltip(tip)
        top = Gtk.TreeView()
        titles = [('', 0, 50),
                  (_('Name'), 1, 300),
                  (_('Type'), 2, 150),
                  (_('Date'), 4, 150),
                  ('', NOSORT, 50)]
        self.model = ListModel(top, titles, list_mode="tree",
                               event_func=self.edit_place)
        return top

    def active_changed(self, handle):
        self.update()

    def update_has_data(self):
        active_handle = self.get_active('Place')
        if active_handle:
            active = self.dbstate.db.get_place_from_handle(active_handle)
            self.set_has_data(self.get_has_data(active))
        else:
            self.set_has_data(False)

    def get_has_data(self, place):
        """
        Return True if the gramplet has data, else return False.
        """
        pass

    def main(self):
        self.model.clear()
        self.callman.unregister_all()
        active_handle = self.get_active('Place')
        if active_handle:
            active = self.dbstate.db.get_place_from_handle(active_handle)
            if active:
                self.display_place(active, None, [active_handle])
            else:
                self.set_has_data(False)
        else:
            self.set_has_data(False)

    def display_place(self, place, node, visited):
        """
        Display the location hierarchy for the active place.
        """
        pass

    def add_place(self, placeref, place, node, visited):
        """
        Add a place to the model.
        """
        place_date = get_date(placeref)
        place_sort = '%012d' % placeref.get_date_object().get_sort_value()
        place_name = place.get_name().get_value()
        place_type = str(place.get_type())

        new_node = self.model.add([place.handle,
                                   place_name,
                                   place_type,
                                   place_date,
                                   place_sort],
                                  node=node)

        self.display_place(place, new_node, visited + [place.handle])

    def edit_place(self, treeview):
        """
        Edit the selected place.
        """
        model, iter_ = treeview.get_selection().get_selected()
        if iter_:
            handle = model.get_value(iter_, 0)
            place = self.dbstate.db.get_place_from_handle(handle)
            try:
                EditPlace(self.dbstate, self.uistate, [], place)
            except WindowActiveError:
                pass
Пример #24
0
class Citations(Gramplet, DbGUIElement):

    def __init__(self, gui, nav_group=0):
        Gramplet.__init__(self, gui, nav_group)
        DbGUIElement.__init__(self, self.dbstate.db)

    """
    Displays the citations for an object.
    """
    def init(self):
        self.gui.WIDGET = self.build_gui()
        self.gui.get_container_widget().remove(self.gui.textview)
        self.gui.get_container_widget().add(self.gui.WIDGET)
        self.gui.WIDGET.show()

    def _connect_db_signals(self):
        """
        called on init of DbGUIElement, connect to db as required.
        """
        self.callman.register_callbacks({'citation-update': self.changed})
        self.callman.connect_all(keys=['citation'])

    def changed(self, handle):
        """
        Called when a registered citation is updated.
        """
        self.update()

    def build_gui(self):
        """
        Build the GUI interface.
        """
        tip = _('Double-click on a row to edit the selected source/citation.')
        self.set_tooltip(tip)
        top = Gtk.TreeView()
        titles = [('', NOSORT, 50,),
                  (_('Source/Citation'), 1, 350),
                  (_('Author'), 2, 200),
                  (_('Publisher'), 3, 150)]
        self.model = ListModel(top, titles, list_mode="tree",
                               event_func=self.invoke_editor)
        return top

    def add_citations(self, obj):
        for citation_handle in obj.get_citation_list():
            self.add_citation_ref(citation_handle)

    def add_name_citations(self, obj):
        names = [obj.get_primary_name()] + obj.get_alternate_names()
        for name in names:
            self.add_citations(name)

    def add_attribute_citations(self, obj):
        for attr in obj.get_attribute_list():
            self.add_citations(attr)

    def add_mediaref_citations(self, obj):
        for media_ref in obj.get_media_list():
            self.add_citations(media_ref)
            self.add_attribute_citations(media_ref)
            media = self.dbstate.db.get_media_from_handle(media_ref.ref)
            self.add_media_citations(media)

    def add_media_citations(self, media):
        self.add_citations(media)
        self.add_attribute_citations(media)

    def add_eventref_citations(self, obj):
        for event_ref in obj.get_event_ref_list():
            self.add_attribute_citations(event_ref)
            event = self.dbstate.db.get_event_from_handle(event_ref.ref)
            self.add_event_citations(event)

    def add_event_citations(self, event):
        self.add_citations(event)
        self.add_attribute_citations(event)
        self.add_mediaref_citations(event)
        place_handle = event.get_place_handle()
        if place_handle:
            place = self.dbstate.db.get_place_from_handle(place_handle)
            if place:
                self.add_place_citations(place)

    def add_place_citations(self, place):
        self.add_citations(place)
        self.add_mediaref_citations(place)

    def add_address_citations(self, obj):
        for address in obj.get_address_list():
            self.add_citations(address)

    def add_lds_citations(self, obj):
        for lds in obj.get_lds_ord_list():
            self.add_citations(lds)
            place_handle = lds.get_place_handle()
            place = self.dbstate.db.get_place_from_handle(place_handle)
            if place:
                self.add_place_citations(place)

    def add_association_citations(self, obj):
        for assoc in obj.get_person_ref_list():
            self.add_citations(assoc)

    def add_citation_ref(self, citation_handle):
        """
        Add a citation to the model.
        """
        self.callman.register_handles({'citation': [citation_handle]})
        citation = self.dbstate.db.get_citation_from_handle(citation_handle)
        page = citation.get_page()
        if not page:
            page = _('<No Citation>')
        source_handle = citation.get_reference_handle()
        source = self.dbstate.db.get_source_from_handle(source_handle)
        title = source.get_title()
        author = source.get_author()
        publisher = source.get_publication_info()

        if source_handle not in self.source_nodes:
            node = self.model.add([source_handle, title, author, publisher])
            self.source_nodes[source_handle] = node

        self.model.add([citation_handle, page, '', ''],
                       node=self.source_nodes[source_handle])

    def check_citations(self, obj):
        return True if obj.get_citation_list() else False

    def check_name_citations(self, obj):
        names = [obj.get_primary_name()] + obj.get_alternate_names()
        for name in names:
            if self.check_citations(name):
                return True
        return False

    def check_attribute_citations(self, obj):
        for attr in obj.get_attribute_list():
            if self.check_citations(attr):
                return True
        return False

    def check_mediaref_citations(self, obj):
        for media_ref in obj.get_media_list():
            if self.check_citations(media_ref):
                return True
            if self.check_attribute_citations(media_ref):
                return True
            media = self.dbstate.db.get_media_from_handle(media_ref.ref)
            if self.check_media_citations(media):
                return True
        return False

    def check_media_citations(self, media):
        if self.check_citations(media):
            return True
        if self.check_attribute_citations(media):
            return True
        return False

    def check_eventref_citations(self, obj):
        if obj:
            for event_ref in obj.get_event_ref_list():
                if self.check_attribute_citations(event_ref):
                    return True
                event = self.dbstate.db.get_event_from_handle(event_ref.ref)
                if self.check_event_citations(event):
                    return True
        return False

    def check_event_citations(self, event):
        if self.check_citations(event):
            return True
        if self.check_attribute_citations(event):
            return True
        if self.check_mediaref_citations(event):
            return True
        place_handle = event.get_place_handle()
        if place_handle:
            place = self.dbstate.db.get_place_from_handle(place_handle)
            if place and self.check_place_citations(place):
                return True
        return False

    def check_place_citations(self, place):
        if self.check_citations(place):
            return True
        if self.check_mediaref_citations(place):
            return True
        return False

    def check_address_citations(self, obj):
        for address in obj.get_address_list():
            if self.check_citations(address):
                return True
        return False

    def check_lds_citations(self, obj):
        for lds in obj.get_lds_ord_list():
            if self.check_citations(lds):
                return True
            place_handle = lds.get_place_handle()
            place = self.dbstate.db.get_place_from_handle(place_handle)
            if place and self.check_place_citations(place):
                return True
        return False

    def check_association_citations(self, obj):
        for assoc in obj.get_person_ref_list():
            if self.check_citations(assoc):
                return True
        return False

    def invoke_editor(self, treeview):
        """
        Edit the selected source or citation.
        """
        model, iter_ = treeview.get_selection().get_selected()
        if iter_:
            handle = model.get_value(iter_, 0)
            # bug 9094.
            # str(model.get_path(iter_)) return something like NNN:MMM
            # So if we have only NNN, it's a node
            # removing the str() solves the problem.
            if len(model.get_path(iter_)) == 1:
                self.edit_source(handle)
            else:
                self.edit_citation(handle)

    def edit_source(self, handle):
        """
        Edit the selected source.
        """
        try:
            source = self.dbstate.db.get_source_from_handle(handle)
            EditSource(self.dbstate, self.uistate, [], source)
        except WindowActiveError:
            pass

    def edit_citation(self, handle):
        """
        Edit the selected citation.
        """
        try:
            citation = self.dbstate.db.get_citation_from_handle(handle)
            source_handle = citation.get_reference_handle()
            source = self.dbstate.db.get_source_from_handle(source_handle)
            EditCitation(self.dbstate, self.uistate, [], citation, source)
        except WindowActiveError:
            pass
class Participants(Gramplet, DbGUIElement):
    """
    Displays the participants of an event.
    """
    def __init__(self, gui, nav_group=0):
        Gramplet.__init__(self, gui, nav_group)
        DbGUIElement.__init__(self, self.dbstate.db)

    def init(self):
        self.gui.WIDGET = self.build_gui()
        self.gui.get_container_widget().remove(self.gui.textview)
        self.gui.get_container_widget().add_with_viewport(self.gui.WIDGET)
        self.gui.WIDGET.show()

    def _connect_db_signals(self):
        """
        called on init of DbGUIElement, connect to db as required.
        """
        self.callman.register_callbacks({
            'person-update': self.changed,
            'event-update': self.changed
        })
        self.callman.connect_all(keys=['person', 'event'])
        #self.dbstate.db.connect('person-update', self.update)
        self.connect_signal('Event', self.update)

    def changed(self, handle):
        """
        Called when a registered person is updated.
        """
        self.update()

    def build_gui(self):
        """
        Build the GUI interface.
        """
        tip = _('Double-click on a row to edit the selected participant.')
        self.set_tooltip(tip)
        top = Gtk.TreeView()
        titles = [(
            '',
            NOSORT,
            50,
        ), (_('Name'), 1, 250), (_('Role'), 2, 80), (_('Birth Date'), 3, 100),
                  ('', 3, 100), (_('Spouses'), 4, 200)]
        self.model = ListModel(top, titles, event_func=self.edit_person)
        return top

    def display_participants(self, active_handle):
        """
        Display the participants of an event.
        """
        for classname, handle in \
                        self.dbstate.db.find_backlink_handles(active_handle):
            if classname == 'Person':
                self.display_person(handle, active_handle)
            elif classname == 'Family':
                self.display_family(handle, active_handle)
        self.set_has_data(self.model.count > 0)

    def display_person(self, handle, event_handle):
        """
        Display a participant in the event.
        """
        person = self.dbstate.db.get_person_from_handle(handle)
        role = self.get_role(person, event_handle)
        self.add_person(person, role)

    def display_family(self, handle, event_handle):
        """
        Display a participant in the event.
        """
        family = self.dbstate.db.get_family_from_handle(handle)
        role = self.get_role(family, event_handle)

        mother_handle = family.get_mother_handle()
        if mother_handle:
            mother = self.dbstate.db.get_person_from_handle(mother_handle)
            self.add_person(mother, role)

        father_handle = family.get_father_handle()
        if father_handle:
            father = self.dbstate.db.get_person_from_handle(father_handle)
            self.add_person(father, role)

    def add_person(self, person, role):
        """
        Add a person to the model.
        """
        self.callman.register_handles({'person': [person.get_handle()]})
        name = displayer.display(person)
        spouses = self.get_spouses(person)
        birth = get_birth_or_fallback(self.dbstate.db, person)
        if birth:
            self.callman.register_handles({'event': [birth.get_handle()]})
        birth_date, birth_sort, birth_place = self.get_date_place(birth)
        self.model.add(
            (person.get_handle(), name, role, birth_date, birth_sort, spouses))

    def get_role(self, obj, event_handle):
        """
        Get the role of a person or family in an event.
        """
        for event_ref in obj.get_event_ref_list():
            if event_ref.ref == event_handle:
                return str(event_ref.get_role())
        return None

    def get_spouses(self, person):
        """
        Get the spouses of a given person.
        """
        spouses = []
        for handle in person.get_family_handle_list():
            family = self.dbstate.db.get_family_from_handle(handle)
            father_handle = family.get_father_handle()
            if father_handle and father_handle != person.get_handle():
                self.callman.register_handles({'person': [father_handle]})
                father = self.dbstate.db.get_person_from_handle(father_handle)
                spouses.append(displayer.display(father))
            mother_handle = family.get_mother_handle()
            if mother_handle and mother_handle != person.get_handle():
                self.callman.register_handles({'person': [mother_handle]})
                mother = self.dbstate.db.get_person_from_handle(mother_handle)
                spouses.append(displayer.display(mother))
        return ' | '.join(spouses)

    def get_date_place(self, event):
        """
        Return the date and place of the given event.
        """
        event_date = ''
        event_place = ''
        event_sort = '%012d' % 0
        if event:
            event_date = get_date(event)
            event_sort = '%012d' % event.get_date_object().get_sort_value()
            event_place = place_displayer.display_event(self.dbstate.db, event)
        return (event_date, event_sort, event_place)

    def edit_person(self, treeview):
        """
        Edit the selected child.
        """
        model, iter_ = treeview.get_selection().get_selected()
        if iter_:
            handle = model.get_value(iter_, 0)
            try:
                person = self.dbstate.db.get_person_from_handle(handle)
                EditPerson(self.dbstate, self.uistate, [], person)
            except WindowActiveError:
                pass

    def get_has_data(self, active_handle):
        """
        Return True if the gramplet has data, else return False.
        """
        if active_handle is None:
            return False
        for handle in self.dbstate.db.find_backlink_handles(active_handle):
            return True
        return False

    def update_has_data(self):
        active_handle = self.get_active('Event')
        self.set_has_data(self.get_has_data(active_handle))

    def main(self):
        active_handle = self.get_active('Event')
        self.model.clear()
        self.callman.unregister_all()
        if active_handle:
            self.display_participants(active_handle)
        else:
            self.set_has_data(False)
Пример #26
0
class MediaBrowser(Gramplet):
    """
    Displays an object tree and a media preview for a person.
    """

    def init(self):
        self.gui.WIDGET = self.build_gui()
        self.gui.get_container_widget().remove(self.gui.textview)
        self.gui.get_container_widget().add_with_viewport(self.gui.WIDGET)
        self.gui.WIDGET.show()

    def build_gui(self):
        """
        Build the GUI interface.
        """
        top = Gtk.HBox()
        self.photo = Photo()
        self.photo.show()
        view = Gtk.TreeView()
        titles = [(_("Object"), 1, 250)]
        self.model = ListModel(view, titles, list_mode="tree", select_func=self.row_selected)
        top.pack_start(view, True, True, 0)
        top.pack_start(self.photo, True, False, 5)
        top.show_all()
        return top

    def db_changed(self):
        self.dbstate.db.connect("person-update", self.update)
        self.update()

    def active_changed(self, handle):
        self.update()

    def update_has_data(self):
        active_handle = self.get_active("Person")
        active = self.dbstate.db.get_person_from_handle(active_handle)
        self.set_has_data(self.get_has_data(active))

    def main(self):
        active_handle = self.get_active("Person")
        active = self.dbstate.db.get_person_from_handle(active_handle)

        self.model.clear()
        self.photo.set_image(None)
        if active:
            self.display_data(active)
        else:
            self.set_has_data(False)

    def display_data(self, person):
        """
        Display the object tree for the active person.
        """
        self.add_media(person)
        self.add_events(person)
        self.add_sources(person)
        self.set_has_data(self.model.count > 0)

    def add_events(self, obj, parent_node=None):
        """
        Add event nodes to the model.
        """
        for event_ref in obj.get_event_ref_list():
            handle = event_ref.ref
            name, event = navigation_label(self.dbstate.db, "Event", handle)
            node = self.model.add([name], node=parent_node)
            self.add_sources(event, node)
            self.add_media(event, node)

    def add_sources(self, obj, parent_node=None):
        """
        Add source nodes to the model.
        """
        for citation_handle in obj.get_citation_list():
            citation = self.dbstate.db.get_citation_from_handle(citation_handle)
            handle = citation.get_reference_handle()
            name, src = navigation_label(self.dbstate.db, "Source", handle)
            node = self.model.add([name], node=parent_node)
            self.add_media(src, node)

    def add_media(self, obj, parent_node=None):
        """
        Add media object nodes to the model.
        """
        for media_ref in obj.get_media_list():
            handle = media_ref.ref
            name, media = navigation_label(self.dbstate.db, "Media", handle)
            full_path = media_path_full(self.dbstate.db, media.get_path())
            rect = media_ref.get_rectangle()
            self.model.add([name], info=media_ref, node=parent_node)

    def row_selected(self, selection):
        """
        Change the image when a row is selected.
        """
        selected = self.model.get_selected_objects()
        if selected:
            if selected[0]:
                self.load_image(selected[0])
            else:
                self.photo.set_image(None)
        else:
            self.photo.set_image(None)

    def load_image(self, media_ref):
        """
        Display an image from the given media reference.
        """
        media = self.dbstate.db.get_object_from_handle(media_ref.ref)
        full_path = media_path_full(self.dbstate.db, media.get_path())
        mime_type = media.get_mime_type()
        rectangle = media_ref.get_rectangle()
        self.photo.set_image(full_path, mime_type, rectangle)

    def get_has_data(self, person):
        """
        Return True if the gramplet has data, else return False.
        """
        if person is None:
            return False
        elif person.get_event_ref_list():
            return True
        elif person.get_citation_list():
            return True
        elif person.get_media_list():
            return True
        return False
Пример #27
0
class PersonResidence(Gramplet):
    """
    Displays residence events for a person.
    """
    def init(self):
        self.gui.WIDGET = self.build_gui()
        self.gui.get_container_widget().remove(self.gui.textview)
        self.gui.get_container_widget().add(self.gui.WIDGET)
        self.gui.WIDGET.show()

    def build_gui(self):
        """
        Build the GUI interface.
        """
        tip = _('Double-click on a row to edit the selected event.')
        self.set_tooltip(tip)
        top = Gtk.TreeView()
        titles = [('', NOSORT, 50,),
                  (_('Date'), 1, 200),
                  (_('Place'), 2, 200)]
        self.model = ListModel(top, titles, event_func=self.edit_event)
        return top

    def db_changed(self):
        self.connect(self.dbstate.db, 'person-update', self.update)

    def active_changed(self, handle):
        self.update()

    def update_has_data(self):
        active_handle = self.get_active('Person')
        if active_handle:
            active = self.dbstate.db.get_person_from_handle(active_handle)
            self.set_has_data(self.get_has_data(active))
        else:
            self.set_has_data(False)

    def get_has_data(self, active_person):
        """
        Return True if the gramplet has data, else return False.
        """
        if active_person:
            for event_ref in active_person.get_event_ref_list():
                if int(event_ref.get_role()) == EventRoleType.PRIMARY:
                    event = self.dbstate.db.get_event_from_handle(event_ref.ref)
                    if int(event.get_type()) == EventType.RESIDENCE:
                        return True
        return False

    def main(self): # return false finishes
        self.model.clear()
        active_handle = self.get_active('Person')
        if active_handle:
            active_person = self.dbstate.db.get_person_from_handle(active_handle)
            if active_person:
                self.display_person(active_person)
            else:
                self.set_has_data(False)
        else:
            self.set_has_data(False)

    def display_person(self, active_person):
        """
        Display the residence events of the active person.
        """
        count = 0
        for event_ref in active_person.get_event_ref_list():
            if int(event_ref.get_role()) == EventRoleType.PRIMARY:
                event = self.dbstate.db.get_event_from_handle(event_ref.ref)
                if int(event.get_type()) == EventType.RESIDENCE:
                    self.add_residence(event)
                    count += 1
        self.set_has_data(count > 0)

    def add_residence(self, event):
        """
        Add a residence event to the model.
        """
        date = get_date(event)
        place = ''
        handle = event.get_place_handle()
        if handle:
            place = place_displayer.display_event(self.dbstate.db, event)
        self.model.add((event.get_handle(), date, place))

    def edit_event(self, treeview):
        """
        Edit the selected event.
        """
        model, iter_ = treeview.get_selection().get_selected()
        if iter_:
            handle = model.get_value(iter_, 0)
            try:
                event = self.dbstate.db.get_event_from_handle(handle)
                EditEvent(self.dbstate, self.uistate, [], event)
            except WindowActiveError:
                pass
Пример #28
0
class PersonChildren(Children):
    """
    Displays the children of a person.
    """
    def build_gui(self):
        """
        Build the GUI interface.
        """
        tip = _('Double-click on a row to edit the selected child.')
        self.set_tooltip(tip)
        top = Gtk.TreeView()
        titles = [('', NOSORT, 50,),
                  (_('Child'), 1, 250),
                  (_('Birth Date'), 3, 100),
                  ('', 3, 100),
                  (_('Death Date'), 5, 100),
                  ('', 5, 100),
                  (_('Spouse'), 6, 250)]
        self.model = ListModel(top, titles, event_func=self.edit_person)
        return top

    def db_changed(self):
        self.dbstate.db.connect('person-update', self.update)

    def active_changed(self, handle):
        self.update()

    def main(self):
        active_handle = self.get_active('Person')
        self.model.clear()
        if active_handle:
            self.display_person(active_handle)
        else:
            self.set_has_data(False)

    def update_has_data(self):
        active_handle = self.get_active('Person')
        if active_handle:
            active = self.dbstate.db.get_person_from_handle(active_handle)
            self.set_has_data(self.get_has_data(active))
        else:
            self.set_has_data(False)

    def get_has_data(self, active_person):
        """
        Return True if the gramplet has data, else return False.
        """
        if active_person is None:
            return False
        for family_handle in active_person.get_family_handle_list():
            family = self.dbstate.db.get_family_from_handle(family_handle)
            if family and family.get_child_ref_list():
                return True
        return False

    def display_person(self, active_handle):
        """
        Display the children of the active person.
        """
        active_person = self.dbstate.db.get_person_from_handle(active_handle)
        for family_handle in active_person.get_family_handle_list():
            family = self.dbstate.db.get_family_from_handle(family_handle)
            self.display_family(family, active_person)
        self.set_has_data(self.model.count > 0)

    def display_family(self, family, active_person):
        """
        Display the children of given family.
        """
        spouse_handle = find_spouse(active_person, family)
        if spouse_handle:
            spouse = self.dbstate.db.get_person_from_handle(spouse_handle)
        else:
            spouse = None

        for child_ref in family.get_child_ref_list():
            child = self.dbstate.db.get_person_from_handle(child_ref.ref)
            self.add_child(child, spouse)

    def add_child(self, child, spouse):
        """
        Add a child to the model.
        """
        name = name_displayer.display(child)
        if spouse:
            spouse = name_displayer.display(spouse)
        spouse = spouse or ''
        birth = get_birth_or_fallback(self.dbstate.db, child)
        birth_date, birth_sort, birth_place = self.get_date_place(birth)
        death = get_death_or_fallback(self.dbstate.db, child)
        death_date, death_sort, death_place = self.get_date_place(death)
        self.model.add((child.get_handle(),
                        name,
                        birth_date,
                        birth_sort,
                        death_date,
                        death_sort,
                        spouse))
Пример #29
0
class Descendant(Gramplet):
    """
    Gramplet to display descendants of the active person.
    """
    def init(self):
        self.gui.WIDGET = self.build_gui()
        self.gui.get_container_widget().remove(self.gui.textview)
        self.gui.get_container_widget().add(self.gui.WIDGET)
        self.gui.WIDGET.show()

    def build_gui(self):
        """
        Build the GUI interface.
        """
        self.view = Gtk.TreeView()
        self.view.set_tooltip_column(3)
        titles = [(_('Name'), 0, 230),
                  (_('Birth'), 2, 100),
                  ('', NOSORT, 1),
                  ('', NOSORT, 1), # tooltip
                  ('', NOSORT, 100)] # handle
        self.model = ListModel(self.view, titles, list_mode="tree",
                               event_func=self.cb_double_click,
                               right_click=self.cb_right_click)
        return self.view

    def get_has_data(self, active_handle):
        """
        Return True if the gramplet has data, else return False.
        """
        if active_handle:
            person = self.dbstate.db.get_person_from_handle(active_handle)
            if person:
                for family_handle in person.get_family_handle_list():
                    family = self.dbstate.db.get_family_from_handle(family_handle)
                    if family:
                        for child_ref in family.get_child_ref_list():
                            return True
        return False

    def cb_double_click(self, treeview):
        """
        Handle double click on treeview.
        """
        (model, iter_) = treeview.get_selection().get_selected()
        if not iter_:
            return

        try:
            handle = model.get_value(iter_, 4)
            person = self.dbstate.db.get_person_from_handle(handle)
            EditPerson(self.dbstate, self.uistate, [], person)
        except WindowActiveError:
            pass

    def cb_right_click(self, treeview, event):
        """
        Handle right click on treeview.
        """
        (model, iter_) = treeview.get_selection().get_selected()
        sensitivity = 1 if iter_ else 0
        menu = Gtk.Menu()
        menu.set_title(_('Descendent Menu'))
        entries = [
            (_("Edit"), lambda obj: self.cb_double_click(treeview),
             sensitivity),
            (None, None, 0),
            (_("Copy all"), lambda obj: self.on_copy_all(treeview), 1),
        ]
        for stock_id, callback, sensitivity in entries:
            item = Gtk.ImageMenuItem(stock_id)
            if callback:
                item.connect("activate", callback)
            item.set_sensitive(sensitivity)
            item.show()
            menu.append(item)
        self.menu = menu
        self.menu.popup(None, None, None, None, event.button, event.time)

    def on_copy_all(self, treeview):
        """
        Copy tree to clipboard.
        """
        model = treeview.get_model()
        text = model_to_text(model, [0, 1], level=1)
        text_to_clipboard(text)

    def db_changed(self):
        self.update()

    def active_changed(self, handle):
        self.update()

    def update_has_data(self):
        active_handle = self.get_active('Person')
        if active_handle:
            self.set_has_data(self.get_has_data(active_handle))
        else:
            self.set_has_data(False)

    def main(self):
        active_handle = self.get_active('Person')
        self.model.clear()
        if active_handle:
            self.add_to_tree(None, active_handle)
            self.view.expand_all()
            self.set_has_data(self.get_has_data(active_handle))
        else:
            self.set_has_data(False)

    def add_to_tree(self, parent_id, person_handle):
        """
        Add a person to the tree.
        """
        person = self.dbstate.db.get_person_from_handle(person_handle)
        name = name_displayer.display(person)

        birth = get_birth_or_fallback(self.dbstate.db, person)
        death = get_death_or_fallback(self.dbstate.db, person)

        birth_text = birth_date = birth_sort = ''
        if birth:
            birth_date = get_date(birth)
            birth_sort = '%012d' % birth.get_date_object().get_sort_value()
            birth_text = _('%(abbr)s %(date)s') % \
                         {'abbr': birth.type.get_abbreviation(),
                          'date': birth_date}

        death_date = death_sort = death_text = ''
        if death:
            death_date = get_date(death)
            death_sort = '%012d' % death.get_date_object().get_sort_value()
            death_text = _('%(abbr)s %(date)s') % \
                         {'abbr': death.type.get_abbreviation(),
                          'date': death_date}

        tooltip = name + '\n' + birth_text + '\n' + death_text

        item_id = self.model.add([name, birth_date, birth_sort,
                                  tooltip, person_handle], node=parent_id)

        for family_handle in person.get_family_handle_list():
            family = self.dbstate.db.get_family_from_handle(family_handle)
            for child_ref in family.get_child_ref_list():
                self.add_to_tree(item_id, child_ref.ref)
        return item_id
Пример #30
0
    def __init__(self, dbstate, user, options_class, name, callback=None):
        uistate = user.uistate
        self.label = _("Relation and distances with root")
        self.dbstate = dbstate
        FilterClass = GenericFilterFactory('Person')
        self.path = '.'
        filter = FilterClass()

        tool.Tool.__init__(self, dbstate, options_class, name)
        if uistate:

            window = Gtk.Window()
            window.set_default_size(880, 600)

            box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=0)
            window.add(box)

            # dirty work-around for Gtk.HeaderBar() and FolderChooser

            chooser = Gtk.FileChooserDialog(_("Folder Chooser"),
                                            parent=uistate.window,
                                            action=Gtk.FileChooserAction.SELECT_FOLDER,
                                            buttons=(_('_Cancel'),
                                                     Gtk.ResponseType.CANCEL,
                                                     _('_Select'),
                                                     Gtk.ResponseType.OK))
            chooser.set_tooltip_text(_("Please, select a folder"))
            status = chooser.run()
            if status == Gtk.ResponseType.OK:
                # work-around 'IsADirectoryError' with self()
                # TypeError: invalid file: gi.FunctionInfo()
                self.path = chooser.get_current_folder()
            chooser.destroy()

            ManagedWindow.__init__(self, uistate, [],
                                   self.__class__)
            self.titles = [
                (_('Rel_id'), 0, 40, INTEGER), # would be INTEGER
                (_('Relation'), 1, 300, str),
                (_('Name'), 2, 200, str),
                (_('up'), 3, 35, INTEGER),
                (_('down'), 4, 35, INTEGER),
                (_('Common MRA'), 5, 40, INTEGER),
                (_('Rank'), 6, 40, INTEGER),
                (_('Period'), 7, 40, str),
                ]

            treeview = Gtk.TreeView()
            model = ListModel(treeview, self.titles)
            s = Gtk.ScrolledWindow()
            s.add(treeview)
            box.pack_start(s, True, True, 0)

            button = Gtk.Button(label=_("Save"))
            button.connect("clicked", self.button_clicked)
            box.pack_end(button, False, True, 0)

        self.stats_list = []

        # behavior can be different according to CPU and generation depth

        max_level = config.get('behavior.generation-depth')
        # compact and interlinked tree
        # single core 2.80 Ghz needs +/- 0.1 second per person
        if max_level >= 15:
            var = max_level * 0.01
        elif 10 <= max_level < 15:
            var = max_level * 0.02
        else:
            var = max_level * 0.025

        plist = self.dbstate.db.iter_person_handles()
        length = self.dbstate.db.get_number_of_people()
        default_person = self.dbstate.db.get_default_person()
        if uistate:
            self.progress = ProgressMeter(self.label, can_cancel=True,
                                          parent=window)
        else:
            self.progress = ProgressMeter(self.label)

        if default_person: # rather designed for run via GUI...
            root_id = default_person.get_gramps_id()
            ancestors = rules.person.IsAncestorOf([str(root_id), True])
            descendants = rules.person.IsDescendantOf([str(root_id), True])
            related = rules.person.IsRelatedWith([str(root_id)])

            # filtering people can be useful on some large data set
            # counter on filtering pass was not efficient
            # Not the proper solution, but a lazy one providing expected message

            filter.add_rule(related)
            self.progress.set_pass(_('Please wait, filtering...'))
            filtered_list = filter.apply(self.dbstate.db, plist)

            relationship = get_relationship_calculator()
        else: # TODO: provide selection widget for CLI and GUI
            WarningDialog(_("No default_person"))
            return

        count = 0
        filtered_people = len(filtered_list)
        self.progress.set_pass(_('Generating relation map...'), filtered_people)
        if self.progress.get_cancelled():
            self.progress.close()
            return
        step_one = time.clock() # init for counters
        for handle in filtered_list:
            nb = len(self.stats_list)
            count += 1
            self.progress.step()
            step_two = time.clock()
            start = 99
            if count > start: # provide a basic interface for counters
                need = (step_two - step_one) / count
                wait = need * filtered_people
                remain = int(wait) - int(step_two - step_one)
                # sorry, lazy
                header = _("%d/%d \n %d/%d seconds \n %d/%d \n%f|\t%f"
                           % (count, filtered_people, remain, int(wait),
                              nb, length, float(need), float(var))
                          )
                self.progress.set_header(header)
                if self.progress.get_cancelled():
                    self.progress.close()
                    return
            person = dbstate.db.get_person_from_handle(handle)

            timeout_one = time.clock() # for delta and timeout estimations
            dist = relationship.get_relationship_distance_new(
                dbstate.db, default_person, person, only_birth=True)
            timeout_two = time.clock()

            rank = dist[0][0]
            if rank == -1 or rank > max_level: # not related and ignored people
                continue

            limit = timeout_two - timeout_one
            expect = (limit - var) / max_level
            if limit > var:
                n = name_displayer.display(person)
                _LOG.debug("Sorry! '{0}' needs {1} second, \
                            variation = '{2}'".format(n,
                                                      limit,
                                                      expect
                                                     )
                          )
                continue
            else:
                _LOG.debug("variation = '{}'".format(limit)) # delta, see above max_level 'wall' section
                rel = relationship.get_one_relationship(
                    dbstate.db, default_person, person)
                rel_a = dist[0][2]
                Ga = len(rel_a)
                rel_b = dist[0][4]
                Gb = len(rel_b)
                mra = 1

                # m: mother; f: father
                if Ga > 0:
                    for letter in rel_a:
                        if letter == 'm':
                            mra = mra * 2 + 1
                        if letter == 'f':
                            mra = mra * 2
                    # design: mra gender will be often female (m: mother)
                    if rel_a[-1] == "f" and Gb != 0: # male gender, look at spouse
                        mra = mra + 1

                name = name_displayer.display(person)
                # pseudo privacy; sample for DNA stuff and mapping
                import hashlib
                no_name = hashlib.sha384(name.encode() + handle.encode()).hexdigest()
                _LOG.info(no_name) # own internal password via handle

                kekule = number.get_number(Ga, Gb, rel_a, rel_b)

                # workaround - possible unique ID and common numbers
                uuid = str(uuid4())
                _LOG.info("Random UUID: {}".format(uuid))

                if kekule == "u": # TODO: cousin(e)s need a key
                    kekule = 0
                if kekule == "nb": # non-birth
                    kekule = -1
                try:
                    test = int(kekule)
                except: # 1: related to mother; 0.x : no more girls lineage
                    kekule = 1

                period = get_timeperiod(self.dbstate.db, handle)

                # sometimes 'iterator' (generator) is more faster
                #handle_list = map(handle, filtered_list)
                iterator = (handle for handle in filtered_list)

                # experimentations; not used yet
                new_list=[int(kekule), int(Ga), int(Gb), int(mra), int(rank)]
                if max_level > 7:
                    line = (iterator, array('l', new_list))
                else:
                    line = (iterator, array('b', new_list))

                self.stats_list.append((int(kekule), rel, name, int(Ga),
                                        int(Gb), int(mra), int(rank), str(period)))
        self.progress.close()

        from itertools import groupby
        for key, items in groupby(self.stats_list, lambda x: x[0]):
            for subitem in items:
                _LOG.info(subitem)

        _LOG.debug("total: {}".format(nb))
        for entry in self.stats_list:
            if uistate:
                model.add(entry, entry[0])
            else:
                print(entry)
        if uistate:
            window.show()
            self.set_window(window, None, self.label)
            self.show()
class MediaBrowser(Gramplet):
    """
    Displays an object tree and a media preview for a person.
    """
    def init(self):
        self.gui.WIDGET = self.build_gui()
        self.gui.get_container_widget().remove(self.gui.textview)
        self.gui.get_container_widget().add_with_viewport(self.gui.WIDGET)
        self.gui.WIDGET.show()

    def build_gui(self):
        """
        Build the GUI interface.
        """
        top = Gtk.HBox()
        self.photo = Photo()
        self.photo.show()
        view = Gtk.TreeView()
        titles = [(_('Object'), 1, 250)]
        self.model = ListModel(view,
                               titles,
                               list_mode="tree",
                               select_func=self.row_selected)
        top.pack_start(view, True, True, 0)
        top.pack_start(self.photo, True, False, 5)
        top.show_all()
        return top

    def db_changed(self):
        self.connect(self.dbstate.db, 'person-update', self.update)

    def active_changed(self, handle):
        self.update()

    def update_has_data(self):
        active_handle = self.get_active('Person')
        active = self.dbstate.db.get_person_from_handle(active_handle)
        self.set_has_data(self.get_has_data(active))

    def main(self):
        self.model.clear()
        self.photo.set_image(None)
        active_handle = self.get_active('Person')
        if self.dbstate.db.has_person_handle(active_handle):
            self.display_data(
                self.dbstate.db.get_person_from_handle(active_handle))
        else:
            self.set_has_data(False)

    def display_data(self, person):
        """
        Display the object tree for the active person.
        """
        self.add_media(person)
        self.add_events(person)
        self.add_sources(person)
        self.set_has_data(self.model.count > 0)

    def add_events(self, obj, parent_node=None):
        """
        Add event nodes to the model.
        """
        for event_ref in obj.get_event_ref_list():
            handle = event_ref.ref
            name, event = navigation_label(self.dbstate.db, 'Event', handle)
            node = self.model.add([name], node=parent_node)
            self.add_sources(event, node)
            self.add_media(event, node)

    def add_sources(self, obj, parent_node=None):
        """
        Add source nodes to the model.
        """
        for citation_handle in obj.get_citation_list():
            citation = self.dbstate.db.get_citation_from_handle(
                citation_handle)
            handle = citation.get_reference_handle()
            name, src = navigation_label(self.dbstate.db, 'Source', handle)
            node = self.model.add([name], node=parent_node)
            self.add_media(src, node)

    def add_media(self, obj, parent_node=None):
        """
        Add media object nodes to the model.
        """
        for media_ref in obj.get_media_list():
            handle = media_ref.ref
            name, media = navigation_label(self.dbstate.db, 'Media', handle)
            full_path = media_path_full(self.dbstate.db, media.get_path())
            rect = media_ref.get_rectangle()
            self.model.add([name], info=media_ref, node=parent_node)

    def row_selected(self, selection):
        """
        Change the image when a row is selected.
        """
        selected = self.model.get_selected_objects()
        if selected:
            if selected[0]:
                self.load_image(selected[0])
            else:
                self.photo.set_image(None)
        else:
            self.photo.set_image(None)

    def load_image(self, media_ref):
        """
        Display an image from the given media reference.
        """
        media = self.dbstate.db.get_media_from_handle(media_ref.ref)
        full_path = media_path_full(self.dbstate.db, media.get_path())
        mime_type = media.get_mime_type()
        rectangle = media_ref.get_rectangle()
        self.photo.set_image(full_path, mime_type, rectangle)

    def get_has_data(self, person):
        """
        Return True if the gramplet has data, else return False.
        """
        if person is None:
            return False
        elif person.get_event_ref_list():
            return True
        elif person.get_citation_list():
            return True
        elif person.get_media_list():
            return True
        return False
Пример #32
0
class Events(Gramplet, DbGUIElement):

    def __init__(self, gui, nav_group=0):
        Gramplet.__init__(self, gui, nav_group)
        DbGUIElement.__init__(self, self.dbstate.db)

    """
    Displays the events for a person or family.
    """
    def init(self):
        self.gui.WIDGET = self.build_gui()
        self.gui.get_container_widget().remove(self.gui.textview)
        self.gui.get_container_widget().add(self.gui.WIDGET)
        self.gui.WIDGET.show()

    def _connect_db_signals(self):
        """
        called on init of DbGUIElement, connect to db as required.
        """
        self.callman.register_callbacks({'event-update': self.changed})
        self.callman.connect_all(keys=['event'])

    def changed(self, handle):
        """
        Called when a registered event is updated.
        """
        self.update()

    def build_gui(self):
        """
        Build the GUI interface.
        """
        tip = _('Double-click on a row to edit the selected event.')
        self.set_tooltip(tip)
        top = Gtk.TreeView()
        titles = [('', NOSORT, 50,),
                  (_('Type'), 1, 100),
                  (_('Description'), 2, 150),
                  (_('Date'), 3, 100),
                  ('', NOSORT, 50),
                  (_('Age'), 4, 100),
                  ('', NOSORT, 50),
                  (_('Place'), 5, 400),
                  (_('Main Participants'), 6, 200),
                  (_('Role'), 7, 100)]
        self.model = ListModel(top, titles, event_func=self.edit_event)
        return top

    def add_event_ref(self, event_ref, spouse=None):
        """
        Add an event to the model.
        """
        self.callman.register_handles({'event': [event_ref.ref]})
        event = self.dbstate.db.get_event_from_handle(event_ref.ref)
        event_date = get_date(event)
        event_sort = '%012d' % event.get_date_object().get_sort_value()
        person_age      = self.column_age(event)
        person_age_sort = self.column_sort_age(event)
        place = place_displayer.display_event(self.dbstate.db, event)

        participants = get_participant_from_event(self.dbstate.db,
                                                  event_ref.ref)

        self.model.add((event.get_handle(),
                        str(event.get_type()),
                        event.get_description(),
                        event_date,
                        event_sort,
                        person_age,
                        person_age_sort,
                        place,
                        participants,
                        str(event_ref.get_role())))

    def column_age(self, event):
        """
        Returns a string representation of age in years.  Change
        precision=2 for "year, month", or precision=3 for "year,
        month, days"
        """
        date = event.get_date_object()
        start_date = self.get_start_date()
        if date and start_date:
            return (date - start_date).format(precision=age_precision)
        else:
            return ""

    def column_sort_age(self, event):
        """
        Returns a string version of number of days of age.
        """
        date = event.get_date_object()
        start_date = self.get_start_date()
        if date and start_date:
            return "%09d" % int(date - start_date)
        else:
            return ""

    def edit_event(self, treeview):
        """
        Edit the selected event.
        """
        model, iter_ = treeview.get_selection().get_selected()
        if iter_:
            handle = model.get_value(iter_, 0)
            try:
                event = self.dbstate.db.get_event_from_handle(handle)
                EditEvent(self.dbstate, self.uistate, [], event)
            except WindowActiveError:
                pass
Пример #33
0
class Locations(Gramplet, DbGUIElement):
    def __init__(self, gui, nav_group=0):
        Gramplet.__init__(self, gui, nav_group)
        DbGUIElement.__init__(self, self.dbstate.db)

    """
    Gramplet showing the locations of a place over time.
    """

    def init(self):
        self.gui.WIDGET = self.build_gui()
        self.gui.get_container_widget().remove(self.gui.textview)
        self.gui.get_container_widget().add(self.gui.WIDGET)
        self.gui.WIDGET.show()

    def _connect_db_signals(self):
        """
        called on init of DbGUIElement, connect to db as required.
        """
        self.callman.register_callbacks({'place-update': self.changed})
        self.callman.connect_all(keys=['place'])

    def db_changed(self):
        self.connect_signal('Place', self.update)

    def changed(self, handle):
        """
        Called when a registered place is updated.
        """
        self.update()

    def build_gui(self):
        """
        Build the GUI interface.
        """
        tip = _('Double-click on a row to edit the selected place.')
        self.set_tooltip(tip)
        top = Gtk.TreeView()
        titles = [('', 0, 50), (_('Name'), 1, 300), (_('Type'), 2, 150),
                  (_('Date'), 4, 150), ('', NOSORT, 50)]
        self.model = ListModel(top,
                               titles,
                               list_mode="tree",
                               event_func=self.edit_place)
        return top

    def active_changed(self, handle):
        self.update()

    def update_has_data(self):
        active_handle = self.get_active('Place')
        if active_handle:
            active = self.dbstate.db.get_place_from_handle(active_handle)
            self.set_has_data(self.get_has_data(active))
        else:
            self.set_has_data(False)

    def main(self):
        self.model.clear()
        self.callman.unregister_all()
        active_handle = self.get_active('Place')
        if active_handle:
            active = self.dbstate.db.get_place_from_handle(active_handle)
            if active:
                self.display_place(active, None, [active_handle])
            else:
                self.set_has_data(False)
        else:
            self.set_has_data(False)

    def display_place(self, place, node, visited):
        """
        Display the location hierarchy for the active place.
        """
        self.callman.register_obj(place)
        for placeref in place.get_placeref_list():
            if placeref.ref in visited:
                continue

            place_date = get_date(placeref)
            place_sort = '%012d' % placeref.get_date_object().get_sort_value()
            parent_place = self.dbstate.db.get_place_from_handle(placeref.ref)
            parent_name = parent_place.get_name().get_value()
            parent_type = str(parent_place.get_type())

            parent_node = self.model.add([
                placeref.ref, parent_name, parent_type, place_date, place_sort
            ],
                                         node=node)

            self.display_place(parent_place, parent_node,
                               visited + [placeref.ref])

        self.set_has_data(self.model.count > 0)
        self.model.tree.expand_all()

    def get_has_data(self, place):
        """
        Return True if the gramplet has data, else return False.
        """
        if place is None:
            return False
        if len(place.get_placeref_list()) > 0:
            return True
        else:
            return False

    def edit_place(self, treeview):
        """
        Edit the selected place.
        """
        model, iter_ = treeview.get_selection().get_selected()
        if iter_:
            handle = model.get_value(iter_, 0)
            place = self.dbstate.db.get_place_from_handle(handle)
            try:
                EditPlace(self.dbstate, self.uistate, [], place)
            except WindowActiveError:
                pass