622 lines
19 KiB
Python
622 lines
19 KiB
Python
#
|
|
# Gramps - a GTK+/GNOME based genealogy program
|
|
#
|
|
# Copyright (C) 2000 Donald N. Allingham
|
|
#
|
|
# 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
|
|
#
|
|
|
|
"Export to GEDCOM"
|
|
|
|
from RelLib import *
|
|
import os
|
|
import string
|
|
import time
|
|
import const
|
|
import utils
|
|
import intl
|
|
_ = intl.gettext
|
|
|
|
from gtk import *
|
|
from gnome.ui import *
|
|
from libglade import *
|
|
|
|
import const
|
|
from latin_ansel import latin_to_ansel
|
|
|
|
topDialog = None
|
|
db = None
|
|
|
|
people_list = []
|
|
family_list = []
|
|
source_list = []
|
|
|
|
#-------------------------------------------------------------------------
|
|
#
|
|
#
|
|
#
|
|
#-------------------------------------------------------------------------
|
|
def entire_database():
|
|
global people_list
|
|
global family_list
|
|
global source_list
|
|
|
|
people_list = db.getPersonMap().values()
|
|
family_list = db.getFamilyMap().values()
|
|
source_list = db.getSourceMap().values()
|
|
|
|
#-------------------------------------------------------------------------
|
|
#
|
|
#
|
|
#
|
|
#-------------------------------------------------------------------------
|
|
def active_person_descendants():
|
|
global people_list
|
|
global family_list
|
|
global source_list
|
|
|
|
people_list = []
|
|
family_list = []
|
|
source_list = []
|
|
descend(active_person)
|
|
|
|
#-------------------------------------------------------------------------
|
|
#
|
|
#
|
|
#
|
|
#-------------------------------------------------------------------------
|
|
def active_person_ancestors_and_descendants():
|
|
global people_list
|
|
global family_list
|
|
global source_list
|
|
|
|
people_list = []
|
|
family_list = []
|
|
source_list = []
|
|
descend(active_person)
|
|
ancestors(active_person)
|
|
|
|
#-------------------------------------------------------------------------
|
|
#
|
|
#
|
|
#
|
|
#-------------------------------------------------------------------------
|
|
def active_person_ancestors():
|
|
global people_list
|
|
global family_list
|
|
global source_list
|
|
|
|
people_list = []
|
|
family_list = []
|
|
source_list = []
|
|
ancestors(active_person)
|
|
|
|
#-------------------------------------------------------------------------
|
|
#
|
|
#
|
|
#
|
|
#-------------------------------------------------------------------------
|
|
def interconnected():
|
|
global people_list
|
|
global family_list
|
|
global source_list
|
|
|
|
people_list = []
|
|
family_list = []
|
|
source_list = []
|
|
walk(active_person)
|
|
|
|
#-------------------------------------------------------------------------
|
|
#
|
|
#
|
|
#
|
|
#-------------------------------------------------------------------------
|
|
def descend(person):
|
|
if person == None or person in people_list:
|
|
return
|
|
people_list.append(person)
|
|
add_persons_sources(person)
|
|
for family in person.getFamilyList():
|
|
add_familys_sources(family)
|
|
family_list.append(family)
|
|
father = family.getFather()
|
|
mother = family.getMother()
|
|
if father != None and father not in people_list:
|
|
people_list.append(father)
|
|
add_persons_sources(father)
|
|
if mother != None and mother not in people_list:
|
|
people_list.append(mother)
|
|
add_persons_sources(mother)
|
|
for child in family.getChildList():
|
|
descend(child)
|
|
|
|
#-------------------------------------------------------------------------
|
|
#
|
|
#
|
|
#
|
|
#-------------------------------------------------------------------------
|
|
def ancestors(person):
|
|
if person == None or person in people_list:
|
|
return
|
|
people_list.append(person)
|
|
add_persons_sources(person)
|
|
family = person.getMainFamily()
|
|
if family == None or family in family_list:
|
|
return
|
|
add_familys_sources(family)
|
|
family_list.append(family)
|
|
ancestors(family.getMother())
|
|
ancestors(family.getFather())
|
|
|
|
#-------------------------------------------------------------------------
|
|
#
|
|
#
|
|
#
|
|
#-------------------------------------------------------------------------
|
|
def walk(person):
|
|
if person == None or person in people_list:
|
|
return
|
|
people_list.append(person)
|
|
add_persons_sources(person)
|
|
families = person.getFamilyList() + person.getAltFamilyList()
|
|
families.append(person.getMainFamily())
|
|
for family in families:
|
|
if family == None or family in family_list:
|
|
continue
|
|
add_familys_sources(family)
|
|
family_list.append(family)
|
|
walk(family.getFather())
|
|
walk(family.getMother())
|
|
for child in family.getChildList():
|
|
walk(child)
|
|
|
|
#-------------------------------------------------------------------------
|
|
#
|
|
#
|
|
#
|
|
#-------------------------------------------------------------------------
|
|
def add_persons_sources(person):
|
|
elist = person.getEventList()[:]
|
|
if person.getBirth():
|
|
elist.append(person.getBirth())
|
|
if person.getDeath():
|
|
elist.append(person.getDeath())
|
|
for event in elist:
|
|
source_ref = event.getSourceRef()
|
|
if source_ref != None:
|
|
source_list.append(source_ref)
|
|
|
|
#-------------------------------------------------------------------------
|
|
#
|
|
#
|
|
#
|
|
#-------------------------------------------------------------------------
|
|
def add_familys_sources(family):
|
|
elist = family.getEventList()[:]
|
|
if family.getMarriage():
|
|
elist.append(family.getMarriage())
|
|
if family.getDivorce():
|
|
elist.append(family.getDivorce())
|
|
for event in elist:
|
|
source_ref = event.getSourceRef()
|
|
if source_ref != None:
|
|
source_list.append(source_ref)
|
|
|
|
#-------------------------------------------------------------------------
|
|
#
|
|
#
|
|
#
|
|
#-------------------------------------------------------------------------
|
|
def sortById(first,second):
|
|
fid = first.getId()
|
|
sid = second.getId()
|
|
|
|
if fid == sid:
|
|
return 0
|
|
elif fid < sid:
|
|
return -1
|
|
else:
|
|
return 1
|
|
|
|
#-------------------------------------------------------------------------
|
|
#
|
|
#
|
|
#
|
|
#-------------------------------------------------------------------------
|
|
def writeNote(g,id,note):
|
|
g.write("1 NOTE @NI%s@\n" % id)
|
|
g.write("0 @NI%s@ NOTE\n" % id)
|
|
first = 0
|
|
realfirst = 0
|
|
words = []
|
|
textlines = string.split(note,'\n')
|
|
|
|
lineLen = 0
|
|
text = ""
|
|
|
|
for line in textlines:
|
|
if line == "":
|
|
continue
|
|
line = latin_to_ansel(line)
|
|
for word in string.split(line):
|
|
text = text + " " + word
|
|
if len(text) > 72 :
|
|
if first == 0 or realfirst == 0:
|
|
g.write("1 CONC%s \n" % text)
|
|
realfirst = 1
|
|
else:
|
|
g.write("1 CONT%s\n" % text)
|
|
first = 0
|
|
text = ""
|
|
if len(text) > 0:
|
|
if first == 0 or realfirst == 0:
|
|
g.write("1 CONC%s \n" % text)
|
|
realfirst = 1
|
|
else:
|
|
g.write("1 CONT%s\n" % text)
|
|
first = 1
|
|
text = ""
|
|
|
|
g.write("1 CONT\n")
|
|
first = 1
|
|
|
|
#-------------------------------------------------------------------------
|
|
#
|
|
#
|
|
#
|
|
#-------------------------------------------------------------------------
|
|
def write_comment(g,note):
|
|
g.write("3 NOTE ")
|
|
first = 0
|
|
realfirst = 0
|
|
words = []
|
|
textlines = string.split(note,'\n')
|
|
|
|
lineLen = 0
|
|
text = ""
|
|
|
|
for line in textlines:
|
|
if line == "":
|
|
continue
|
|
line = latin_to_ansel(line)
|
|
for word in string.split(line):
|
|
text = text + " " + word
|
|
if len(text) > 72 :
|
|
if realfirst == 0:
|
|
g.write("%s \n" % text)
|
|
realfirst = 1
|
|
elif first == 0:
|
|
g.write("1 CONC%s \n" % text)
|
|
realfirst = 1
|
|
else:
|
|
g.write("1 CONT%s\n" % text)
|
|
first = 0
|
|
text = ""
|
|
if len(text) > 0:
|
|
if realfirst == 0:
|
|
g.write("%s \n" % text)
|
|
realfirst = 1
|
|
elif first == 0:
|
|
g.write("1 CONC%s \n" % text)
|
|
realfirst = 1
|
|
else:
|
|
g.write("1 CONT%s\n" % text)
|
|
first = 1
|
|
text = ""
|
|
|
|
g.write("1 CONT\n")
|
|
first = 1
|
|
|
|
#-------------------------------------------------------------------------
|
|
#
|
|
#
|
|
#
|
|
#-------------------------------------------------------------------------
|
|
def dump_event_stats(g,event):
|
|
if event.getSaveDate() != "":
|
|
g.write("2 DATE %s\n" % latin_to_ansel(event.getSaveDate()))
|
|
if event.getPlace() != "":
|
|
g.write("2 PLAC %s\n" % latin_to_ansel(event.getPlace()))
|
|
source = event.getSourceRef()
|
|
if source:
|
|
base = source.getBase()
|
|
if base:
|
|
g.write("2 SOUR @" + str(base.getId()) + "@\n")
|
|
text = latin_to_ansel(string.strip(source.getPage()))
|
|
if text != "":
|
|
g.write("3 PAGE " + text + "\n")
|
|
text = latin_to_ansel(string.strip(source.getText()))
|
|
if text != "":
|
|
g.write("3 DATA\n")
|
|
g.write("4 TEXT " + text + "\n")
|
|
comments = latin_to_ansel(string.strip(source.getComments()))
|
|
if comments != "":
|
|
write_comment(g,comments)
|
|
|
|
#-------------------------------------------------------------------------
|
|
#
|
|
#
|
|
#
|
|
#-------------------------------------------------------------------------
|
|
def probably_alive(person):
|
|
|
|
if person == None:
|
|
return 1
|
|
|
|
if restrict == 0:
|
|
return 0
|
|
|
|
death = person.getDeath()
|
|
birth = person.getBirth()
|
|
|
|
if death.getDate() != "":
|
|
return 0
|
|
if birth.getDate() != "":
|
|
year = birth.getDateObj().getYear()
|
|
time_struct = time.localtime(time.time())
|
|
current_year = time_struct[0]
|
|
if year != -1 and current_year - year > 110:
|
|
return 0
|
|
return 1
|
|
|
|
#-------------------------------------------------------------------------
|
|
#
|
|
#
|
|
#
|
|
#-------------------------------------------------------------------------
|
|
def exportData(database, filename):
|
|
|
|
g = open(filename,"w")
|
|
|
|
date = string.split(time.ctime(time.time()))
|
|
|
|
g.write("0 HEAD\n")
|
|
g.write("1 SOUR GRAMPS\n")
|
|
g.write("2 VERS " + const.version + "\n")
|
|
g.write("2 NAME Gramps\n")
|
|
g.write("1 DEST GRAMPS\n")
|
|
g.write("1 DATE %s %s %s\n" % (date[2],string.upper(date[1]),date[4]))
|
|
g.write("1 CHAR ANSEL\n");
|
|
g.write("1 SUBM @SUBM@\n")
|
|
g.write("1 FILE %s\n" % filename)
|
|
g.write("1 GEDC\n")
|
|
g.write("2 VERS 5.5\n")
|
|
g.write("0 @SUBM@ SUBM\n")
|
|
owner = database.getResearcher()
|
|
if owner.getName() != "":
|
|
g.write("1 NAME " + latin_to_ansel(owner.getName()) +"\n")
|
|
if owner.getAddress() != "":
|
|
g.write("1 ADDR " + latin_to_ansel(owner.getAddress()) + "\n")
|
|
if owner.getCity() != "":
|
|
g.write("2 CITY " + latin_to_ansel(owner.getCity()) + "\n")
|
|
if owner.getState() != "":
|
|
g.write("2 STAE " + latin_to_ansel(owner.getState()) + "\n")
|
|
if owner.getPostalCode() != "":
|
|
g.write("2 POST " + latin_to_ansel(owner.getPostalCode()) + "\n")
|
|
if owner.getCountry() != "":
|
|
g.write("2 CTRY " + latin_to_ansel(owner.getCountry()) + "\n")
|
|
if owner.getPhone() != "":
|
|
g.write("1 PHON " + latin_to_ansel(owner.getPhone()) + "\n")
|
|
|
|
people_list.sort(sortById)
|
|
for person in people_list:
|
|
g.write("0 @I%s@ INDI\n" % person.getId())
|
|
name = person.getPrimaryName()
|
|
firstName = latin_to_ansel(name.getFirstName())
|
|
surName = latin_to_ansel(name.getSurname())
|
|
suffix = latin_to_ansel(name.getSuffix())
|
|
if suffix == "":
|
|
g.write("1 NAME %s /%s/\n" % (firstName,surName))
|
|
else:
|
|
g.write("1 NAME %s /%s/, %s\n" % (firstName,surName, suffix))
|
|
|
|
if name.getFirstName() != "":
|
|
g.write("2 GIVN %s\n" % firstName)
|
|
if name.getSurname() != "":
|
|
g.write("2 SURN %s\n" % surName)
|
|
if name.getSuffix() != "":
|
|
g.write("2 NSFX %s\n" % suffix)
|
|
|
|
if person.getGender() == Person.male:
|
|
g.write("1 SEX M\n")
|
|
else:
|
|
g.write("1 SEX F\n")
|
|
|
|
if not probably_alive(person):
|
|
|
|
birth = person.getBirth()
|
|
if birth.getSaveDate() != "" or birth.getPlace() != "":
|
|
g.write("1 BIRT\n")
|
|
dump_event_stats(g,birth)
|
|
|
|
death = person.getDeath()
|
|
if death.getSaveDate() != "" or death.getPlace() != "":
|
|
g.write("1 DEAT\n")
|
|
dump_event_stats(g,death)
|
|
|
|
uid = person.getPafUid()
|
|
if uid != "":
|
|
g.write("1 _UID " + uid + "\n")
|
|
|
|
for event in person.getEventList():
|
|
name = event.getName()
|
|
if const.personalConstantEvents.has_key(name):
|
|
val = const.personalConstantEvents[name]
|
|
else:
|
|
val = ""
|
|
if val != "" :
|
|
g.write("1 " + const.personalConstantEvents[name] + \
|
|
" " + event.getDescription() + "\n")
|
|
else:
|
|
g.write("1 EVEN " + latin_to_ansel(event.getDescription()) + "\n")
|
|
g.write("2 TYPE " + latin_to_ansel(event.getName()) + "\n")
|
|
dump_event_stats(g,event)
|
|
|
|
for attr in person.getAttributeList():
|
|
name = attr.getType()
|
|
if const.personalConstantAttributes.has_key(name):
|
|
val = const.personalConstantEvents[name]
|
|
else:
|
|
val = ""
|
|
if val != "" :
|
|
g.write("1 " + val + "\n")
|
|
else:
|
|
g.write("1 EVEN " + "\n")
|
|
g.write("2 TYPE " + latin_to_ansel(name) + "\n")
|
|
g.write("2 PLAC " + latin_to_ansel(attr.getValue()) + "\n")
|
|
|
|
family = person.getMainFamily()
|
|
if family != None and family in family_list:
|
|
g.write("1 FAMC @F%s@\n" % family.getId())
|
|
|
|
for family in person.getFamilyList():
|
|
if family != None and family in family_list:
|
|
g.write("1 FAMS @F%s@\n" % family.getId())
|
|
|
|
if person.getNote() != "":
|
|
writeNote(g,person.getId(),person.getNote())
|
|
|
|
for family in family_list:
|
|
g.write("0 @F%s@ FAM\n" % family.getId())
|
|
person = family.getFather()
|
|
if person != None:
|
|
g.write("1 HUSB @I%s@\n" % person.getId())
|
|
|
|
person = family.getMother()
|
|
if person != None:
|
|
g.write("1 WIFE @I%s@\n" % person.getId())
|
|
|
|
father = family.getFather()
|
|
mother = family.getMother()
|
|
if not probably_alive(father) or not probably_alive(mother):
|
|
event = family.getMarriage()
|
|
if event != None:
|
|
g.write("1 MARR\n");
|
|
dump_event_stats(g,event)
|
|
|
|
event = family.getDivorce()
|
|
if event != None:
|
|
g.write("1 DIV\n");
|
|
dump_event_stats(g,event)
|
|
|
|
for event in family.getEventList():
|
|
text = event.getName()
|
|
|
|
if const.familyConstantEvents.has_key(name):
|
|
val = const.personalConstantEvents[name]
|
|
else:
|
|
val = ""
|
|
if val != "": # and val[0] != "_":
|
|
g.write("1 %s\n" % const.familyConstantEvents[text])
|
|
else:
|
|
g.write("1 EVEN\n")
|
|
g.write("2 TYPE %s\n" % latin_to_ansel(event.getName()))
|
|
|
|
dump_event_stats(g,event)
|
|
|
|
for person in family.getChildList():
|
|
g.write("1 CHIL @I%s@\n" % person.getId())
|
|
|
|
for source in source_list:
|
|
g.write("0 @" + str(source.getId()) + "@ SOUR\n")
|
|
if source.getTitle() != "":
|
|
g.write("1 TITL " + latin_to_ansel(source.getTitle()) + "\n")
|
|
if source.getAuthor() != "":
|
|
g.write("1 AUTH " + latin_to_ansel(source.getAuthor()) + "\n")
|
|
if source.getPubInfo() != "":
|
|
g.write("1 PUBL " + latin_to_ansel(source.getPubInfo()) + "\n")
|
|
if source.getTitle() != "":
|
|
g.write("1 ABBR " + latin_to_ansel(source.getTitle()) + "\n")
|
|
if source.getCallNumber() != "":
|
|
g.write("1 CALN " + latin_to_ansel(source.getCallNumber()) + "\n")
|
|
|
|
|
|
g.write("0 TRLR\n")
|
|
g.close()
|
|
|
|
#-------------------------------------------------------------------------
|
|
#
|
|
#
|
|
#
|
|
#-------------------------------------------------------------------------
|
|
def on_ok_clicked(obj):
|
|
global db
|
|
global topDialog
|
|
global restrict
|
|
|
|
restrict = topDialog.get_widget("restrict").get_active()
|
|
filter_obj = topDialog.get_widget("filter").get_menu().get_active()
|
|
filter = filter_obj.get_data("filter")
|
|
|
|
name = topDialog.get_widget("filename").get_text()
|
|
filter()
|
|
|
|
exportData(db,name)
|
|
utils.destroy_passed_object(obj)
|
|
|
|
#-------------------------------------------------------------------------
|
|
#
|
|
#
|
|
#
|
|
#-------------------------------------------------------------------------
|
|
def writeData(database,person):
|
|
global db
|
|
global topDialog
|
|
global active_person
|
|
|
|
db = database
|
|
active_person = person
|
|
|
|
base = os.path.dirname(__file__)
|
|
glade_file = base + os.sep + "gedcomexport.glade"
|
|
|
|
dic = {
|
|
"destroy_passed_object" : utils.destroy_passed_object,
|
|
"on_ok_clicked" : on_ok_clicked
|
|
}
|
|
|
|
topDialog = GladeXML(glade_file,"gedcomExport")
|
|
topDialog.signal_autoconnect(dic)
|
|
|
|
filter_obj = topDialog.get_widget("filter")
|
|
myMenu = GtkMenu()
|
|
menuitem = GtkMenuItem(_("Entire Database"))
|
|
myMenu.append(menuitem)
|
|
menuitem.set_data("filter",entire_database)
|
|
menuitem.show()
|
|
name = active_person.getPrimaryName().getRegularName()
|
|
menuitem = GtkMenuItem(_("Ancestors of %s") % name)
|
|
myMenu.append(menuitem)
|
|
menuitem.set_data("filter",active_person_ancestors)
|
|
menuitem.show()
|
|
menuitem = GtkMenuItem(_("Descendants of %s") % name)
|
|
myMenu.append(menuitem)
|
|
menuitem.set_data("filter",active_person_descendants)
|
|
menuitem.show()
|
|
menuitem = GtkMenuItem(_("Ancestors and Descendants of %s") % name)
|
|
myMenu.append(menuitem)
|
|
menuitem.set_data("filter",active_person_ancestors_and_descendants)
|
|
menuitem.show()
|
|
menuitem = GtkMenuItem(_("People somehow connected to %s") % name)
|
|
myMenu.append(menuitem)
|
|
menuitem.set_data("filter",interconnected)
|
|
menuitem.show()
|
|
filter_obj.set_menu(myMenu)
|
|
|
|
topDialog.get_widget("gedcomExport").show()
|
|
|
|
def get_name():
|
|
return _("Export to GEDCOM")
|