Split DefaultGramplets into their respective files
svn: r11790
This commit is contained in:
Doug Blank
parent
8af25caf2e
commit
248002b819
@ -262,12 +262,27 @@ src/plugins/export/ExportVCalendar.py
|
||||
src/plugins/export/ExportVCard.py
|
||||
|
||||
# plugins/gramplet directory
|
||||
src/plugins/gramplet/AgeOnDateGramplet.py
|
||||
src/plugins/gramplet/AgeStats.py
|
||||
src/plugins/gramplet/AttributesGramplet.py
|
||||
src/plugins/gramplet/DefaultGramplets.py
|
||||
src/plugins/gramplet/CalendarGramplet.py
|
||||
src/plugins/gramplet/DataEntryGramplet.py
|
||||
src/plugins/gramplet/DescendGramplet.py
|
||||
src/plugins/gramplet/FanChartGramplet.py
|
||||
src/plugins/gramplet/FaqGramplet.py
|
||||
src/plugins/gramplet/GivenNameGramplet.py
|
||||
src/plugins/gramplet/HeadlineNewsGramplet.py
|
||||
src/plugins/gramplet/NoteGramplet.py
|
||||
src/plugins/gramplet/PedigreeGramplet.py
|
||||
src/plugins/gramplet/PythonGramplet.py
|
||||
src/plugins/gramplet/QuickViewGramplet.py
|
||||
src/plugins/gramplet/RelativeGramplet.py
|
||||
src/plugins/gramplet/SessionLogGramplet.py
|
||||
src/plugins/gramplet/StatsGramplet.py
|
||||
src/plugins/gramplet/SurnameCloudGramplet.py
|
||||
src/plugins/gramplet/ToDoGramplet.py
|
||||
src/plugins/gramplet/TopSurnamesGramplet.py
|
||||
src/plugins/gramplet/WelcomeGramplet.py
|
||||
src/plugins/gramplet/WhatsNext.py
|
||||
|
||||
# plugins/graph directory
|
||||
|
||||
94
src/plugins/gramplet/AgeOnDateGramplet.py
Normal file
94
src/plugins/gramplet/AgeOnDateGramplet.py
Normal file
@ -0,0 +1,94 @@
|
||||
# Gramps - a GTK+/GNOME based genealogy program
|
||||
#
|
||||
# Copyright (C) 2007-2009 Douglas S. Blank <doug.blank@gmail.com>
|
||||
#
|
||||
# This program is free software; you can redistribute it and/or modify
|
||||
# it under the terms of the GNU General Public License as published by
|
||||
# the Free Software Foundation; either version 2 of the License, or
|
||||
# (at your option) any later version.
|
||||
#
|
||||
# This program is distributed in the hope that it will be useful,
|
||||
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
# GNU General Public License for more details.
|
||||
#
|
||||
# You should have received a copy of the GNU General Public License
|
||||
# along with this program; if not, write to the Free Software
|
||||
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
|
||||
# $Id$
|
||||
|
||||
#------------------------------------------------------------------------
|
||||
#
|
||||
# Python modules
|
||||
#
|
||||
#------------------------------------------------------------------------
|
||||
|
||||
#------------------------------------------------------------------------
|
||||
#
|
||||
# GRAMPS modules
|
||||
#
|
||||
#------------------------------------------------------------------------
|
||||
from DataViews import register, Gramplet
|
||||
from TransUtils import sgettext as _
|
||||
import DateHandler
|
||||
from QuickReports import run_quick_report_by_name
|
||||
|
||||
#------------------------------------------------------------------------
|
||||
#
|
||||
# Gramplet class
|
||||
#
|
||||
#------------------------------------------------------------------------
|
||||
class AgeOnDateGramplet(Gramplet):
|
||||
def init(self):
|
||||
import gtk
|
||||
# GUI setup:
|
||||
self.set_tooltip(_("Enter a date, click Run"))
|
||||
vbox = gtk.VBox()
|
||||
hbox = gtk.HBox()
|
||||
# label, entry
|
||||
description = gtk.TextView()
|
||||
description.set_wrap_mode(gtk.WRAP_WORD)
|
||||
description.set_editable(False)
|
||||
buffer = description.get_buffer()
|
||||
buffer.set_text(_("Enter a date in the entry below and click Run."
|
||||
" This will compute the ages for everyone in your"
|
||||
" Family Tree on that date. You can then sort by"
|
||||
" the age column, and double-click the row to view"
|
||||
" or edit."))
|
||||
label = gtk.Label()
|
||||
label.set_text(_("Date") + ":")
|
||||
self.entry = gtk.Entry()
|
||||
button = gtk.Button(_("Run"))
|
||||
button.connect("clicked", self.run)
|
||||
##self.filter =
|
||||
hbox.pack_start(label, False)
|
||||
hbox.pack_start(self.entry, True)
|
||||
vbox.pack_start(description, True)
|
||||
vbox.pack_start(hbox, False)
|
||||
vbox.pack_start(button, False)
|
||||
self.gui.get_container_widget().remove(self.gui.textview)
|
||||
self.gui.get_container_widget().add_with_viewport(vbox)
|
||||
vbox.show_all()
|
||||
|
||||
def run(self, obj):
|
||||
text = self.entry.get_text()
|
||||
date = DateHandler.parser.parse(text)
|
||||
run_quick_report_by_name(self.gui.dbstate,
|
||||
self.gui.uistate,
|
||||
'ageondate',
|
||||
date)
|
||||
|
||||
#------------------------------------------------------------------------
|
||||
#
|
||||
# Register Gramplet
|
||||
#
|
||||
#------------------------------------------------------------------------
|
||||
register(type="gramplet",
|
||||
name="Age on Date Gramplet",
|
||||
tname=_("Age on Date Gramplet"),
|
||||
height=200,
|
||||
content = AgeOnDateGramplet,
|
||||
title=_("Age on Date"),
|
||||
)
|
||||
|
||||
68
src/plugins/gramplet/CalendarGramplet.py
Normal file
68
src/plugins/gramplet/CalendarGramplet.py
Normal file
@ -0,0 +1,68 @@
|
||||
# Gramps - a GTK+/GNOME based genealogy program
|
||||
#
|
||||
# Copyright (C) 2007-2009 Douglas S. Blank <doug.blank@gmail.com>
|
||||
#
|
||||
# This program is free software; you can redistribute it and/or modify
|
||||
# it under the terms of the GNU General Public License as published by
|
||||
# the Free Software Foundation; either version 2 of the License, or
|
||||
# (at your option) any later version.
|
||||
#
|
||||
# This program is distributed in the hope that it will be useful,
|
||||
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
# GNU General Public License for more details.
|
||||
#
|
||||
# You should have received a copy of the GNU General Public License
|
||||
# along with this program; if not, write to the Free Software
|
||||
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
|
||||
# $Id$
|
||||
|
||||
#------------------------------------------------------------------------
|
||||
#
|
||||
# GRAMPS modules
|
||||
#
|
||||
#------------------------------------------------------------------------
|
||||
from DataViews import register, Gramplet
|
||||
from TransUtils import sgettext as _
|
||||
from QuickReports import run_quick_report_by_name
|
||||
import gen.lib
|
||||
|
||||
#------------------------------------------------------------------------
|
||||
#
|
||||
# Gramplet class
|
||||
#
|
||||
#------------------------------------------------------------------------
|
||||
class CalendarGramplet(Gramplet):
|
||||
def init(self):
|
||||
import gtk
|
||||
self.set_tooltip(_("Double-click a day for details"))
|
||||
self.gui.calendar = gtk.Calendar()
|
||||
self.gui.calendar.connect('day-selected-double-click', self.double_click)
|
||||
self.gui.get_container_widget().remove(self.gui.textview)
|
||||
self.gui.get_container_widget().add_with_viewport(self.gui.calendar)
|
||||
self.gui.calendar.show()
|
||||
|
||||
def double_click(self, obj):
|
||||
# bring up events on this day
|
||||
year, month, day = self.gui.calendar.get_date()
|
||||
date = gen.lib.Date()
|
||||
date.set_yr_mon_day(year, month + 1, day)
|
||||
run_quick_report_by_name(self.gui.dbstate,
|
||||
self.gui.uistate,
|
||||
'onthisday',
|
||||
date)
|
||||
|
||||
#------------------------------------------------------------------------
|
||||
#
|
||||
# Register Gramplet
|
||||
#
|
||||
#------------------------------------------------------------------------
|
||||
register(type="gramplet",
|
||||
name="Calendar Gramplet",
|
||||
tname=_("Calendar Gramplet"),
|
||||
height=200,
|
||||
content = CalendarGramplet,
|
||||
title=_("Calendar"),
|
||||
)
|
||||
|
||||
750
src/plugins/gramplet/DataEntryGramplet.py
Normal file
750
src/plugins/gramplet/DataEntryGramplet.py
Normal file
@ -0,0 +1,750 @@
|
||||
# Gramps - a GTK+/GNOME based genealogy program
|
||||
#
|
||||
# Copyright (C) 2007-2009 Douglas S. Blank <doug.blank@gmail.com>
|
||||
#
|
||||
# This program is free software; you can redistribute it and/or modify
|
||||
# it under the terms of the GNU General Public License as published by
|
||||
# the Free Software Foundation; either version 2 of the License, or
|
||||
# (at your option) any later version.
|
||||
#
|
||||
# This program is distributed in the hope that it will be useful,
|
||||
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
# GNU General Public License for more details.
|
||||
#
|
||||
# You should have received a copy of the GNU General Public License
|
||||
# along with this program; if not, write to the Free Software
|
||||
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
|
||||
# $Id$
|
||||
|
||||
#------------------------------------------------------------------------
|
||||
#
|
||||
# GRAMPS modules
|
||||
#
|
||||
#------------------------------------------------------------------------
|
||||
from DataViews import register, Gramplet
|
||||
from BasicUtils import name_displayer
|
||||
from ReportBase import ReportUtils
|
||||
import DateHandler
|
||||
import Errors
|
||||
import gen.lib
|
||||
|
||||
#------------------------------------------------------------------------
|
||||
#
|
||||
# Gramplet class
|
||||
#
|
||||
#------------------------------------------------------------------------
|
||||
class DataEntryGramplet(Gramplet):
|
||||
NO_REL = 0
|
||||
AS_PARENT = 1
|
||||
AS_SPOUSE = 2
|
||||
AS_SIBLING = 3
|
||||
AS_CHILD = 4
|
||||
def init(self):
|
||||
self.de_column_width = 20
|
||||
import gtk
|
||||
rows = gtk.VBox()
|
||||
self.dirty = False
|
||||
self.dirty_person = None
|
||||
self.dirty_family = None
|
||||
self.de_widgets = {}
|
||||
for items in [("Active person", _("Active person"), None, True,
|
||||
[("Edit person", "", self.edit_person), ("Edit family", _("Family:"), self.edit_family)],
|
||||
False, 0),
|
||||
("APName", _("Surname, Given"), None, False, [], True, 0),
|
||||
("APGender", _("Gender"), [_("female"), _("male"), _("unknown")], False, [], True, 2),
|
||||
("APBirth", _("Birth"), None, False, [], True, 0),
|
||||
("APDeath", _("Death"), None, False, [], True, 0)
|
||||
]:
|
||||
pos, text, choices, readonly, callback, dirty, default = items
|
||||
row = self.make_row(pos, text, choices, readonly, callback, dirty, default)
|
||||
rows.pack_start(row, False)
|
||||
|
||||
# Save and Abandon
|
||||
row = gtk.HBox()
|
||||
button = gtk.Button(_("Save"))
|
||||
button.connect("clicked", self.save_data_edit)
|
||||
row.pack_start(button, True)
|
||||
button = gtk.Button(_("Abandon"))
|
||||
button.connect("clicked", self.abandon_data_edit)
|
||||
row.pack_start(button, True)
|
||||
rows.pack_start(row, False)
|
||||
|
||||
for items in [("New person", _("New person"), None, True, 0),
|
||||
("NPRelation", _("Add relation"),
|
||||
[_("No relation to active person"),
|
||||
_("Add as a Parent"),
|
||||
_("Add as a Spouse"),
|
||||
_("Add as a Sibling"),
|
||||
_("Add as a Child")],
|
||||
False, 0),
|
||||
("NPName", _("Surname, Given"), None, False, 0),
|
||||
("NPGender", _("Gender"), [_("female"), _("male"), _("unknown")], False, 2),
|
||||
("NPBirth", _("Birth"), None, False, 0),
|
||||
("NPDeath", _("Death"), None, False, 0)
|
||||
]:
|
||||
pos, text, choices, readonly, default = items
|
||||
row = self.make_row(pos, text, choices, readonly, default=default)
|
||||
rows.pack_start(row, False)
|
||||
|
||||
# Save, Abandon, Clear
|
||||
row = gtk.HBox()
|
||||
button = gtk.Button(_("Add"))
|
||||
button.connect("clicked", self.add_data_entry)
|
||||
row.pack_start(button, True)
|
||||
button = gtk.Button(_("Copy Active Data"))
|
||||
button.connect("clicked", self.copy_data_entry)
|
||||
row.pack_start(button, True)
|
||||
button = gtk.Button(_("Clear"))
|
||||
button.connect("clicked", self.clear_data_entry)
|
||||
row.pack_start(button, True)
|
||||
rows.pack_start(row, False)
|
||||
|
||||
self.gui.get_container_widget().remove(self.gui.textview)
|
||||
self.gui.get_container_widget().add_with_viewport(rows)
|
||||
rows.show_all()
|
||||
self.clear_data_entry(None)
|
||||
|
||||
def main(self): # return false finishes
|
||||
if self.dirty:
|
||||
return
|
||||
self.de_widgets["Active person:Edit family"].hide()
|
||||
self.de_widgets["Active person:Edit family:Label"].hide()
|
||||
active_person = self.dbstate.get_active_person()
|
||||
self.dirty_person = active_person
|
||||
self.dirty_family = None
|
||||
if active_person:
|
||||
self.de_widgets["Active person:Edit person"].show()
|
||||
self.de_widgets["Active person:Edit family"].hide()
|
||||
self.de_widgets["Active person:Edit family:Label"].hide()
|
||||
# Fill in current person edits:
|
||||
name = name_displayer.display(active_person)
|
||||
self.de_widgets["Active person"].set_text("<i>%s</i> " % name)
|
||||
self.de_widgets["Active person"].set_use_markup(True)
|
||||
# Name:
|
||||
name_obj = active_person.get_primary_name()
|
||||
if name_obj:
|
||||
self.de_widgets["APName"].set_text("%s, %s" %
|
||||
(name_obj.get_surname(), name_obj.get_first_name()))
|
||||
self.de_widgets["APGender"].set_active(active_person.get_gender()) # gender
|
||||
# Birth:
|
||||
birth = ReportUtils.get_birth_or_fallback(self.dbstate.db, active_person)
|
||||
birth_text = ""
|
||||
if birth:
|
||||
sdate = DateHandler.get_date(birth)
|
||||
birth_text += sdate + " "
|
||||
place_handle = birth.get_place_handle()
|
||||
if place_handle:
|
||||
place = self.dbstate.db.get_place_from_handle(place_handle)
|
||||
place_text = place.get_title()
|
||||
if place_text:
|
||||
birth_text += _("in") + " " + place_text
|
||||
|
||||
self.de_widgets["APBirth"].set_text(birth_text)
|
||||
# Death:
|
||||
death = ReportUtils.get_death_or_fallback(self.dbstate.db, active_person)
|
||||
death_text = ""
|
||||
if death:
|
||||
sdate = DateHandler.get_date(death)
|
||||
death_text += sdate + " "
|
||||
place_handle = death.get_place_handle()
|
||||
if place_handle:
|
||||
place = self.dbstate.db.get_place_from_handle(place_handle)
|
||||
place_text = place.get_title()
|
||||
if place_text:
|
||||
death_text += _("in") + " " + place_text
|
||||
self.de_widgets["APDeath"].set_text(death_text)
|
||||
family_list = active_person.get_family_handle_list()
|
||||
if len(family_list) > 0:
|
||||
self.dirty_family = self.dbstate.db.get_family_from_handle(family_list[0])
|
||||
self.de_widgets["Active person:Edit family"].show()
|
||||
self.de_widgets["Active person:Edit family:Label"].show()
|
||||
else:
|
||||
family_list = active_person.get_parent_family_handle_list()
|
||||
if len(family_list) > 0:
|
||||
self.dirty_family = self.dbstate.db.get_family_from_handle(family_list[0])
|
||||
self.de_widgets["Active person:Edit family"].show()
|
||||
self.de_widgets["Active person:Edit family:Label"].show()
|
||||
else:
|
||||
self.clear_data_edit(None)
|
||||
self.de_widgets["Active person:Edit person"].hide()
|
||||
self.de_widgets["Active person:Edit family"].hide()
|
||||
self.de_widgets["Active person:Edit family:Label"].hide()
|
||||
self.dirty = False
|
||||
|
||||
def make_row(self, pos, text, choices=None, readonly=False, callback_list=[],
|
||||
mark_dirty=False, default=0):
|
||||
import gtk
|
||||
# Data Entry: Active Person
|
||||
row = gtk.HBox()
|
||||
label = gtk.Label()
|
||||
if readonly:
|
||||
label.set_text("<b>%s</b>" % text)
|
||||
label.set_width_chars(self.de_column_width)
|
||||
label.set_use_markup(True)
|
||||
self.de_widgets[pos] = gtk.Label()
|
||||
self.de_widgets[pos].set_alignment(0.0, 0.5)
|
||||
self.de_widgets[pos].set_use_markup(True)
|
||||
label.set_alignment(0.0, 0.5)
|
||||
row.pack_start(label, False)
|
||||
row.pack_start(self.de_widgets[pos], False)
|
||||
else:
|
||||
label.set_text("%s: " % text)
|
||||
label.set_width_chars(self.de_column_width)
|
||||
label.set_alignment(1.0, 0.5)
|
||||
if choices == None:
|
||||
self.de_widgets[pos] = gtk.Entry()
|
||||
if mark_dirty:
|
||||
self.de_widgets[pos].connect("changed", self.mark_dirty)
|
||||
row.pack_start(label, False)
|
||||
row.pack_start(self.de_widgets[pos], True)
|
||||
else:
|
||||
eventBox = gtk.EventBox()
|
||||
self.de_widgets[pos] = gtk.combo_box_new_text()
|
||||
eventBox.add(self.de_widgets[pos])
|
||||
for add_type in choices:
|
||||
self.de_widgets[pos].append_text(add_type)
|
||||
self.de_widgets[pos].set_active(default)
|
||||
if mark_dirty:
|
||||
self.de_widgets[pos].connect("changed", self.mark_dirty)
|
||||
row.pack_start(label, False)
|
||||
row.pack_start(eventBox, True, True)
|
||||
for name, text, callback in callback_list:
|
||||
label = gtk.Label()
|
||||
label.set_text(text)
|
||||
self.de_widgets[pos + ":" + name + ":Label"] = label
|
||||
row.pack_start(label, False)
|
||||
icon = gtk.STOCK_EDIT
|
||||
size = gtk.ICON_SIZE_MENU
|
||||
button = gtk.Button()
|
||||
image = gtk.Image()
|
||||
image.set_from_stock(icon, size)
|
||||
button.add(image)
|
||||
button.set_relief(gtk.RELIEF_NONE)
|
||||
button.connect("clicked", callback)
|
||||
self.de_widgets[pos + ":" + name] = button
|
||||
row.pack_start(button, False)
|
||||
row.show_all()
|
||||
return row
|
||||
|
||||
def mark_dirty(self, obj):
|
||||
self.dirty = True
|
||||
|
||||
def abandon_data_edit(self, obj):
|
||||
self.dirty = False
|
||||
self.update()
|
||||
|
||||
def edit_callback(self, person):
|
||||
self.dirty = False
|
||||
self.update()
|
||||
|
||||
def edit_person(self, obj):
|
||||
from Editors import EditPerson
|
||||
try:
|
||||
EditPerson(self.gui.dbstate,
|
||||
self.gui.uistate, [],
|
||||
self.dirty_person,
|
||||
callback=self.edit_callback)
|
||||
except Errors.WindowActiveError:
|
||||
pass
|
||||
|
||||
def edit_family(self, obj):
|
||||
from Editors import EditFamily
|
||||
try:
|
||||
EditFamily(self.gui.dbstate,
|
||||
self.gui.uistate, [],
|
||||
self.dirty_family)
|
||||
except Errors.WindowActiveError:
|
||||
pass
|
||||
|
||||
def process_dateplace(self, text):
|
||||
if text == "": return None, None
|
||||
prep_in = _("in") # word or phrase that separates date from place
|
||||
text = text.strip()
|
||||
if (" %s " % prep_in) in text:
|
||||
date, place = text.split((" %s " % prep_in), 1)
|
||||
elif text.startswith("%s " % prep_in):
|
||||
date, place = text.split(("%s " % prep_in), 1)
|
||||
else:
|
||||
date, place = text, ""
|
||||
date = date.strip()
|
||||
place = place.strip()
|
||||
if date != "":
|
||||
date = DateHandler.parser.parse(date)
|
||||
else:
|
||||
date = None
|
||||
if place != "":
|
||||
newq, place = self.get_or_create_place(place)
|
||||
else:
|
||||
place = None
|
||||
return date, place
|
||||
|
||||
def get_or_create_place(self, place_name):
|
||||
if place_name == "": return (-1, None)
|
||||
place_list = self.dbstate.db.get_place_handles()
|
||||
for place_handle in place_list:
|
||||
place = self.dbstate.db.get_place_from_handle(place_handle)
|
||||
if place.get_title().strip() == place_name:
|
||||
return (0, place) # (old, object)
|
||||
place = gen.lib.Place()
|
||||
place.set_title(place_name)
|
||||
self.dbstate.db.add_place(place,self.trans)
|
||||
return (1, place) # (new, object)
|
||||
|
||||
def get_or_create_event(self, object, type, date, place):
|
||||
""" Add or find a type event on object """
|
||||
if date == place == None: return (-1, None)
|
||||
# first, see if it exists
|
||||
ref_list = object.get_event_ref_list()
|
||||
# look for a match, and possible correction
|
||||
for ref in ref_list:
|
||||
event = self.dbstate.db.get_event_from_handle(ref.ref)
|
||||
if event is not None:
|
||||
if int(event.get_type()) == type:
|
||||
# Match! Let's update
|
||||
if date:
|
||||
event.set_date_object(date)
|
||||
if place:
|
||||
event.set_place_handle(place.get_handle())
|
||||
self.dbstate.db.commit_event(event, self.trans)
|
||||
return (0, event)
|
||||
# else create it:
|
||||
event = gen.lib.Event()
|
||||
if type:
|
||||
event.set_type(gen.lib.EventType(type))
|
||||
if date:
|
||||
event.set_date_object(date)
|
||||
if place:
|
||||
event.set_place_handle(place.get_handle())
|
||||
self.dbstate.db.add_event(event, self.trans)
|
||||
return (1, event)
|
||||
|
||||
def make_event(self, type, date, place):
|
||||
if date == place == None: return None
|
||||
event = gen.lib.Event()
|
||||
event.set_type(gen.lib.EventType(type))
|
||||
if date:
|
||||
event.set_date_object(date)
|
||||
if place:
|
||||
event.set_place_handle(place.get_handle())
|
||||
self.dbstate.db.add_event(event, self.trans)
|
||||
return event
|
||||
|
||||
def make_person(self, firstname, surname, gender):
|
||||
person = gen.lib.Person()
|
||||
name = gen.lib.Name()
|
||||
name.set_type(gen.lib.NameType(gen.lib.NameType.BIRTH))
|
||||
name.set_first_name(firstname)
|
||||
name.set_surname(surname)
|
||||
person.set_primary_name(name)
|
||||
person.set_gender(gender)
|
||||
return person
|
||||
|
||||
def save_data_edit(self, obj):
|
||||
if self.dirty:
|
||||
# Save the edits ----------------------------------
|
||||
person = self.dirty_person
|
||||
# First, get the data:
|
||||
gender = self.de_widgets["APGender"].get_active()
|
||||
if "," in self.de_widgets["APName"].get_text():
|
||||
surname, firstname = self.de_widgets["APName"].get_text().split(",", 1)
|
||||
else:
|
||||
surname, firstname = self.de_widgets["APName"].get_text(), ""
|
||||
surname = surname.strip()
|
||||
firstname = firstname.strip()
|
||||
name = person.get_primary_name()
|
||||
# Now, edit it:
|
||||
self.trans = self.dbstate.db.transaction_begin()
|
||||
name.set_surname(surname)
|
||||
name.set_first_name(firstname)
|
||||
person.set_gender(gender)
|
||||
birthdate, birthplace = self.process_dateplace(self.de_widgets["APBirth"].get_text().strip())
|
||||
new, birthevent = self.get_or_create_event(person, gen.lib.EventType.BIRTH, birthdate, birthplace)
|
||||
# reference it, if need be:
|
||||
birthref = person.get_birth_ref()
|
||||
if birthevent:
|
||||
if birthref is None:
|
||||
# need new
|
||||
birthref = gen.lib.EventRef()
|
||||
birthref.set_reference_handle(birthevent.get_handle())
|
||||
person.set_birth_ref(birthref)
|
||||
deathdate, deathplace = self.process_dateplace(self.de_widgets["APDeath"].get_text().strip())
|
||||
new, deathevent = self.get_or_create_event(person, gen.lib.EventType.DEATH, deathdate, deathplace)
|
||||
# reference it, if need be:
|
||||
deathref = person.get_death_ref()
|
||||
if deathevent:
|
||||
if deathref is None:
|
||||
# need new
|
||||
deathref = gen.lib.EventRef()
|
||||
deathref.set_reference_handle(deathevent.get_handle())
|
||||
person.set_death_ref(deathref)
|
||||
self.dbstate.db.commit_person(person,self.trans)
|
||||
self.dbstate.db.transaction_commit(self.trans,
|
||||
(_("Gramplet Data Edit: %s") % name_displayer.display(person)))
|
||||
self.dirty = False
|
||||
self.update()
|
||||
|
||||
def add_data_entry(self, obj):
|
||||
from QuestionDialog import ErrorDialog
|
||||
# First, get the data:
|
||||
if "," in self.de_widgets["NPName"].get_text():
|
||||
surname, firstname = self.de_widgets["NPName"].get_text().split(",", 1)
|
||||
else:
|
||||
surname, firstname = self.de_widgets["NPName"].get_text(), ""
|
||||
surname = surname.strip()
|
||||
firstname = firstname.strip()
|
||||
gender = self.de_widgets["NPGender"].get_active()
|
||||
if self.dirty:
|
||||
current_person = self.dirty_person
|
||||
else:
|
||||
current_person = self.dbstate.get_active_person()
|
||||
# Pre-check to make sure everything is ok: -------------------------------------------
|
||||
if surname == "" and firstname == "":
|
||||
ErrorDialog(_("Please provide a name."), _("Can't add new person."))
|
||||
return
|
||||
if self.de_widgets["NPRelation"].get_active() == self.NO_REL:
|
||||
# "No relation to active person"
|
||||
pass
|
||||
elif self.de_widgets["NPRelation"].get_active() == self.AS_PARENT:
|
||||
# "Add as a Parent"
|
||||
if current_person == None:
|
||||
ErrorDialog(_("Please set an active person."), _("Can't add new person as a parent."))
|
||||
return
|
||||
elif gender == gen.lib.Person.UNKNOWN: # unknown
|
||||
ErrorDialog(_("Please set the new person's gender."), _("Can't add new person as a parent."))
|
||||
return
|
||||
elif self.de_widgets["NPRelation"].get_active() == self.AS_SPOUSE:
|
||||
# "Add as a Spouse"
|
||||
if current_person == None:
|
||||
ErrorDialog(_("Please set an active person."), _("Can't add new person as a spouse."))
|
||||
return
|
||||
elif (gender == gen.lib.Person.UNKNOWN and
|
||||
current_person.get_gender() == gen.lib.Person.UNKNOWN): # both genders unknown
|
||||
ErrorDialog(_("Please set the new person's gender."), _("Can't add new person as a spouse."))
|
||||
return
|
||||
elif self.de_widgets["NPRelation"].get_active() == self.AS_SIBLING:
|
||||
# "Add as a Sibling"
|
||||
if current_person == None:
|
||||
ErrorDialog(_("Please set an active person."), _("Can't add new person as a sibling."))
|
||||
return
|
||||
elif self.de_widgets["NPRelation"].get_active() == self.AS_CHILD:
|
||||
# "Add as a Child"
|
||||
if current_person == None:
|
||||
ErrorDialog(_("Please set an active person."), _("Can't add new person as a child."))
|
||||
return
|
||||
# Start the transaction: ------------------------------------------------------------
|
||||
self.trans = self.dbstate.db.transaction_begin()
|
||||
# New person --------------------------------------------------
|
||||
# Add birth
|
||||
new_birth_date, new_birth_place = self.process_dateplace(self.de_widgets["NPBirth"].get_text().strip())
|
||||
birth_event = self.make_event(gen.lib.EventType.BIRTH, new_birth_date, new_birth_place)
|
||||
# Add death
|
||||
new_death_date, new_death_place = self.process_dateplace(self.de_widgets["NPDeath"].get_text())
|
||||
death_event = self.make_event(gen.lib.EventType.DEATH, new_death_date, new_death_place)
|
||||
# Now, create the person and events:
|
||||
person = self.make_person(firstname, surname, gender)
|
||||
# New birth for person:
|
||||
if birth_event:
|
||||
birth_ref = gen.lib.EventRef()
|
||||
birth_ref.set_reference_handle(birth_event.get_handle())
|
||||
person.set_birth_ref(birth_ref)
|
||||
# New death for person:
|
||||
if death_event:
|
||||
death_ref = gen.lib.EventRef()
|
||||
death_ref.set_reference_handle(death_event.get_handle())
|
||||
person.set_death_ref(death_ref)
|
||||
self.dbstate.db.add_person(person, self.trans)
|
||||
# All error checking done; just add relation:
|
||||
if self.de_widgets["NPRelation"].get_active() == self.NO_REL:
|
||||
# "No relation to active person"
|
||||
pass
|
||||
elif self.de_widgets["NPRelation"].get_active() == self.AS_PARENT:
|
||||
# "Add as a Parent"
|
||||
# Go through current_person parent families
|
||||
added = False
|
||||
for family_handle in current_person.get_parent_family_handle_list():
|
||||
family = self.dbstate.db.get_family_from_handle(family_handle)
|
||||
if family:
|
||||
# find one that person would fit as a parent
|
||||
fam_husband_handle = family.get_father_handle()
|
||||
fam_wife_handle = family.get_mother_handle()
|
||||
# can we add person as wife?
|
||||
if fam_wife_handle == None and person.get_gender() == gen.lib.Person.FEMALE:
|
||||
# add the person
|
||||
family.set_mother_handle(person.get_handle())
|
||||
family.set_relationship(gen.lib.FamilyRelType.MARRIED)
|
||||
person.add_family_handle(family.get_handle())
|
||||
added = True
|
||||
break
|
||||
elif fam_husband_handle == None and person.get_gender() == gen.lib.Person.MALE:
|
||||
# add the person
|
||||
family.set_father_handle(person.get_handle())
|
||||
family.set_relationship(gen.lib.FamilyRelType.MARRIED)
|
||||
person.add_family_handle(family.get_handle())
|
||||
added = True
|
||||
break
|
||||
if added:
|
||||
self.dbstate.db.commit_family(family, self.trans)
|
||||
else:
|
||||
family = gen.lib.Family()
|
||||
self.dbstate.db.add_family(family, self.trans)
|
||||
if person.get_gender() == gen.lib.Person.MALE:
|
||||
family.set_father_handle(person.get_handle())
|
||||
elif person.get_gender() == gen.lib.Person.FEMALE:
|
||||
family.set_mother_handle(person.get_handle())
|
||||
family.set_relationship(gen.lib.FamilyRelType.MARRIED)
|
||||
# add curent_person as child
|
||||
childref = gen.lib.ChildRef()
|
||||
childref.set_reference_handle(current_person.get_handle())
|
||||
family.add_child_ref( childref)
|
||||
current_person.add_parent_family_handle(family.get_handle())
|
||||
# finalize
|
||||
person.add_family_handle(family.get_handle())
|
||||
self.dbstate.db.commit_family(family, self.trans)
|
||||
elif self.de_widgets["NPRelation"].get_active() == self.AS_SPOUSE:
|
||||
# "Add as a Spouse"
|
||||
added = False
|
||||
family = None
|
||||
for family_handle in current_person.get_family_handle_list():
|
||||
family = self.dbstate.db.get_family_from_handle(family_handle)
|
||||
if family:
|
||||
fam_husband_handle = family.get_father_handle()
|
||||
fam_wife_handle = family.get_mother_handle()
|
||||
if current_person.get_handle() == fam_husband_handle:
|
||||
# can we add person as wife?
|
||||
if fam_wife_handle == None:
|
||||
if person.get_gender() == gen.lib.Person.FEMALE:
|
||||
# add the person
|
||||
family.set_mother_handle(person.get_handle())
|
||||
family.set_relationship(gen.lib.FamilyRelType.MARRIED)
|
||||
person.add_family_handle(family.get_handle())
|
||||
added = True
|
||||
break
|
||||
elif person.get_gender() == gen.lib.Person.UNKNOWN:
|
||||
family.set_mother_handle(person.get_handle())
|
||||
family.set_relationship(gen.lib.FamilyRelType.MARRIED)
|
||||
person.set_gender(gen.lib.Person.FEMALE)
|
||||
self.de_widgets["NPGender"].set_active(gen.lib.Person.FEMALE)
|
||||
person.add_family_handle(family.get_handle())
|
||||
added = True
|
||||
break
|
||||
elif current_person.get_handle() == fam_wife_handle:
|
||||
# can we add person as husband?
|
||||
if fam_husband_handle == None:
|
||||
if person.get_gender() == gen.lib.Person.MALE:
|
||||
# add the person
|
||||
family.set_father_handle(person.get_handle())
|
||||
family.set_relationship(gen.lib.FamilyRelType.MARRIED)
|
||||
person.add_family_handle(family.get_handle())
|
||||
added = True
|
||||
break
|
||||
elif person.get_gender() == gen.lib.Person.UNKNOWN:
|
||||
family.set_father_handle(person.get_handle())
|
||||
family.set_relationship(gen.lib.FamilyRelType.MARRIED)
|
||||
person.add_family_handle(family.get_handle())
|
||||
person.set_gender(gen.lib.Person.MALE)
|
||||
self.de_widgets["NPGender"].set_active(gen.lib.Person.MALE)
|
||||
added = True
|
||||
break
|
||||
if added:
|
||||
self.dbstate.db.commit_family(family, self.trans)
|
||||
else:
|
||||
if person.get_gender() == gen.lib.Person.UNKNOWN:
|
||||
if current_person.get_gender() == gen.lib.Person.UNKNOWN:
|
||||
ErrorDialog(_("Please set gender on Active or new person."),
|
||||
_("Can't add new person as a spouse."))
|
||||
return
|
||||
elif current_person.get_gender() == gen.lib.Person.MALE:
|
||||
family = gen.lib.Family()
|
||||
self.dbstate.db.add_family(family, self.trans)
|
||||
family.set_father_handle(current_person.get_handle())
|
||||
family.set_mother_handle(person.get_handle())
|
||||
family.set_relationship(gen.lib.FamilyRelType.MARRIED)
|
||||
person.set_gender(gen.lib.Person.FEMALE)
|
||||
self.de_widgets["NPGender"].set_active(gen.lib.Person.FEMALE)
|
||||
person.add_family_handle(family.get_handle())
|
||||
current_person.add_family_handle(family.get_handle())
|
||||
self.dbstate.db.commit_family(family, self.trans)
|
||||
elif current_person.get_gender() == gen.lib.Person.FEMALE:
|
||||
family = gen.lib.Family()
|
||||
self.dbstate.db.add_family(family, self.trans)
|
||||
family.set_father_handle(person.get_handle())
|
||||
family.set_mother_handle(current_person.get_handle())
|
||||
family.set_relationship(gen.lib.FamilyRelType.MARRIED)
|
||||
person.set_gender(gen.lib.Person.MALE)
|
||||
self.de_widgets["NPGender"].set_active(gen.lib.Person.MALE)
|
||||
person.add_family_handle(family.get_handle())
|
||||
current_person.add_family_handle(family.get_handle())
|
||||
self.dbstate.db.commit_family(family, self.trans)
|
||||
elif person.get_gender() == gen.lib.Person.MALE:
|
||||
if current_person.get_gender() == gen.lib.Person.UNKNOWN:
|
||||
family = gen.lib.Family()
|
||||
self.dbstate.db.add_family(family, self.trans)
|
||||
family.set_father_handle(person.get_handle())
|
||||
family.set_mother_handle(current_person.get_handle())
|
||||
family.set_relationship(gen.lib.FamilyRelType.MARRIED)
|
||||
current_person.set_gender(gen.lib.Person.FEMALE)
|
||||
person.add_family_handle(family.get_handle())
|
||||
current_person.add_family_handle(family.get_handle())
|
||||
self.dbstate.db.commit_family(family, self.trans)
|
||||
elif current_person.get_gender() == gen.lib.Person.MALE:
|
||||
ErrorDialog(_("Same genders on Active and new person."),
|
||||
_("Can't add new person as a spouse."))
|
||||
return
|
||||
elif current_person.get_gender() == gen.lib.Person.FEMALE:
|
||||
family = gen.lib.Family()
|
||||
self.dbstate.db.add_family(family, self.trans)
|
||||
family.set_father_handle(person.get_handle())
|
||||
family.set_mother_handle(current_person.get_handle())
|
||||
family.set_relationship(gen.lib.FamilyRelType.MARRIED)
|
||||
person.add_family_handle(family.get_handle())
|
||||
current_person.add_family_handle(family.get_handle())
|
||||
self.dbstate.db.commit_family(family, self.trans)
|
||||
elif person.get_gender() == gen.lib.Person.FEMALE:
|
||||
if current_person.get_gender() == gen.lib.Person.UNKNOWN:
|
||||
family = gen.lib.Family()
|
||||
self.dbstate.db.add_family(family, self.trans)
|
||||
family.set_father_handle(current_person.get_handle())
|
||||
family.set_mother_handle(person.get_handle())
|
||||
family.set_relationship(gen.lib.FamilyRelType.MARRIED)
|
||||
current_person.set_gender(gen.lib.Person.MALE)
|
||||
person.add_family_handle(family.get_handle())
|
||||
current_person.add_family_handle(family.get_handle())
|
||||
self.dbstate.db.commit_family(family, self.trans)
|
||||
elif current_person.get_gender() == gen.lib.Person.MALE:
|
||||
family = gen.lib.Family()
|
||||
self.dbstate.db.add_family(family, self.trans)
|
||||
family.set_father_handle(current_person.get_handle())
|
||||
family.set_mother_handle(person.get_handle())
|
||||
family.set_relationship(gen.lib.FamilyRelType.MARRIED)
|
||||
person.add_family_handle(family.get_handle())
|
||||
current_person.add_family_handle(family.get_handle())
|
||||
self.dbstate.db.commit_family(family, self.trans)
|
||||
elif current_person.get_gender() == gen.lib.Person.FEMALE:
|
||||
ErrorDialog(_("Same genders on Active and new person."),
|
||||
_("Can't add new person as a spouse."))
|
||||
return
|
||||
elif self.de_widgets["NPRelation"].get_active() == self.AS_SIBLING:
|
||||
# "Add as a Sibling"
|
||||
added = False
|
||||
for family_handle in current_person.get_parent_family_handle_list():
|
||||
family = self.dbstate.db.get_family_from_handle(family_handle)
|
||||
if family:
|
||||
childref = gen.lib.ChildRef()
|
||||
childref.set_reference_handle(person.get_handle())
|
||||
family.add_child_ref( childref)
|
||||
person.add_parent_family_handle(family.get_handle())
|
||||
added = True
|
||||
break
|
||||
if added:
|
||||
self.dbstate.db.commit_family(family, self.trans)
|
||||
else:
|
||||
family = gen.lib.Family()
|
||||
self.dbstate.db.add_family(family, self.trans)
|
||||
childref = gen.lib.ChildRef()
|
||||
childref.set_reference_handle(person.get_handle())
|
||||
family.add_child_ref( childref)
|
||||
childref = gen.lib.ChildRef()
|
||||
childref.set_reference_handle(current_person.get_handle())
|
||||
family.add_child_ref( childref)
|
||||
person.add_parent_family_handle(family.get_handle())
|
||||
current_person.add_parent_family_handle(family.get_handle())
|
||||
self.dbstate.db.commit_family(family, self.trans)
|
||||
elif self.de_widgets["NPRelation"].get_active() == self.AS_CHILD:
|
||||
# "Add as a Child"
|
||||
added = False
|
||||
family = None
|
||||
for family_handle in current_person.get_family_handle_list():
|
||||
family = self.dbstate.db.get_family_from_handle(family_handle)
|
||||
if family:
|
||||
childref = gen.lib.ChildRef()
|
||||
childref.set_reference_handle(person.get_handle())
|
||||
family.add_child_ref( childref)
|
||||
person.add_parent_family_handle(family.get_handle())
|
||||
added = True
|
||||
break
|
||||
if added:
|
||||
self.dbstate.db.commit_family(family, self.trans)
|
||||
else:
|
||||
if current_person.get_gender() == gen.lib.Person.UNKNOWN:
|
||||
ErrorDialog(_("Please set gender on Active person."),
|
||||
_("Can't add new person as a child."))
|
||||
return
|
||||
else:
|
||||
family = gen.lib.Family()
|
||||
self.dbstate.db.add_family(family, self.trans)
|
||||
childref = gen.lib.ChildRef()
|
||||
childref.set_reference_handle(person.get_handle())
|
||||
family.add_child_ref( childref)
|
||||
person.add_parent_family_handle(family.get_handle())
|
||||
current_person.add_family_handle(family.get_handle())
|
||||
if gen.lib.Person.FEMALE:
|
||||
family.set_mother_handle(current_person.get_handle())
|
||||
else:
|
||||
family.set_father_handle(current_person.get_handle())
|
||||
self.dbstate.db.commit_family(family, self.trans)
|
||||
# Commit changes -------------------------------------------------
|
||||
if current_person:
|
||||
self.dbstate.db.commit_person(current_person, self.trans)
|
||||
if person:
|
||||
self.dbstate.db.commit_person(person, self.trans)
|
||||
self.dbstate.db.transaction_commit(self.trans,
|
||||
(_("Gramplet Data Entry: %s") % name_displayer.display(person)))
|
||||
|
||||
def copy_data_entry(self, obj):
|
||||
self.de_widgets["NPName"].set_text(self.de_widgets["APName"].get_text())
|
||||
self.de_widgets["NPBirth"].set_text(self.de_widgets["APBirth"].get_text())
|
||||
self.de_widgets["NPDeath"].set_text(self.de_widgets["APDeath"].get_text())
|
||||
self.de_widgets["NPGender"].set_active(self.de_widgets["APGender"].get_active())
|
||||
# FIXME: put cursor in add surname
|
||||
|
||||
def clear_data_edit(self, obj):
|
||||
self.de_widgets["Active person"].set_text("")
|
||||
self.de_widgets["APName"].set_text("")
|
||||
self.de_widgets["APBirth"].set_text("")
|
||||
self.de_widgets["APDeath"].set_text("")
|
||||
self.de_widgets["APGender"].set_active(gen.lib.Person.UNKNOWN)
|
||||
|
||||
def clear_data_entry(self, obj):
|
||||
self.de_widgets["NPName"].set_text("")
|
||||
self.de_widgets["NPBirth"].set_text("")
|
||||
self.de_widgets["NPDeath"].set_text("")
|
||||
self.de_widgets["NPRelation"].set_active(self.NO_REL)
|
||||
self.de_widgets["NPGender"].set_active(gen.lib.Person.UNKNOWN)
|
||||
|
||||
def db_changed(self):
|
||||
"""
|
||||
If person or family changes, the relatives of active person might have
|
||||
changed
|
||||
"""
|
||||
self.dbstate.db.connect('person-add', self.update)
|
||||
self.dbstate.db.connect('person-delete', self.update)
|
||||
self.dbstate.db.connect('person-edit', self.update)
|
||||
self.dbstate.db.connect('family-add', self.update)
|
||||
self.dbstate.db.connect('family-delete', self.update)
|
||||
self.dbstate.db.connect('person-rebuild', self.update)
|
||||
self.dbstate.db.connect('family-rebuild', self.update)
|
||||
self.dirty = False
|
||||
self.dirty_person = None
|
||||
self.clear_data_entry(None)
|
||||
|
||||
def active_changed(self, handle):
|
||||
self.update()
|
||||
|
||||
#------------------------------------------------------------------------
|
||||
#
|
||||
# Register Gramplet
|
||||
#
|
||||
#------------------------------------------------------------------------
|
||||
register(type="gramplet",
|
||||
name="Data Entry Gramplet",
|
||||
tname=_("Data Entry Gramplet"),
|
||||
height=375,
|
||||
expand=False,
|
||||
content = DataEntryGramplet,
|
||||
title=_("Data Entry"),
|
||||
detached_width = 510,
|
||||
detached_height = 480,
|
||||
)
|
||||
|
||||
@ -1,184 +0,0 @@
|
||||
# encoding: utf-8
|
||||
#
|
||||
# Gramps - a GTK+/GNOME based genealogy program - What Next Gramplet plugin
|
||||
#
|
||||
# Copyright (C) 2009 Doug Blank <doug.blank@gmail.com>
|
||||
#
|
||||
# This program is free software; you can redistribute it and/or modify
|
||||
# it under the terms of the GNU General Public License as published by
|
||||
# the Free Software Foundation; either version 2 of the License, or
|
||||
# (at your option) any later version.
|
||||
#
|
||||
# This program is distributed in the hope that it will be useful,
|
||||
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
# GNU General Public License for more details.
|
||||
#
|
||||
# You should have received a copy of the GNU General Public License
|
||||
# along with this program; if not, write to the Free Software
|
||||
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
#
|
||||
|
||||
# $Id$
|
||||
|
||||
#------------------------------------------------------------------------
|
||||
#
|
||||
# Python modules
|
||||
#
|
||||
#------------------------------------------------------------------------
|
||||
import gtk
|
||||
|
||||
#------------------------------------------------------------------------
|
||||
#
|
||||
# GRAMPS modules
|
||||
#
|
||||
#------------------------------------------------------------------------
|
||||
from gen.lib import EventType, FamilyRelType
|
||||
from BasicUtils import name_displayer
|
||||
from DataViews import register, Gramplet
|
||||
from TransUtils import sgettext as _
|
||||
|
||||
#------------------------------------------------------------------------
|
||||
#
|
||||
# The Gramplet
|
||||
#
|
||||
#------------------------------------------------------------------------
|
||||
class DeepConnectionsGramplet(Gramplet):
|
||||
"""
|
||||
Finds deep connections people the home person and the active person.
|
||||
"""
|
||||
def init(self):
|
||||
self.set_tooltip(_("Double-click name for details"))
|
||||
self.set_text(_("No Family Tree loaded."))
|
||||
self.set_use_markup(True)
|
||||
self.gui.get_container_widget().remove(self.gui.textview)
|
||||
vbox = gtk.VBox()
|
||||
hbox = gtk.HBox()
|
||||
pause_button = gtk.Button(_("Pause"))
|
||||
pause_button.connect("clicked", self.interrupt)
|
||||
continue_button = gtk.Button(_("Continue"))
|
||||
continue_button.connect("clicked", self.resume)
|
||||
hbox.pack_start(pause_button, True)
|
||||
hbox.pack_start(continue_button, True)
|
||||
vbox.pack_start(self.gui.textview, True)
|
||||
vbox.pack_start(hbox, False)
|
||||
self.gui.get_container_widget().add_with_viewport(vbox)
|
||||
vbox.show_all()
|
||||
|
||||
def get_relatives(self, person_handle, path):
|
||||
"""
|
||||
Gets all of the direct relatives of person_handle.
|
||||
"""
|
||||
retval = []
|
||||
person = self.dbstate.db.get_person_from_handle(person_handle)
|
||||
if person is None: return []
|
||||
family_list = person.get_family_handle_list()
|
||||
for family_handle in family_list:
|
||||
family = self.dbstate.db.get_family_from_handle(family_handle)
|
||||
children = family.get_child_ref_list()
|
||||
for child_ref in children:
|
||||
retval += [(child_ref.ref, (path, (_("child"), person_handle)))]
|
||||
husband = family.get_father_handle()
|
||||
if husband:
|
||||
retval += [(husband, (path, (_("husband"), person_handle)))]
|
||||
wife = family.get_mother_handle()
|
||||
if wife:
|
||||
retval += [(wife, (path, (_("wife"), person_handle)))]
|
||||
parent_family_list = person.get_parent_family_handle_list()
|
||||
for family_handle in parent_family_list:
|
||||
family = self.dbstate.db.get_family_from_handle(family_handle)
|
||||
children = family.get_child_ref_list()
|
||||
for child_ref in children:
|
||||
retval += [(child_ref.ref, (path, (_("sibling"), person_handle)))]
|
||||
husband = family.get_father_handle()
|
||||
if husband:
|
||||
retval += [(husband, (path, (_("father"), person_handle)))]
|
||||
wife = family.get_mother_handle()
|
||||
if wife:
|
||||
retval += [(wife, (path, (_("mother"), person_handle)))]
|
||||
return retval
|
||||
|
||||
def active_changed(self, handle):
|
||||
"""
|
||||
Update the gramplet on active person change.
|
||||
"""
|
||||
self.update()
|
||||
|
||||
def pretty_print(self, path):
|
||||
"""
|
||||
Print a path to a person, with links.
|
||||
"""
|
||||
more_path, relation = path
|
||||
text, handle = relation
|
||||
person = self.dbstate.db.get_person_from_handle(handle)
|
||||
name = person.get_primary_name()
|
||||
if text != "self":
|
||||
self.append_text(_("\n who is a %s of ") % text)
|
||||
self.link(name_displayer.display_name(name), "Person", handle)
|
||||
if more_path is not None:
|
||||
self.pretty_print(more_path)
|
||||
|
||||
def main(self):
|
||||
"""
|
||||
Main method.
|
||||
"""
|
||||
self.total_relations_found = 0
|
||||
yield True
|
||||
default_person = self.dbstate.db.get_default_person()
|
||||
active_person = self.dbstate.get_active_person()
|
||||
if default_person == None:
|
||||
self.set_text(_("No Home Person set."))
|
||||
return
|
||||
if active_person == None:
|
||||
self.set_text(_("No Active Person set."))
|
||||
return
|
||||
self.cache = {}
|
||||
self.queue = [(default_person.handle, (None, (_("self"), default_person.handle)))]
|
||||
default_name = default_person.get_primary_name()
|
||||
active_name = active_person.get_primary_name()
|
||||
self.set_text("")
|
||||
self.render_text(_("Looking for relationship between\n" +
|
||||
" <b>%s</b> (Home Person) and\n" +
|
||||
" <b>%s</b> (Active Person)...\n") %
|
||||
(name_displayer.display_name(default_name),
|
||||
name_displayer.display_name(active_name)))
|
||||
yield True
|
||||
while self.queue:
|
||||
current_handle, current_path = self.queue.pop(0)
|
||||
if current_handle == active_person.handle:
|
||||
self.total_relations_found += 1
|
||||
self.append_text(_("Found relation #%d: \n ") % self.total_relations_found)
|
||||
|
||||
self.link(name_displayer.display_name(active_name), "Person", active_person.handle)
|
||||
self.pretty_print(current_path)
|
||||
self.append_text("\n")
|
||||
if default_person.handle != active_person.handle:
|
||||
self.append_text(_("Paused.\nPress Continue to search for additional relations.\n"))
|
||||
self.pause()
|
||||
yield False
|
||||
else:
|
||||
break
|
||||
elif current_handle in self.cache:
|
||||
continue
|
||||
self.cache[current_handle] = 1
|
||||
relatives = self.get_relatives(current_handle, current_path)
|
||||
for (person_handle, path) in relatives:
|
||||
if person_handle is not None and person_handle not in self.cache:
|
||||
self.queue.append( (person_handle, path))
|
||||
yield True
|
||||
self.append_text(_("\nSearch completed. %d relations found.") % self.total_relations_found)
|
||||
yield False
|
||||
|
||||
#------------------------------------------------------------------------
|
||||
#
|
||||
# Register the gramplet
|
||||
#
|
||||
#------------------------------------------------------------------------
|
||||
register(
|
||||
type = "gramplet",
|
||||
name = "Deep Connections Gramplet",
|
||||
tname =_("Deep Connections Gramplet"),
|
||||
height = 230,
|
||||
expand = True,
|
||||
content = DeepConnectionsGramplet,
|
||||
title = _("Deep Connections"))
|
||||
File diff suppressed because it is too large
Load Diff
49
src/plugins/gramplet/FaqGramplet.py
Normal file
49
src/plugins/gramplet/FaqGramplet.py
Normal file
@ -0,0 +1,49 @@
|
||||
# Gramps - a GTK+/GNOME based genealogy program
|
||||
#
|
||||
# Copyright (C) 2007-2009 Douglas S. Blank <doug.blank@gmail.com>
|
||||
#
|
||||
# This program is free software; you can redistribute it and/or modify
|
||||
# it under the terms of the GNU General Public License as published by
|
||||
# the Free Software Foundation; either version 2 of the License, or
|
||||
# (at your option) any later version.
|
||||
#
|
||||
# This program is distributed in the hope that it will be useful,
|
||||
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
# GNU General Public License for more details.
|
||||
#
|
||||
# You should have received a copy of the GNU General Public License
|
||||
# along with this program; if not, write to the Free Software
|
||||
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
|
||||
# $Id$
|
||||
|
||||
#------------------------------------------------------------------------
|
||||
#
|
||||
# GRAMPS modules
|
||||
#
|
||||
#------------------------------------------------------------------------
|
||||
from DataViews import register, Gramplet
|
||||
from TransUtils import sgettext as _
|
||||
|
||||
#------------------------------------------------------------------------
|
||||
#
|
||||
# Register Gramplet
|
||||
#
|
||||
#------------------------------------------------------------------------
|
||||
class FAQGramplet(Gramplet):
|
||||
def init(self):
|
||||
self.set_use_markup(True)
|
||||
self.clear_text()
|
||||
self.render_text("Draft of a <a wiki='FAQ'>Frequently Asked Questions</a> Gramplet\n\n")
|
||||
self.render_text(" 1. <a href='http://bugs.gramps-project.org/'>Test 1</a>\n")
|
||||
self.render_text(" 2. <a href='http://gramps-project.org//'>Test 2</a>\n")
|
||||
|
||||
register(type="gramplet",
|
||||
name="FAQ Gramplet",
|
||||
tname=_("FAQ Gramplet"),
|
||||
height=300,
|
||||
content = FAQGramplet,
|
||||
title=_("FAQ"),
|
||||
)
|
||||
|
||||
198
src/plugins/gramplet/HeadlineNewsGramplet.py
Normal file
198
src/plugins/gramplet/HeadlineNewsGramplet.py
Normal file
@ -0,0 +1,198 @@
|
||||
# Gramps - a GTK+/GNOME based genealogy program
|
||||
#
|
||||
# Copyright (C) 2007-2009 Douglas S. Blank <doug.blank@gmail.com>
|
||||
#
|
||||
# This program is free software; you can redistribute it and/or modify
|
||||
# it under the terms of the GNU General Public License as published by
|
||||
# the Free Software Foundation; either version 2 of the License, or
|
||||
# (at your option) any later version.
|
||||
#
|
||||
# This program is distributed in the hope that it will be useful,
|
||||
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
# GNU General Public License for more details.
|
||||
#
|
||||
# You should have received a copy of the GNU General Public License
|
||||
# along with this program; if not, write to the Free Software
|
||||
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
|
||||
# $Id$
|
||||
|
||||
#------------------------------------------------------------------------
|
||||
#
|
||||
# Python modules
|
||||
#
|
||||
#------------------------------------------------------------------------
|
||||
import re
|
||||
import gobject
|
||||
import urllib
|
||||
import sys
|
||||
|
||||
#------------------------------------------------------------------------
|
||||
#
|
||||
# GRAMPS modules
|
||||
#
|
||||
#------------------------------------------------------------------------
|
||||
from DataViews import register, Gramplet
|
||||
from const import URL_WIKISTRING
|
||||
from TransUtils import sgettext as _
|
||||
|
||||
#------------------------------------------------------------------------
|
||||
#
|
||||
# Gramplet class
|
||||
#
|
||||
#------------------------------------------------------------------------
|
||||
class HeadlineNewsGramplet(Gramplet):
|
||||
"""
|
||||
Headlines News Gramplet reads the Headline News every hour.
|
||||
"""
|
||||
RAW = URL_WIKISTRING + "%s&action=raw"
|
||||
URL = URL_WIKISTRING + "%s"
|
||||
|
||||
def init(self):
|
||||
"""
|
||||
Initialize gramplet. Start up update timer.
|
||||
"""
|
||||
self.set_tooltip(_("Read headline news from the GRAMPS wiki"))
|
||||
self.update_interval = 3600 * 1000 # in miliseconds (1 hour)
|
||||
self.timer = gobject.timeout_add(self.update_interval,
|
||||
self.update_by_timer)
|
||||
|
||||
def update_by_timer(self):
|
||||
"""
|
||||
Update, and return True to continually update on interval.
|
||||
"""
|
||||
self.update()
|
||||
return True # keep updating!
|
||||
|
||||
def main(self):
|
||||
continuation = self.process('HeadlineNews')
|
||||
retval = True
|
||||
while retval:
|
||||
retval, text = continuation.next()
|
||||
self.set_text(text)
|
||||
yield True
|
||||
self.cleanup(text)
|
||||
yield False
|
||||
|
||||
def cleanup(self, text):
|
||||
# final text
|
||||
text = text.replace("<BR>", "\n")
|
||||
while "\n\n\n" in text:
|
||||
text = text.replace("\n\n\n", "\n\n")
|
||||
text = text.strip()
|
||||
## Wiki text:
|
||||
### Internal wiki URL with title:
|
||||
pattern = re.compile('\[\[(.*?)\|(.*?)\]\]')
|
||||
matches = pattern.findall(text)
|
||||
for (g1, g2) in matches:
|
||||
text = text.replace("[[%s|%s]]" % (g1, g2),
|
||||
("""<A HREF="%s">%s</A>""" %
|
||||
(self.wiki(g1), self.nice_title(g2))))
|
||||
### Internal wiki URL:
|
||||
pattern = re.compile('\[\[(.*?)\]\]')
|
||||
matches = pattern.findall(text)
|
||||
for match in matches:
|
||||
text = text.replace("[[%s]]" % match,
|
||||
("""<A HREF="%s">%s</A>""" %
|
||||
(self.wiki(match), self.nice_title(match))))
|
||||
### URL with title:
|
||||
pattern = re.compile('\[http\:\/\/(.*?) (.*?)\]')
|
||||
matches = pattern.findall(text)
|
||||
for (g1, g2) in matches:
|
||||
text = text.replace("[http://%s %s]" % (g1, g2),
|
||||
("""<A HREF="http://%s">%s</A>""" %
|
||||
(g1, g2)))
|
||||
### URL:
|
||||
pattern = re.compile('\[http\:\/\/(.*?)\]')
|
||||
matches = pattern.findall(text)
|
||||
count = 1
|
||||
for g1 in matches:
|
||||
text = text.replace("[http://%s]" % (g1),
|
||||
("""<A HREF="http://%s">%s</A>""" %
|
||||
(g1, ("[%d]" % count))))
|
||||
count += 1
|
||||
### Bold:
|
||||
pattern = re.compile("'''(.*?)'''")
|
||||
matches = pattern.findall(text)
|
||||
for match in matches:
|
||||
text = text.replace("'''%s'''" % match, "<B>%s</B>" % match)
|
||||
text = """<I>Live update from <A HREF="http://gramps-project.org/">www.gramps-project.org</A></I>:\n\n""" + text
|
||||
self.clear_text()
|
||||
self.set_use_markup(True)
|
||||
try:
|
||||
self.render_text(text)
|
||||
except:
|
||||
cla, exc, trbk = sys.exc_info()
|
||||
self.append_text(_("Error") + (" : %s %s\n\n" %(cla, exc)))
|
||||
self.append_text(text)
|
||||
self.append_text("", scroll_to="begin")
|
||||
|
||||
def wiki(self, title):
|
||||
return (self.URL % title)
|
||||
|
||||
def nice_title(self, title):
|
||||
return title.replace("_", " ")
|
||||
|
||||
def process(self, title):
|
||||
#print "processing '%s'..." % title
|
||||
title = self.nice_title(title)
|
||||
yield True, (_("Reading") + " '%s'..." % title)
|
||||
fp = urllib.urlopen(self.RAW % title)
|
||||
text = fp.read()
|
||||
#text = text.replace("\n", " ")
|
||||
html = re.findall('<.*?>', text)
|
||||
for exp in html:
|
||||
text = text.replace(exp, "")
|
||||
text = text.replace("\n", "<BR>")
|
||||
fp.close()
|
||||
pattern = '{{.*?}}'
|
||||
matches = re.findall(pattern, text)
|
||||
#print " before:", text
|
||||
for match in matches:
|
||||
page = match[2:-2]
|
||||
oldtext = match
|
||||
if "|" in page:
|
||||
template, heading, body = page.split("|", 2)
|
||||
if template.lower() == "release":
|
||||
newtext = "GRAMPS " + heading + " released.<BR><BR>"
|
||||
else:
|
||||
newtext = "<B>%s</B><BR><BR>" % heading
|
||||
newtext += body + "<BR>"
|
||||
text = text.replace(oldtext, newtext)
|
||||
else: # a macro/redirect
|
||||
continuation = self.process("Template:" + page)
|
||||
retval = True
|
||||
while retval:
|
||||
retval, newtext = continuation.next()
|
||||
yield True, newtext
|
||||
text = text.replace(oldtext, newtext)
|
||||
#print " after:", text
|
||||
pattern = '#REDIRECT \[\[.*?\]\]'
|
||||
matches = re.findall(pattern, text)
|
||||
#print " before:", text
|
||||
for match in matches:
|
||||
page = match[12:-2]
|
||||
oldtext = match
|
||||
continuation = self.process(page)
|
||||
retval = True
|
||||
while retval:
|
||||
retval, newtext = continuation.next()
|
||||
yield True, newtext
|
||||
text = text.replace(oldtext, newtext)
|
||||
#print " after:", text
|
||||
yield False, text
|
||||
|
||||
#------------------------------------------------------------------------
|
||||
#
|
||||
# Register Gramplet
|
||||
#
|
||||
#------------------------------------------------------------------------
|
||||
register(type="gramplet",
|
||||
name="Headline News Gramplet",
|
||||
tname=_("Headline News Gramplet"),
|
||||
height=300,
|
||||
expand=True,
|
||||
content = HeadlineNewsGramplet,
|
||||
title=_("Headline News"),
|
||||
)
|
||||
@ -6,12 +6,27 @@
|
||||
pkgdatadir = $(datadir)/@PACKAGE@/plugins/gramplet
|
||||
|
||||
pkgdata_PYTHON = \
|
||||
AgeOnDateGramplet.py \
|
||||
AgeStats.py \
|
||||
AttributesGramplet.py \
|
||||
DefaultGramplets.py \
|
||||
CalendarGramplet.py \
|
||||
DataEntryGramplet.py \
|
||||
DescendGramplet.py \
|
||||
FanChartGramplet.py \
|
||||
FaqGramplet.py \
|
||||
GivenNameGramplet.py \
|
||||
HeadlineNewsGramplet.py \
|
||||
NoteGramplet.py \
|
||||
PedigreeGramplet.py \
|
||||
PythonGramplet.py \
|
||||
QuickViewGramplet.py \
|
||||
RelativeGramplet.py \
|
||||
SessionLogGramplet.py \
|
||||
StatsGramplet.py \
|
||||
SurnameCloudGramplet.py \
|
||||
ToDoGramplet.py \
|
||||
TopSurnamesGramplet.py \
|
||||
WelcomeGramplet.py \
|
||||
WhatsNext.py
|
||||
|
||||
pkgpyexecdir = @pkgpyexecdir@/plugins/gramplet
|
||||
|
||||
279
src/plugins/gramplet/PedigreeGramplet.py
Normal file
279
src/plugins/gramplet/PedigreeGramplet.py
Normal file
@ -0,0 +1,279 @@
|
||||
# Gramps - a GTK+/GNOME based genealogy program
|
||||
#
|
||||
# Copyright (C) 2007-2009 Douglas S. Blank <doug.blank@gmail.com>
|
||||
#
|
||||
# This program is free software; you can redistribute it and/or modify
|
||||
# it under the terms of the GNU General Public License as published by
|
||||
# the Free Software Foundation; either version 2 of the License, or
|
||||
# (at your option) any later version.
|
||||
#
|
||||
# This program is distributed in the hope that it will be useful,
|
||||
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
# GNU General Public License for more details.
|
||||
#
|
||||
# You should have received a copy of the GNU General Public License
|
||||
# along with this program; if not, write to the Free Software
|
||||
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
|
||||
# $Id$
|
||||
|
||||
#------------------------------------------------------------------------
|
||||
#
|
||||
# Python modules
|
||||
#
|
||||
#------------------------------------------------------------------------
|
||||
import cgi
|
||||
|
||||
#------------------------------------------------------------------------
|
||||
#
|
||||
# GRAMPS modules
|
||||
#
|
||||
#------------------------------------------------------------------------
|
||||
from DataViews import register, Gramplet
|
||||
from TransUtils import sgettext as _
|
||||
from BasicUtils import name_displayer
|
||||
from ReportBase import ReportUtils
|
||||
import DateHandler
|
||||
import gen
|
||||
|
||||
#------------------------------------------------------------------------
|
||||
#
|
||||
# Gramplet class
|
||||
#
|
||||
#------------------------------------------------------------------------
|
||||
class PedigreeGramplet(Gramplet):
|
||||
def init(self):
|
||||
self.set_text(_("No Family Tree loaded."))
|
||||
self.set_tooltip(_("Move mouse over links for options"))
|
||||
self.set_use_markup(True)
|
||||
self.max_generations = 100
|
||||
self.show_dates = 1
|
||||
self.box_mode = "UTF"
|
||||
|
||||
def build_options(self):
|
||||
from gen.plug.menu import NumberOption
|
||||
self.add_option(NumberOption(_("Max generations"),
|
||||
self.max_generations, 1, 100))
|
||||
|
||||
def save_options(self):
|
||||
self.max_generations = int(self.get_option(_("Max generations")).get_value())
|
||||
|
||||
def on_load(self):
|
||||
if len(self.gui.data) > 0:
|
||||
self.max_generations = int(self.gui.data[0])
|
||||
if len(self.gui.data) > 1:
|
||||
self.show_dates = int(self.gui.data[1])
|
||||
if len(self.gui.data) > 2:
|
||||
self.box_mode = self.gui.data[2] # ASCII or UTF
|
||||
|
||||
def on_save(self):
|
||||
self.gui.data = [self.max_generations, self.show_dates, self.box_mode]
|
||||
|
||||
def db_changed(self):
|
||||
"""
|
||||
If a person or family changes, the ancestors of active person might have
|
||||
changed.
|
||||
"""
|
||||
self.dbstate.db.connect('person-add', self.update)
|
||||
self.dbstate.db.connect('person-delete', self.update)
|
||||
self.dbstate.db.connect('family-add', self.update)
|
||||
self.dbstate.db.connect('family-delete', self.update)
|
||||
self.dbstate.db.connect('person-rebuild', self.update)
|
||||
self.dbstate.db.connect('family-rebuild', self.update)
|
||||
|
||||
def active_changed(self, handle):
|
||||
self.update()
|
||||
|
||||
def get_boxes(self, generation, what):
|
||||
retval = u""
|
||||
if self.box_mode == "UTF":
|
||||
space = u" "
|
||||
elif self.box_mode == "ASCII":
|
||||
space = u" "
|
||||
space_len = len(space) + 2
|
||||
for i in range(generation+1):
|
||||
if self._boxes[i]:
|
||||
retval += space + u"|"
|
||||
else:
|
||||
retval += space + u" "
|
||||
if retval[-1] == u' ':
|
||||
if what == 'sf':
|
||||
retval = retval[:-space_len] + u"/"
|
||||
elif what == 'sm':
|
||||
retval = retval[:-space_len] + u"\\"
|
||||
elif retval.endswith(u"|" + space + u"|"):
|
||||
retval = retval[:-space_len] + u"+"
|
||||
if self.box_mode == "UTF":
|
||||
retval += u"-"
|
||||
retval = retval.replace(u"\\", u"\u2514")
|
||||
retval = retval.replace(u"-", u"\u2500")
|
||||
retval = retval.replace(u"|", u"\u2502")
|
||||
retval = retval.replace(u"/", u"\u250c")
|
||||
elif self.box_mode == "ASCII":
|
||||
retval += u"--"
|
||||
return retval
|
||||
|
||||
def set_box(self, pos, value):
|
||||
self._boxes[pos] = value
|
||||
|
||||
def process_person(self, handle, generation, what):
|
||||
if generation > self.max_generations:
|
||||
return
|
||||
person = self.dbstate.db.get_person_from_handle(handle)
|
||||
family_list = person.get_parent_family_handle_list()
|
||||
if what == "f":
|
||||
if len(family_list) > 0:
|
||||
family = self.dbstate.db.get_family_from_handle(family_list[0])
|
||||
father = family.get_father_handle()
|
||||
mother = family.get_mother_handle()
|
||||
if father:
|
||||
self.process_person(father, generation + 1, "f")
|
||||
self.set_box(generation, 1)
|
||||
self.process_person(father, generation + 1, "sf")
|
||||
self.process_person(father, generation + 1, "m")
|
||||
elif mother:
|
||||
self.set_box(generation, 1)
|
||||
elif what[0] == "s":
|
||||
boxes = self.get_boxes(generation, what)
|
||||
if what[-1] == 'f':
|
||||
if self.box_mode == "UTF":
|
||||
boxes = boxes.replace("+", u"\u250c")
|
||||
else:
|
||||
boxes = boxes.replace("+", u"/")
|
||||
else:
|
||||
if self.box_mode == "UTF":
|
||||
boxes = boxes.replace("+", u"\u2514")
|
||||
else:
|
||||
boxes = boxes.replace("+", u"\\")
|
||||
self.append_text(boxes)
|
||||
self.link(name_displayer.display_name(person.get_primary_name()),
|
||||
'Person', person.handle,
|
||||
tooltip=_("Click to make active\n") + \
|
||||
_("Right-click to edit"))
|
||||
if self.show_dates:
|
||||
self.append_text(" ")
|
||||
self.render_text(self.info_string(person))
|
||||
self.append_text("\n")
|
||||
if generation not in self._generations:
|
||||
self._generations[generation] = []
|
||||
self._generations[generation].append(handle)
|
||||
elif what == "a":
|
||||
if self.box_mode == "UTF":
|
||||
self.append_text(u"o" + (u"\u2500" * 3))
|
||||
elif self.box_mode == "ASCII":
|
||||
self.append_text(u"o---")
|
||||
self.append_text("%s " % name_displayer.display_name(person.get_primary_name()))
|
||||
if self.show_dates:
|
||||
self.render_text(self.info_string(person))
|
||||
self.append_text("\n")
|
||||
if generation not in self._generations:
|
||||
self._generations[generation] = []
|
||||
self._generations[generation].append(handle)
|
||||
elif what == "m":
|
||||
if len(family_list) > 0:
|
||||
family = self.dbstate.db.get_family_from_handle(family_list[0])
|
||||
mother = family.get_mother_handle()
|
||||
if mother:
|
||||
self.process_person(mother, generation + 1, "f")
|
||||
self.process_person(mother, generation + 1, "sm")
|
||||
self.set_box(generation, 0)
|
||||
self.process_person(mother, generation + 1, "m")
|
||||
self.set_box(generation, 0) # regardless, turn off line if on
|
||||
|
||||
def info_string(self, person):
|
||||
birth = ReportUtils.get_birth_or_fallback(self.dbstate.db, person)
|
||||
if birth and birth.get_type != gen.lib.EventType.BIRTH:
|
||||
sdate = DateHandler.get_date(birth)
|
||||
if sdate:
|
||||
bdate = "<i>%s</i>" % cgi.escape(sdate)
|
||||
else:
|
||||
bdate = ""
|
||||
elif birth:
|
||||
bdate = cgi.escape(DateHandler.get_date(birth))
|
||||
else:
|
||||
bdate = ""
|
||||
|
||||
death = ReportUtils.get_death_or_fallback(self.dbstate.db, person)
|
||||
if death and death.get_type != gen.lib.EventType.DEATH:
|
||||
sdate = DateHandler.get_date(death)
|
||||
if sdate:
|
||||
ddate = "<i>%s</i>" % cgi.escape(sdate)
|
||||
else:
|
||||
ddate = ""
|
||||
elif death:
|
||||
ddate = cgi.escape(DateHandler.get_date(death))
|
||||
else:
|
||||
ddate = ""
|
||||
|
||||
if bdate and ddate:
|
||||
value = _("(b. %(birthdate)s, d. %(deathdate)s)") % {
|
||||
'birthdate' : bdate,
|
||||
'deathdate' : ddate
|
||||
}
|
||||
elif bdate:
|
||||
value = _("(b. %s)") % (bdate)
|
||||
elif ddate:
|
||||
value = _("(d. %s)") % (ddate)
|
||||
else:
|
||||
value = ""
|
||||
return value
|
||||
|
||||
def main(self): # return false finishes
|
||||
"""
|
||||
Generator which will be run in the background.
|
||||
"""
|
||||
self._boxes = [0] * (self.max_generations + 1)
|
||||
self._generations = {}
|
||||
self.gui.buffer.set_text("")
|
||||
active_person = self.dbstate.get_active_person()
|
||||
if not active_person:
|
||||
return False
|
||||
#no wrap in Gramplet
|
||||
self.no_wrap()
|
||||
self.process_person(active_person.handle, 1, "f") # father
|
||||
self.process_person(active_person.handle, 0, "a") # active #FIXME: should be 1?
|
||||
self.process_person(active_person.handle, 1, "m") # mother
|
||||
gens = self._generations.keys()
|
||||
gens.sort()
|
||||
self.append_text(_("\nBreakdown by generation:\n"))
|
||||
all = [active_person.handle]
|
||||
for g in gens:
|
||||
count = len(self._generations[g])
|
||||
handles = self._generations[g]
|
||||
self.append_text(" ")
|
||||
if g == 0:
|
||||
self.link(_("Generation 1"), 'PersonList', handles,
|
||||
tooltip=_("Double-click to see people in generation"))
|
||||
self.append_text(_(" has 1 of 1 individual (100.00% complete)\n"))
|
||||
else:
|
||||
all.extend(handles)
|
||||
self.link(_("Generation %d") % g, 'PersonList', handles,
|
||||
tooltip=_("Double-click to see people in generation"))
|
||||
self.append_text(_(" has %d of %d individuals (%.2f%% complete)\n") %
|
||||
(count, 2**(g-1), float(count)/2**(g-1) * 100))
|
||||
self.link(_("All generations"), 'PersonList', all,
|
||||
tooltip=_("Double-click to see all generations"))
|
||||
self.append_text(_(" have %d individuals\n") % len(all))
|
||||
# Set to a fixed font
|
||||
if self.box_mode == "UTF":
|
||||
start, end = self.gui.buffer.get_bounds()
|
||||
self.gui.buffer.apply_tag_by_name("fixed", start, end)
|
||||
self.append_text("", scroll_to="begin")
|
||||
|
||||
#------------------------------------------------------------------------
|
||||
#
|
||||
# Register Gramplet
|
||||
#
|
||||
#------------------------------------------------------------------------
|
||||
register(type="gramplet",
|
||||
name="Pedigree Gramplet",
|
||||
tname=_("Pedigree Gramplet"),
|
||||
height=300,
|
||||
content = PedigreeGramplet,
|
||||
title=_("Pedigree"),
|
||||
expand=True,
|
||||
detached_width = 600,
|
||||
detached_height = 400,
|
||||
)
|
||||
|
||||
157
src/plugins/gramplet/PythonGramplet.py
Normal file
157
src/plugins/gramplet/PythonGramplet.py
Normal file
@ -0,0 +1,157 @@
|
||||
# Gramps - a GTK+/GNOME based genealogy program
|
||||
#
|
||||
# Copyright (C) 2007-2009 Douglas S. Blank <doug.blank@gmail.com>
|
||||
#
|
||||
# This program is free software; you can redistribute it and/or modify
|
||||
# it under the terms of the GNU General Public License as published by
|
||||
# the Free Software Foundation; either version 2 of the License, or
|
||||
# (at your option) any later version.
|
||||
#
|
||||
# This program is distributed in the hope that it will be useful,
|
||||
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
# GNU General Public License for more details.
|
||||
#
|
||||
# You should have received a copy of the GNU General Public License
|
||||
# along with this program; if not, write to the Free Software
|
||||
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
|
||||
# $Id$
|
||||
|
||||
#------------------------------------------------------------------------
|
||||
#
|
||||
# Python modules
|
||||
#
|
||||
#------------------------------------------------------------------------
|
||||
import sys
|
||||
|
||||
#------------------------------------------------------------------------
|
||||
#
|
||||
# GRAMPS modules
|
||||
#
|
||||
#------------------------------------------------------------------------
|
||||
from DataViews import register, Gramplet
|
||||
from TransUtils import sgettext as _
|
||||
import gen
|
||||
|
||||
#------------------------------------------------------------------------
|
||||
#
|
||||
# Gramplet class
|
||||
#
|
||||
#------------------------------------------------------------------------
|
||||
class PythonGramplet(Gramplet):
|
||||
def init(self):
|
||||
import gc
|
||||
gc.set_debug(gc.DEBUG_UNCOLLECTABLE|gc.DEBUG_OBJECTS|gc.DEBUG_SAVEALL)
|
||||
self.prompt = ">"
|
||||
self.set_tooltip(_("Enter Python expressions"))
|
||||
self.gc = gc
|
||||
self.env = {"dbstate": self.gui.dbstate,
|
||||
"uistate": self.gui.uistate,
|
||||
"gc": self.gc,
|
||||
"self": self,
|
||||
_("class name|Date"): gen.lib.Date,
|
||||
}
|
||||
# GUI setup:
|
||||
self.gui.textview.set_editable(True)
|
||||
self.set_text("Python %s\n%s " % (sys.version, self.prompt))
|
||||
self.gui.textview.connect('key-press-event', self.on_key_press)
|
||||
|
||||
def format_exception(self, max_tb_level=10):
|
||||
retval = ''
|
||||
cla, exc, trbk = sys.exc_info()
|
||||
retval += _("Error") + (" : %s %s" %(cla, exc))
|
||||
return retval
|
||||
|
||||
def process_command(self, command):
|
||||
# update states, in case of change:
|
||||
self.env["dbstate"] = self.gui.dbstate
|
||||
self.env["uistate"] = self.gui.uistate
|
||||
_retval = None
|
||||
if "_retval" in self.env:
|
||||
del self.env["_retval"]
|
||||
exp1 = """_retval = """ + command
|
||||
exp2 = command.strip()
|
||||
try:
|
||||
_retval = eval(exp2, self.env)
|
||||
except:
|
||||
try:
|
||||
exec exp1 in self.env
|
||||
except:
|
||||
try:
|
||||
exec exp2 in self.env
|
||||
except:
|
||||
_retval = self.format_exception()
|
||||
if "_retval" in self.env:
|
||||
_retval = self.env["_retval"]
|
||||
return _retval
|
||||
|
||||
def on_key_press(self, widget, event):
|
||||
import gtk
|
||||
if (event.keyval == gtk.keysyms.Home or
|
||||
((event.keyval == gtk.keysyms.a and
|
||||
event.get_state() & gtk.gdk.CONTROL_MASK))):
|
||||
buffer = widget.get_buffer()
|
||||
cursor_pos = buffer.get_property("cursor-position")
|
||||
iter = buffer.get_iter_at_offset(cursor_pos)
|
||||
line_cnt = iter.get_line()
|
||||
start = buffer.get_iter_at_line(line_cnt)
|
||||
start.forward_chars(2)
|
||||
buffer.place_cursor(start)
|
||||
return True
|
||||
elif (event.keyval == gtk.keysyms.End or
|
||||
(event.keyval == gtk.keysyms.e and
|
||||
event.get_state() & gtk.gdk.CONTROL_MASK)):
|
||||
buffer = widget.get_buffer()
|
||||
end = buffer.get_end_iter()
|
||||
buffer.place_cursor(end)
|
||||
return True
|
||||
elif event.keyval == gtk.keysyms.Return:
|
||||
echo = False
|
||||
buffer = widget.get_buffer()
|
||||
cursor_pos = buffer.get_property("cursor-position")
|
||||
iter = buffer.get_iter_at_offset(cursor_pos)
|
||||
line_cnt = iter.get_line()
|
||||
start = buffer.get_iter_at_line(line_cnt)
|
||||
line_len = iter.get_chars_in_line()
|
||||
buffer_cnt = buffer.get_line_count()
|
||||
if (buffer_cnt - line_cnt) > 1:
|
||||
line_len -= 1
|
||||
echo = True
|
||||
end = buffer.get_iter_at_line_offset(line_cnt, line_len)
|
||||
line = buffer.get_text(start, end)
|
||||
self.append_text("\n")
|
||||
if line.startswith(self.prompt):
|
||||
line = line[1:].strip()
|
||||
else:
|
||||
self.append_text("%s " % self.prompt)
|
||||
end = buffer.get_end_iter()
|
||||
buffer.place_cursor(end)
|
||||
return True
|
||||
if echo:
|
||||
self.append_text(("%s " % self.prompt) + line)
|
||||
end = buffer.get_end_iter()
|
||||
buffer.place_cursor(end)
|
||||
return True
|
||||
_retval = self.process_command(line)
|
||||
if _retval is not None:
|
||||
self.append_text("%s\n" % str(_retval))
|
||||
self.append_text("%s " % self.prompt)
|
||||
end = buffer.get_end_iter()
|
||||
buffer.place_cursor(end)
|
||||
return True
|
||||
return False
|
||||
|
||||
#------------------------------------------------------------------------
|
||||
#
|
||||
# Register Gramplet
|
||||
#
|
||||
#------------------------------------------------------------------------
|
||||
register(type="gramplet",
|
||||
name="Python Gramplet",
|
||||
tname=_("Python Gramplet"),
|
||||
height=250,
|
||||
content = PythonGramplet,
|
||||
title=_("Python Shell"),
|
||||
)
|
||||
|
||||
131
src/plugins/gramplet/QuickViewGramplet.py
Normal file
131
src/plugins/gramplet/QuickViewGramplet.py
Normal file
@ -0,0 +1,131 @@
|
||||
# Gramps - a GTK+/GNOME based genealogy program
|
||||
#
|
||||
# Copyright (C) 2007-2009 Douglas S. Blank <doug.blank@gmail.com>
|
||||
#
|
||||
# This program is free software; you can redistribute it and/or modify
|
||||
# it under the terms of the GNU General Public License as published by
|
||||
# the Free Software Foundation; either version 2 of the License, or
|
||||
# (at your option) any later version.
|
||||
#
|
||||
# This program is distributed in the hope that it will be useful,
|
||||
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
# GNU General Public License for more details.
|
||||
#
|
||||
# You should have received a copy of the GNU General Public License
|
||||
# along with this program; if not, write to the Free Software
|
||||
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
|
||||
# $Id$
|
||||
|
||||
#------------------------------------------------------------------------
|
||||
#
|
||||
# Python modules
|
||||
#
|
||||
#------------------------------------------------------------------------
|
||||
|
||||
|
||||
#------------------------------------------------------------------------
|
||||
#
|
||||
# GRAMPS modules
|
||||
#
|
||||
#------------------------------------------------------------------------
|
||||
from DataViews import register, Gramplet
|
||||
from TransUtils import sgettext as _
|
||||
from QuickReports import run_quick_report_by_name, get_quick_report_list
|
||||
from ReportBase import (CATEGORY_QR_PERSON, CATEGORY_QR_FAMILY,
|
||||
CATEGORY_QR_EVENT, CATEGORY_QR_SOURCE,
|
||||
CATEGORY_QR_MISC, CATEGORY_QR_PLACE,
|
||||
CATEGORY_QR_REPOSITORY)
|
||||
|
||||
#------------------------------------------------------------------------
|
||||
#
|
||||
# Gramplet class
|
||||
#
|
||||
#------------------------------------------------------------------------
|
||||
class QuickViewGramplet(Gramplet):
|
||||
def active_changed(self, handle):
|
||||
self.update()
|
||||
|
||||
def main(self):
|
||||
qv_type = self.get_option(_("View Type"))
|
||||
quick_type = qv_type.get_value()
|
||||
qv_option = self.get_option(_("Quick Views"))
|
||||
quick_view = qv_option.get_value()
|
||||
if quick_type == CATEGORY_QR_PERSON:
|
||||
active = self.dbstate.get_active_person()
|
||||
if active:
|
||||
run_quick_report_by_name(self.gui.dbstate,
|
||||
self.gui.uistate,
|
||||
quick_view,
|
||||
active.handle,
|
||||
container=self.gui.textview)
|
||||
else:
|
||||
active_list = []
|
||||
for item in self.gui.uistate.viewmanager.pages:
|
||||
if (item.get_title() == _("Families") and
|
||||
quick_type == CATEGORY_QR_FAMILY):
|
||||
active_list = item.selected_handles()
|
||||
elif (item.get_title() == _("Events") and
|
||||
quick_type == CATEGORY_QR_EVENT):
|
||||
active_list = item.selected_handles()
|
||||
elif (item.get_title() == _("Sources") and
|
||||
quick_type == CATEGORY_QR_SOURCE):
|
||||
active_list = item.selected_handles()
|
||||
elif (item.get_title() == _("Places") and
|
||||
quick_type == CATEGORY_QR_PLACE):
|
||||
active_list = item.selected_handles()
|
||||
elif (item.get_title() == _("Repositories") and
|
||||
quick_type == CATEGORY_QR_REPOSITORY):
|
||||
active_list = item.selected_handles()
|
||||
if len(active_list) > 0:
|
||||
run_quick_report_by_name(self.gui.dbstate,
|
||||
self.gui.uistate,
|
||||
quick_view,
|
||||
active_list[0],
|
||||
container=self.gui.textview)
|
||||
|
||||
def build_options(self):
|
||||
from gen.plug.menu import EnumeratedListOption
|
||||
# Add types:
|
||||
type_list = EnumeratedListOption(_("View Type"), CATEGORY_QR_PERSON)
|
||||
for item in [(CATEGORY_QR_PERSON, "Person"),
|
||||
#TODO: add these once they have active change signals
|
||||
#(CATEGORY_QR_FAMILY, "Family"),
|
||||
#(CATEGORY_QR_EVENT, "Event"),
|
||||
#(CATEGORY_QR_SOURCE, "Source"),
|
||||
#(CATEGORY_QR_PLACE, "Place"),
|
||||
#(CATEGORY_QR_REPOSITORY, "Repository"),
|
||||
]:
|
||||
type_list.add_item(item[0], item[1])
|
||||
# Add particular lists:
|
||||
qv_list = get_quick_report_list(CATEGORY_QR_PERSON)
|
||||
list_option = EnumeratedListOption(_("Quick Views"), qv_list[0][2])
|
||||
for item in qv_list:
|
||||
#(title, category, name, status)
|
||||
list_option.add_item(item[2], item[0])
|
||||
self.add_option(type_list)
|
||||
self.add_option(list_option)
|
||||
type_widget = self.get_option_widget(_("View Type"))
|
||||
type_widget.value_changed = self.rebuild_option_list
|
||||
|
||||
def rebuild_option_list(self):
|
||||
qv_option = self.get_option(_("View Type"))
|
||||
list_option = self.get_option(_("Quick Views"))
|
||||
list_option.clear()
|
||||
qv_list = get_quick_report_list(qv_option.get_value())
|
||||
for item in qv_list:
|
||||
#(title, category, name, status)
|
||||
list_option.add_item(item[2], item[0])
|
||||
|
||||
register(type="gramplet",
|
||||
name="Quick View Gramplet",
|
||||
tname=_("Quick View Gramplet"),
|
||||
height=300,
|
||||
expand=True,
|
||||
content = QuickViewGramplet,
|
||||
title=_("Quick View"),
|
||||
detached_width = 600,
|
||||
detached_height = 400,
|
||||
)
|
||||
|
||||
150
src/plugins/gramplet/RelativeGramplet.py
Normal file
150
src/plugins/gramplet/RelativeGramplet.py
Normal file
@ -0,0 +1,150 @@
|
||||
# Gramps - a GTK+/GNOME based genealogy program
|
||||
#
|
||||
# Copyright (C) 2007-2009 Douglas S. Blank <doug.blank@gmail.com>
|
||||
#
|
||||
# This program is free software; you can redistribute it and/or modify
|
||||
# it under the terms of the GNU General Public License as published by
|
||||
# the Free Software Foundation; either version 2 of the License, or
|
||||
# (at your option) any later version.
|
||||
#
|
||||
# This program is distributed in the hope that it will be useful,
|
||||
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
# GNU General Public License for more details.
|
||||
#
|
||||
# You should have received a copy of the GNU General Public License
|
||||
# along with this program; if not, write to the Free Software
|
||||
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
|
||||
# $Id$
|
||||
|
||||
#------------------------------------------------------------------------
|
||||
#
|
||||
# GRAMPS modules
|
||||
#
|
||||
#------------------------------------------------------------------------
|
||||
from DataViews import register, Gramplet
|
||||
from TransUtils import sgettext as _
|
||||
from BasicUtils import name_displayer
|
||||
|
||||
#------------------------------------------------------------------------
|
||||
#
|
||||
# Gramplet class
|
||||
#
|
||||
#------------------------------------------------------------------------
|
||||
class RelativesGramplet(Gramplet):
|
||||
"""
|
||||
This gramplet gives a list of clickable relatives of the active person.
|
||||
Clicking them, changes the active person.
|
||||
"""
|
||||
def init(self):
|
||||
self.set_text(_("No Family Tree loaded."))
|
||||
self.set_tooltip(_("Click name to make person active\n") +
|
||||
_("Right-click name to edit person"))
|
||||
|
||||
def db_changed(self):
|
||||
"""
|
||||
If person or family changes, the relatives of active person might have
|
||||
changed
|
||||
"""
|
||||
self.dbstate.db.connect('person-add', self.update)
|
||||
self.dbstate.db.connect('person-delete', self.update)
|
||||
self.dbstate.db.connect('family-add', self.update)
|
||||
self.dbstate.db.connect('family-delete', self.update)
|
||||
self.dbstate.db.connect('person-rebuild', self.update)
|
||||
self.dbstate.db.connect('family-rebuild', self.update)
|
||||
|
||||
def active_changed(self, handle):
|
||||
self.update()
|
||||
|
||||
def main(self): # return false finishes
|
||||
"""
|
||||
Generator which will be run in the background.
|
||||
"""
|
||||
self.set_text("")
|
||||
database = self.dbstate.db
|
||||
active_person = self.dbstate.get_active_person()
|
||||
if not active_person:
|
||||
return
|
||||
name = name_displayer.display(active_person)
|
||||
self.append_text(_("Active person: %s") % name)
|
||||
self.append_text("\n\n")
|
||||
#obtain families
|
||||
famc = 0
|
||||
for family_handle in active_person.get_family_handle_list():
|
||||
famc += 1
|
||||
family = database.get_family_from_handle(family_handle)
|
||||
if not family: continue
|
||||
if active_person.handle == family.get_father_handle():
|
||||
spouse_handle = family.get_mother_handle()
|
||||
else:
|
||||
spouse_handle = family.get_father_handle()
|
||||
if spouse_handle:
|
||||
spouse = database.get_person_from_handle(spouse_handle)
|
||||
spousename = name_displayer.display(spouse)
|
||||
text = "%s" % spousename
|
||||
self.append_text(_("%d. Partner: ") % (famc))
|
||||
self.link(text, 'Person', spouse_handle)
|
||||
self.append_text("\n")
|
||||
else:
|
||||
self.append_text(_("%d. Partner: Not known") % (famc))
|
||||
self.append_text("\n")
|
||||
#obtain children
|
||||
childc = 0
|
||||
for child_ref in family.get_child_ref_list():
|
||||
childc += 1
|
||||
child = database.get_person_from_handle(child_ref.ref)
|
||||
childname = name_displayer.display(child)
|
||||
text = "%s" % childname
|
||||
self.append_text(" %d.%-3d: " % (famc, childc))
|
||||
self.link(text, 'Person', child_ref.ref)
|
||||
self.append_text("\n")
|
||||
yield True
|
||||
#obtain parent families
|
||||
self.append_text("\n")
|
||||
self.append_text(_("Parents:"))
|
||||
self.append_text("\n")
|
||||
famc = 0
|
||||
for family_handle in active_person.get_parent_family_handle_list():
|
||||
famc += 1
|
||||
family = database.get_family_from_handle(family_handle)
|
||||
mother_handle = family.get_mother_handle()
|
||||
father_handle = family.get_father_handle()
|
||||
if mother_handle:
|
||||
mother = database.get_person_from_handle(mother_handle)
|
||||
mothername = name_displayer.display(mother)
|
||||
text = "%s" % mothername
|
||||
self.append_text(_(" %d.a Mother: ") % (famc))
|
||||
self.link(text, 'Person', mother_handle)
|
||||
self.append_text("\n")
|
||||
else:
|
||||
self.append_text(_(" %d.a Mother: ") % (famc))
|
||||
self.append_text(_("Unknown"))
|
||||
self.append_text("\n")
|
||||
if father_handle:
|
||||
father = database.get_person_from_handle(father_handle)
|
||||
fathername = name_displayer.display(father)
|
||||
text = "%s" % fathername
|
||||
self.append_text(_(" %d.b Father: ") % (famc))
|
||||
self.link(text, 'Person', father_handle)
|
||||
self.append_text("\n")
|
||||
else:
|
||||
self.append_text(_(" %d.b Father: ") % (famc))
|
||||
self.append_text(_("Unknown"))
|
||||
self.append_text("\n")
|
||||
|
||||
#------------------------------------------------------------------------
|
||||
#
|
||||
# Register Gramplet
|
||||
#
|
||||
#------------------------------------------------------------------------
|
||||
register(type="gramplet",
|
||||
name="Relatives Gramplet",
|
||||
tname=_("Relatives Gramplet"),
|
||||
height=200,
|
||||
content = RelativesGramplet,
|
||||
title=_("Relatives"),
|
||||
detached_width = 250,
|
||||
detached_height = 300,
|
||||
)
|
||||
|
||||
101
src/plugins/gramplet/SessionLogGramplet.py
Normal file
101
src/plugins/gramplet/SessionLogGramplet.py
Normal file
@ -0,0 +1,101 @@
|
||||
# Gramps - a GTK+/GNOME based genealogy program
|
||||
#
|
||||
# Copyright (C) 2007-2009 Douglas S. Blank <doug.blank@gmail.com>
|
||||
#
|
||||
# This program is free software; you can redistribute it and/or modify
|
||||
# it under the terms of the GNU General Public License as published by
|
||||
# the Free Software Foundation; either version 2 of the License, or
|
||||
# (at your option) any later version.
|
||||
#
|
||||
# This program is distributed in the hope that it will be useful,
|
||||
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
# GNU General Public License for more details.
|
||||
#
|
||||
# You should have received a copy of the GNU General Public License
|
||||
# along with this program; if not, write to the Free Software
|
||||
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
|
||||
# $Id$
|
||||
|
||||
#------------------------------------------------------------------------
|
||||
#
|
||||
# GRAMPS modules
|
||||
#
|
||||
#------------------------------------------------------------------------
|
||||
from DataViews import register, Gramplet
|
||||
from TransUtils import sgettext as _
|
||||
from BasicUtils import name_displayer
|
||||
|
||||
#------------------------------------------------------------------------
|
||||
#
|
||||
# Gramplet class
|
||||
#
|
||||
#------------------------------------------------------------------------
|
||||
class LogGramplet(Gramplet):
|
||||
def init(self):
|
||||
self.set_tooltip(_("Click name to change active\nDouble-click name to edit"))
|
||||
self.set_text(_("Log for this Session"))
|
||||
self.gui.force_update = True # will always update, even if minimized
|
||||
self.last_log = None
|
||||
self.append_text("\n")
|
||||
|
||||
def db_changed(self):
|
||||
self.append_text("Opened data base -----------\n")
|
||||
self.dbstate.db.connect('person-add',
|
||||
lambda handles: self.log(_('Person'), _('Added'), handles))
|
||||
self.dbstate.db.connect('person-delete',
|
||||
lambda handles: self.log(_('Person'), _('Deleted'), handles))
|
||||
self.dbstate.db.connect('person-update',
|
||||
lambda handles: self.log(_('Person'), _('Edited'), handles))
|
||||
self.dbstate.db.connect('family-add',
|
||||
lambda handles: self.log(_('Family'), _('Added'), handles))
|
||||
self.dbstate.db.connect('family-delete',
|
||||
lambda handles: self.log(_('Family'), _('Deleted'), handles))
|
||||
self.dbstate.db.connect('family-update',
|
||||
lambda handles: self.log(_('Family'), _('Added'), handles))
|
||||
|
||||
def active_changed(self, handle):
|
||||
self.log(_('Person'), _('Selected'), [handle])
|
||||
|
||||
def log(self, ltype, action, handles):
|
||||
for handle in set(handles):
|
||||
if self.last_log == (ltype, action, handle):
|
||||
continue
|
||||
self.last_log = (ltype, action, handle)
|
||||
self.append_text("%s: " % action)
|
||||
if ltype == _("Person"):
|
||||
person = self.dbstate.db.get_person_from_handle(handle)
|
||||
name = name_displayer.display(person)
|
||||
elif ltype == _("Family"):
|
||||
family = self.dbstate.db.get_family_from_handle(handle)
|
||||
father_name = _("unknown")
|
||||
mother_name = _("unknown")
|
||||
if family:
|
||||
father_handle = family.get_father_handle()
|
||||
if father_handle:
|
||||
father = self.dbstate.db.get_person_from_handle(father_handle)
|
||||
if father:
|
||||
father_name = name_displayer.display(father)
|
||||
mother_handle = family.get_mother_handle()
|
||||
if mother_handle:
|
||||
mother = self.dbstate.db.get_person_from_handle(mother_handle)
|
||||
mother_name = name_displayer.display(mother)
|
||||
name = _("%s and %s") % (mother_name, father_name)
|
||||
self.link(name, ltype, handle)
|
||||
self.append_text("\n")
|
||||
|
||||
#------------------------------------------------------------------------
|
||||
#
|
||||
# Register Gramplet
|
||||
#
|
||||
#------------------------------------------------------------------------
|
||||
register(type="gramplet",
|
||||
name="Session Log Gramplet",
|
||||
tname=_("Session Log Gramplet"),
|
||||
height=230,
|
||||
data=['no'],
|
||||
content = LogGramplet,
|
||||
title=_("Session Log"),
|
||||
)
|
||||
|
||||
198
src/plugins/gramplet/StatsGramplet.py
Normal file
198
src/plugins/gramplet/StatsGramplet.py
Normal file
@ -0,0 +1,198 @@
|
||||
# Gramps - a GTK+/GNOME based genealogy program
|
||||
#
|
||||
# Copyright (C) 2007-2009 Douglas S. Blank <doug.blank@gmail.com>
|
||||
#
|
||||
# This program is free software; you can redistribute it and/or modify
|
||||
# it under the terms of the GNU General Public License as published by
|
||||
# the Free Software Foundation; either version 2 of the License, or
|
||||
# (at your option) any later version.
|
||||
#
|
||||
# This program is distributed in the hope that it will be useful,
|
||||
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
# GNU General Public License for more details.
|
||||
#
|
||||
# You should have received a copy of the GNU General Public License
|
||||
# along with this program; if not, write to the Free Software
|
||||
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
|
||||
# $Id$
|
||||
|
||||
#------------------------------------------------------------------------
|
||||
#
|
||||
# Python modules
|
||||
#
|
||||
#------------------------------------------------------------------------
|
||||
import posixpath
|
||||
|
||||
#------------------------------------------------------------------------
|
||||
#
|
||||
# GRAMPS modules
|
||||
#
|
||||
#------------------------------------------------------------------------
|
||||
from DataViews import register, Gramplet
|
||||
from TransUtils import sgettext as _
|
||||
from Utils import media_path_full
|
||||
import DateHandler
|
||||
import gen
|
||||
|
||||
#------------------------------------------------------------------------
|
||||
#
|
||||
# Gramplet class
|
||||
#
|
||||
#------------------------------------------------------------------------
|
||||
class StatsGramplet(Gramplet):
|
||||
def init(self):
|
||||
self.set_text(_("No Family Tree loaded."))
|
||||
self.set_tooltip(_("Double-click item to see matches"))
|
||||
|
||||
def db_changed(self):
|
||||
self.dbstate.db.connect('person-add', self.update)
|
||||
self.dbstate.db.connect('person-edit', self.update)
|
||||
self.dbstate.db.connect('person-delete', self.update)
|
||||
self.dbstate.db.connect('family-add', self.update)
|
||||
self.dbstate.db.connect('family-delete', self.update)
|
||||
self.dbstate.db.connect('person-rebuild', self.update)
|
||||
self.dbstate.db.connect('family-rebuild', self.update)
|
||||
|
||||
def main(self):
|
||||
self.set_text(_("Processing..."))
|
||||
database = self.dbstate.db
|
||||
personList = database.get_person_handles(sort_handles=False)
|
||||
familyList = database.get_family_handles()
|
||||
|
||||
with_photos = 0
|
||||
total_photos = 0
|
||||
incomp_names = 0
|
||||
disconnected = 0
|
||||
missing_bday = 0
|
||||
males = 0
|
||||
females = 0
|
||||
unknowns = 0
|
||||
bytes = 0
|
||||
namelist = []
|
||||
notfound = []
|
||||
|
||||
pobjects = len(database.get_media_object_handles())
|
||||
for photo_id in database.get_media_object_handles():
|
||||
photo = database.get_object_from_handle(photo_id)
|
||||
fullname = media_path_full(database, photo.get_path())
|
||||
try:
|
||||
bytes = bytes + posixpath.getsize(fullname)
|
||||
except:
|
||||
notfound.append(photo.get_path())
|
||||
|
||||
cnt = 0
|
||||
for person_handle in personList:
|
||||
person = database.get_person_from_handle(person_handle)
|
||||
if not person:
|
||||
continue
|
||||
length = len(person.get_media_list())
|
||||
if length > 0:
|
||||
with_photos = with_photos + 1
|
||||
total_photos = total_photos + length
|
||||
|
||||
person = database.get_person_from_handle(person_handle)
|
||||
names = [person.get_primary_name()] + person.get_alternate_names()
|
||||
for name in names:
|
||||
if name.get_first_name() == "" or name.get_group_name() == "":
|
||||
incomp_names = incomp_names + 1
|
||||
if name.get_group_name() not in namelist:
|
||||
namelist.append(name.get_group_name())
|
||||
if ((not person.get_main_parents_family_handle()) and
|
||||
(not len(person.get_family_handle_list()))):
|
||||
disconnected = disconnected + 1
|
||||
birth_ref = person.get_birth_ref()
|
||||
if birth_ref:
|
||||
birth = database.get_event_from_handle(birth_ref.ref)
|
||||
if not DateHandler.get_date(birth):
|
||||
missing_bday = missing_bday + 1
|
||||
else:
|
||||
missing_bday = missing_bday + 1
|
||||
if person.get_gender() == gen.lib.Person.FEMALE:
|
||||
females = females + 1
|
||||
elif person.get_gender() == gen.lib.Person.MALE:
|
||||
males = males + 1
|
||||
else:
|
||||
unknowns += 1
|
||||
if cnt % 200 == 0:
|
||||
yield True
|
||||
cnt += 1
|
||||
|
||||
self.clear_text()
|
||||
self.append_text(_("Individuals") + "\n")
|
||||
self.append_text("----------------------------\n")
|
||||
self.link(_("Number of individuals") + ":",
|
||||
'Filter', 'all people')
|
||||
self.append_text(" %s" % len(personList))
|
||||
self.append_text("\n")
|
||||
self.link("%s:" % _("Males"), 'Filter', 'males')
|
||||
self.append_text(" %s" % males)
|
||||
self.append_text("\n")
|
||||
self.link("%s:" % _("Females"), 'Filter', 'females')
|
||||
self.append_text(" %s" % females)
|
||||
self.append_text("\n")
|
||||
self.link("%s:" % _("Individuals with unknown gender"),
|
||||
'Filter', 'people with unknown gender')
|
||||
self.append_text(" %s" % unknowns)
|
||||
self.append_text("\n")
|
||||
self.link("%s:" % _("Individuals with incomplete names"),
|
||||
'Filter', 'people with incomplete names')
|
||||
self.append_text(" %s" % incomp_names)
|
||||
self.append_text("\n")
|
||||
self.link("%s:" % _("Individuals missing birth dates"),
|
||||
'Filter', 'people with missing birth dates')
|
||||
self.append_text(" %s" % missing_bday)
|
||||
self.append_text("\n")
|
||||
self.link("%s:" % _("Disconnected individuals"),
|
||||
'Filter', 'disconnected people')
|
||||
self.append_text(" %s" % disconnected)
|
||||
self.append_text("\n")
|
||||
self.append_text("\n%s\n" % _("Family Information"))
|
||||
self.append_text("----------------------------\n")
|
||||
self.link("%s:" % _("Number of families"),
|
||||
'Filter', 'all families')
|
||||
self.append_text(" %s" % len(familyList))
|
||||
self.append_text("\n")
|
||||
self.link("%s:" % _("Unique surnames"),
|
||||
'Filter', 'unique surnames')
|
||||
self.append_text(" %s" % len(namelist))
|
||||
self.append_text("\n")
|
||||
self.append_text("\n%s\n" % _("Media Objects"))
|
||||
self.append_text("----------------------------\n")
|
||||
self.link("%s:" % _("Individuals with media objects"),
|
||||
'Filter', 'people with media')
|
||||
self.append_text(" %s" % with_photos)
|
||||
self.append_text("\n")
|
||||
self.link("%s:" % _("Total number of media object references"),
|
||||
'Filter', 'media references')
|
||||
self.append_text(" %s" % total_photos)
|
||||
self.append_text("\n")
|
||||
self.link("%s:" % _("Number of unique media objects"),
|
||||
'Filter', 'unique media')
|
||||
self.append_text(" %s" % pobjects)
|
||||
self.append_text("\n")
|
||||
|
||||
self.link("%s:" % _("Total size of media objects"),
|
||||
'Filter', 'media by size')
|
||||
self.append_text(" %d %s" % (bytes, _("bytes")))
|
||||
self.append_text("\n")
|
||||
self.link("%s:" % _("Missing Media Objects"),
|
||||
'Filter', 'missing media')
|
||||
self.append_text(" %s\n" % len(notfound))
|
||||
self.append_text("", scroll_to="begin")
|
||||
|
||||
#------------------------------------------------------------------------
|
||||
#
|
||||
# Register Gramplet
|
||||
#
|
||||
#------------------------------------------------------------------------
|
||||
register(type="gramplet",
|
||||
name="Statistics Gramplet",
|
||||
tname=_("Statistics Gramplet"),
|
||||
height=230,
|
||||
expand=True,
|
||||
content = StatsGramplet,
|
||||
title=_("Statistics"),
|
||||
)
|
||||
|
||||
162
src/plugins/gramplet/SurnameCloudGramplet.py
Normal file
162
src/plugins/gramplet/SurnameCloudGramplet.py
Normal file
@ -0,0 +1,162 @@
|
||||
# Gramps - a GTK+/GNOME based genealogy program
|
||||
#
|
||||
# Copyright (C) 2007-2009 Douglas S. Blank <doug.blank@gmail.com>
|
||||
#
|
||||
# This program is free software; you can redistribute it and/or modify
|
||||
# it under the terms of the GNU General Public License as published by
|
||||
# the Free Software Foundation; either version 2 of the License, or
|
||||
# (at your option) any later version.
|
||||
#
|
||||
# This program is distributed in the hope that it will be useful,
|
||||
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
# GNU General Public License for more details.
|
||||
#
|
||||
# You should have received a copy of the GNU General Public License
|
||||
# along with this program; if not, write to the Free Software
|
||||
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
|
||||
# $Id$
|
||||
|
||||
#------------------------------------------------------------------------
|
||||
#
|
||||
# GRAMPS modules
|
||||
#
|
||||
#------------------------------------------------------------------------
|
||||
from DataViews import register, Gramplet
|
||||
from TransUtils import sgettext as _
|
||||
import Config
|
||||
|
||||
#------------------------------------------------------------------------
|
||||
#
|
||||
# Local functions
|
||||
#
|
||||
#------------------------------------------------------------------------
|
||||
def make_tag_size(n, counts, mins=8, maxs=20):
|
||||
# return font sizes mins to maxs
|
||||
diff = maxs - mins
|
||||
# based on counts (biggest to smallest)
|
||||
if len(counts) > 1:
|
||||
position = diff - (diff * (float(counts.index(n)) / (len(counts) - 1)))
|
||||
else:
|
||||
position = 0
|
||||
return int(position) + mins
|
||||
|
||||
#------------------------------------------------------------------------
|
||||
#
|
||||
# Gramplet class
|
||||
#
|
||||
#------------------------------------------------------------------------
|
||||
class SurnameCloudGramplet(Gramplet):
|
||||
def init(self):
|
||||
self.set_tooltip(_("Double-click surname for details"))
|
||||
self.top_size = 100 # will be overwritten in load
|
||||
self.set_text(_("No Family Tree loaded."))
|
||||
|
||||
def db_changed(self):
|
||||
self.dbstate.db.connect('person-add', self.update)
|
||||
self.dbstate.db.connect('person-delete', self.update)
|
||||
self.dbstate.db.connect('person-update', self.update)
|
||||
self.dbstate.db.connect('person-rebuild', self.update)
|
||||
self.dbstate.db.connect('family-rebuild', self.update)
|
||||
|
||||
def on_load(self):
|
||||
if len(self.gui.data) > 0:
|
||||
self.top_size = int(self.gui.data[0])
|
||||
|
||||
def on_save(self):
|
||||
self.gui.data = [self.top_size]
|
||||
|
||||
def main(self):
|
||||
self.set_text(_("Processing...") + "\n")
|
||||
yield True
|
||||
people = self.dbstate.db.get_person_handles(sort_handles=False)
|
||||
surnames = {}
|
||||
representative_handle = {}
|
||||
cnt = 0
|
||||
for person_handle in people:
|
||||
person = self.dbstate.db.get_person_from_handle(person_handle)
|
||||
if person:
|
||||
allnames = [person.get_primary_name()] + person.get_alternate_names()
|
||||
allnames = set([name.get_group_name().strip() for name in allnames])
|
||||
for surname in allnames:
|
||||
surnames[surname] = surnames.get(surname, 0) + 1
|
||||
representative_handle[surname] = person_handle
|
||||
if cnt % 350 == 0:
|
||||
yield True
|
||||
cnt += 1
|
||||
total_people = cnt
|
||||
surname_sort = []
|
||||
total = 0
|
||||
cnt = 0
|
||||
for surname in surnames:
|
||||
surname_sort.append( (surnames[surname], surname) )
|
||||
total += surnames[surname]
|
||||
if cnt % 350 == 0:
|
||||
yield True
|
||||
cnt += 1
|
||||
total_surnames = cnt
|
||||
surname_sort.sort(lambda a,b: -cmp(a,b))
|
||||
cloud_names = []
|
||||
cloud_values = []
|
||||
cnt = 0
|
||||
for (count, surname) in surname_sort:
|
||||
cloud_names.append( (count, surname) )
|
||||
cloud_values.append( count )
|
||||
cnt += 1
|
||||
cloud_names.sort(lambda a,b: cmp(a[1], b[1]))
|
||||
counts = list(set(cloud_values))
|
||||
counts.sort()
|
||||
counts.reverse()
|
||||
line = 0
|
||||
### All done!
|
||||
# Now, find out how many we can display without going over top_size:
|
||||
totals = {}
|
||||
for (count, givensubname) in cloud_names: # givensubname_sort:
|
||||
totals[count] = totals.get(count, 0) + 1
|
||||
sums = totals.keys()
|
||||
sums.sort()
|
||||
sums.reverse()
|
||||
total = 0
|
||||
include_greater_than = 0
|
||||
for s in sums:
|
||||
if total + totals[s] <= self.top_size:
|
||||
total += totals[s]
|
||||
else:
|
||||
include_greater_than = s
|
||||
break
|
||||
# Ok, now we can show those counts > include_greater_than:
|
||||
showing = 0
|
||||
self.set_text("")
|
||||
for (count, surname) in cloud_names: # surname_sort:
|
||||
if count > include_greater_than:
|
||||
if len(surname) == 0:
|
||||
text = Config.get(Config.NO_SURNAME_TEXT)
|
||||
else:
|
||||
text = surname
|
||||
size = make_tag_size(count, counts)
|
||||
self.link(text, 'Surname', representative_handle[surname], size,
|
||||
"%s, %d%% (%d)" % (text,
|
||||
int((float(count)/total_people) * 100),
|
||||
count))
|
||||
self.append_text(" ")
|
||||
showing += 1
|
||||
self.append_text(("\n\n" + _("Total unique surnames") + ": %d\n") %
|
||||
total_surnames)
|
||||
self.append_text((_("Total surnames showing") + ": %d\n") % showing)
|
||||
self.append_text((_("Total people") + ": %d") % total_people, "begin")
|
||||
|
||||
#------------------------------------------------------------------------
|
||||
#
|
||||
# Register Gramplet
|
||||
#
|
||||
#------------------------------------------------------------------------
|
||||
register(type="gramplet",
|
||||
name= "Surname Cloud Gramplet",
|
||||
tname=_("Surname Cloud Gramplet"),
|
||||
height=300,
|
||||
expand=True,
|
||||
content = SurnameCloudGramplet,
|
||||
title=_("Surname Cloud"),
|
||||
)
|
||||
|
||||
61
src/plugins/gramplet/ToDoGramplet.py
Normal file
61
src/plugins/gramplet/ToDoGramplet.py
Normal file
@ -0,0 +1,61 @@
|
||||
# Gramps - a GTK+/GNOME based genealogy program
|
||||
#
|
||||
# Copyright (C) 2007-2009 Douglas S. Blank <doug.blank@gmail.com>
|
||||
#
|
||||
# This program is free software; you can redistribute it and/or modify
|
||||
# it under the terms of the GNU General Public License as published by
|
||||
# the Free Software Foundation; either version 2 of the License, or
|
||||
# (at your option) any later version.
|
||||
#
|
||||
# This program is distributed in the hope that it will be useful,
|
||||
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
# GNU General Public License for more details.
|
||||
#
|
||||
# You should have received a copy of the GNU General Public License
|
||||
# along with this program; if not, write to the Free Software
|
||||
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
|
||||
# $Id$
|
||||
|
||||
#------------------------------------------------------------------------
|
||||
#
|
||||
# GRAMPS modules
|
||||
#
|
||||
#------------------------------------------------------------------------
|
||||
from DataViews import register, Gramplet
|
||||
from TransUtils import sgettext as _
|
||||
|
||||
#------------------------------------------------------------------------
|
||||
#
|
||||
# Gramplet class
|
||||
#
|
||||
#------------------------------------------------------------------------
|
||||
class TODOGramplet(Gramplet):
|
||||
def init(self):
|
||||
# GUI setup:
|
||||
self.set_tooltip(_("Enter text"))
|
||||
self.gui.textview.set_editable(True)
|
||||
self.append_text(_("Enter your TODO list here."))
|
||||
|
||||
def on_load(self):
|
||||
self.load_data_to_text()
|
||||
|
||||
def on_save(self):
|
||||
self.gui.data = [] # clear out old data
|
||||
self.save_text_to_data()
|
||||
|
||||
#------------------------------------------------------------------------
|
||||
#
|
||||
# Register Gramplet
|
||||
#
|
||||
#------------------------------------------------------------------------
|
||||
register(type="gramplet",
|
||||
name="TODO Gramplet",
|
||||
tname=_("TODO Gramplet"),
|
||||
height=300,
|
||||
expand=True,
|
||||
content = TODOGramplet,
|
||||
title=_("TODO List"),
|
||||
)
|
||||
|
||||
116
src/plugins/gramplet/TopSurnamesGramplet.py
Normal file
116
src/plugins/gramplet/TopSurnamesGramplet.py
Normal file
@ -0,0 +1,116 @@
|
||||
# Gramps - a GTK+/GNOME based genealogy program
|
||||
#
|
||||
# Copyright (C) 2007-2009 Douglas S. Blank <doug.blank@gmail.com>
|
||||
#
|
||||
# This program is free software; you can redistribute it and/or modify
|
||||
# it under the terms of the GNU General Public License as published by
|
||||
# the Free Software Foundation; either version 2 of the License, or
|
||||
# (at your option) any later version.
|
||||
#
|
||||
# This program is distributed in the hope that it will be useful,
|
||||
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
# GNU General Public License for more details.
|
||||
#
|
||||
# You should have received a copy of the GNU General Public License
|
||||
# along with this program; if not, write to the Free Software
|
||||
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
|
||||
# $Id$
|
||||
|
||||
#------------------------------------------------------------------------
|
||||
#
|
||||
# GRAMPS modules
|
||||
#
|
||||
#------------------------------------------------------------------------
|
||||
from DataViews import register, Gramplet
|
||||
from TransUtils import sgettext as _
|
||||
import Config
|
||||
|
||||
#------------------------------------------------------------------------
|
||||
#
|
||||
# Gramplet class
|
||||
#
|
||||
#------------------------------------------------------------------------
|
||||
class TopSurnamesGramplet(Gramplet):
|
||||
def init(self):
|
||||
self.set_tooltip(_("Double-click surname for details"))
|
||||
self.top_size = 10 # will be overwritten in load
|
||||
self.set_text(_("No Family Tree loaded."))
|
||||
|
||||
def db_changed(self):
|
||||
self.dbstate.db.connect('person-add', self.update)
|
||||
self.dbstate.db.connect('person-delete', self.update)
|
||||
self.dbstate.db.connect('person-update', self.update)
|
||||
self.dbstate.db.connect('person-rebuild', self.update)
|
||||
self.dbstate.db.connect('family-rebuild', self.update)
|
||||
|
||||
def on_load(self):
|
||||
if len(self.gui.data) > 0:
|
||||
self.top_size = int(self.gui.data[0])
|
||||
|
||||
def on_save(self):
|
||||
self.gui.data = [self.top_size]
|
||||
|
||||
def main(self):
|
||||
self.set_text(_("Processing...") + "\n")
|
||||
people = self.dbstate.db.get_person_handles(sort_handles=False)
|
||||
surnames = {}
|
||||
representative_handle = {}
|
||||
cnt = 0
|
||||
for person_handle in people:
|
||||
person = self.dbstate.db.get_person_from_handle(person_handle)
|
||||
if person:
|
||||
allnames = [person.get_primary_name()] + person.get_alternate_names()
|
||||
allnames = set([name.get_group_name().strip() for name in allnames])
|
||||
for surname in allnames:
|
||||
surnames[surname] = surnames.get(surname, 0) + 1
|
||||
representative_handle[surname] = person_handle
|
||||
if cnt % 350 == 0:
|
||||
yield True
|
||||
cnt += 1
|
||||
total_people = cnt
|
||||
surname_sort = []
|
||||
total = 0
|
||||
cnt = 0
|
||||
for surname in surnames:
|
||||
surname_sort.append( (surnames[surname], surname) )
|
||||
total += surnames[surname]
|
||||
if cnt % 350 == 0:
|
||||
yield True
|
||||
cnt += 1
|
||||
total_surnames = cnt
|
||||
surname_sort.sort(lambda a,b: -cmp(a,b))
|
||||
line = 0
|
||||
### All done!
|
||||
self.set_text("")
|
||||
for (count, surname) in surname_sort:
|
||||
if len(surname) == 0:
|
||||
text = "%s, %d%% (%d)\n" % (Config.get(Config.NO_SURNAME_TEXT),
|
||||
int((float(count)/total) * 100),
|
||||
count)
|
||||
else:
|
||||
text = "%s, %d%% (%d)\n" % (surname, int((float(count)/total) * 100),
|
||||
count)
|
||||
self.append_text(" %d. " % (line + 1))
|
||||
self.link(text, 'Surname', representative_handle[surname])
|
||||
line += 1
|
||||
if line >= self.top_size:
|
||||
break
|
||||
self.append_text(("\n" + _("Total unique surnames") + ": %d\n") %
|
||||
total_surnames)
|
||||
self.append_text((_("Total people") + ": %d") % total_people, "begin")
|
||||
|
||||
#------------------------------------------------------------------------
|
||||
#
|
||||
# Register Gramplet
|
||||
#
|
||||
#------------------------------------------------------------------------
|
||||
register(type="gramplet",
|
||||
name= "Top Surnames Gramplet",
|
||||
tname=_("Top Surnames Gramplet"),
|
||||
height=230,
|
||||
content = TopSurnamesGramplet,
|
||||
title=_("Top Surnames"),
|
||||
)
|
||||
|
||||
73
src/plugins/gramplet/WelcomeGramplet.py
Normal file
73
src/plugins/gramplet/WelcomeGramplet.py
Normal file
@ -0,0 +1,73 @@
|
||||
# Gramps - a GTK+/GNOME based genealogy program
|
||||
#
|
||||
# Copyright (C) 2007-2009 Douglas S. Blank <doug.blank@gmail.com>
|
||||
#
|
||||
# This program is free software; you can redistribute it and/or modify
|
||||
# it under the terms of the GNU General Public License as published by
|
||||
# the Free Software Foundation; either version 2 of the License, or
|
||||
# (at your option) any later version.
|
||||
#
|
||||
# This program is distributed in the hope that it will be useful,
|
||||
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
# GNU General Public License for more details.
|
||||
#
|
||||
# You should have received a copy of the GNU General Public License
|
||||
# along with this program; if not, write to the Free Software
|
||||
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
|
||||
# $Id$
|
||||
|
||||
#------------------------------------------------------------------------
|
||||
#
|
||||
# GRAMPS modules
|
||||
#
|
||||
#------------------------------------------------------------------------
|
||||
from DataViews import register
|
||||
from TransUtils import sgettext as _
|
||||
|
||||
#------------------------------------------------------------------------
|
||||
#
|
||||
# Gramplet class
|
||||
#
|
||||
#------------------------------------------------------------------------
|
||||
def make_welcome_content(gui):
|
||||
text = _(
|
||||
'Welcome to GRAMPS!\n\n'
|
||||
'GRAMPS is a software package designed for genealogical research.'
|
||||
' Although similar to other genealogical programs, GRAMPS offers '
|
||||
'some unique and powerful features.\n\n'
|
||||
'GRAMPS is an Open Source Software package, which means you are '
|
||||
'free to make copies and distribute it to anyone you like. It\'s '
|
||||
'developed and maintained by a worldwide team of volunteers whose'
|
||||
' goal is to make GRAMPS powerful, yet easy to use.\n\n'
|
||||
'Getting Started\n\n'
|
||||
'The first thing you must do is to create a new Family Tree. To '
|
||||
'create a new Family Tree (sometimes called a database) select '
|
||||
'"Family Trees" from the menu, pick "Manage Family Trees", press '
|
||||
'"New" and name your database. For more details, please read the '
|
||||
'User Manual, or the on-line manual at http://gramps-project.org.\n\n'
|
||||
'You are currently reading from the "Gramplets" page, where you can'
|
||||
' add your own gramplets.\n\n'
|
||||
'You can right-click on the background of this page to add additional'
|
||||
' gramplets and change the number of columns. You can also drag the '
|
||||
'Properties button to reposition the gramplet on this page, and detach'
|
||||
' the gramplet to float above GRAMPS. If you close GRAMPS with a gramplet'
|
||||
' detached, it will re-open detached the next time you start '
|
||||
'GRAMPS.'
|
||||
)
|
||||
gui.set_text(text)
|
||||
|
||||
#------------------------------------------------------------------------
|
||||
#
|
||||
# Register Gramplet
|
||||
#
|
||||
#------------------------------------------------------------------------
|
||||
register(type="gramplet",
|
||||
name="Welcome Gramplet",
|
||||
tname=_("Welcome Gramplet"),
|
||||
height=300,
|
||||
expand=True,
|
||||
content = make_welcome_content,
|
||||
title=_("Welcome to GRAMPS!"),
|
||||
)
|
||||
Loading…
Reference in New Issue
Block a user