Cyclone-Team/gramps
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
4e37696aa5
gramps/src/gramps_main.py

2456 lines
76 KiB
Python
Executable File
Raw Blame History

#! /usr/bin/python -O
#
# 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
#
#-------------------------------------------------------------------------
#
# Standard python modules
#
#-------------------------------------------------------------------------
import sys
import string
import re
import os
#-------------------------------------------------------------------------
#
# internationalization
#
#-------------------------------------------------------------------------
import intl,sys
_ = intl.gettext
#-------------------------------------------------------------------------
#
# GTK/Gnome modules
#
#-------------------------------------------------------------------------
from gtk import *
from gnome.ui import *
import GTK
import libglade
#-------------------------------------------------------------------------
#
# gramps modules
#
#-------------------------------------------------------------------------
from RelLib import *
import Filter
import const
import Plugins
import sort
import utils
import Bookmarks
import ListColors
import Config
import EditSource
import EditPerson
import Marriage
#-------------------------------------------------------------------------
#
# Global variables.
#
# I'm not fond of global variables. Howerver, I am fairly inexperienced
# with a GUI callback model, and I don't have another way of doing this
# yet.
#
#-------------------------------------------------------------------------
active_event = None
active_person = None
active_father = None
active_family = None
active_parents= None
active_mother = None
active_child = None
active_spouse = None
select_father = None
select_spouse = None
select_mother = None
select_child_list = {}
bookmarks = None
id2col = {}
topWindow = None
statusbar = None
gtop = None
person_list = None
source_list = None
database = None
family_window = None
queryTop = None
prefsTop = None
pv = {}
sortFunc = sort.fast_name_sort
sbar_active = 1
DataFilter = Filter.create("")
#-------------------------------------------------------------------------
#
# Constants
#
#-------------------------------------------------------------------------
NOTEBOOK = "notebook1"
FILESEL = "fileselection"
FILTERNAME = "filter_list"
ODDFGCOLOR = "oddForeground"
ODDBGCOLOR = "oddBackground"
EVENFGCOLOR= "evenForeground"
EVENBGCOLOR= "evenBackground"
#-------------------------------------------------------------------------
#
# Short hand function to return either the person's birthday, or an empty
# string if the person is None
#
#-------------------------------------------------------------------------
def birthday(person):
if person:
return person.getBirth().getQuoteDate()
else:
return ""
#-------------------------------------------------------------------------
#
# Short hand function to return either the person's birthday, or an empty
# string if the person is None
#
#-------------------------------------------------------------------------
def deathday(person):
if person:
return person.getDeath().getQuoteDate()
else:
return ""
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def delete_event(widget, event):
widget.hide()
if utils.wasModified():
question = _("Unsaved changes exist in the current database\n") + \
_("Do you wish to save the changes?")
topWindow.question(question,save_query)
else:
mainquit(widget)
return TRUE
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def on_exit_activate(obj):
if utils.wasModified():
question = _("Unsaved changes exist in the current database\n") + \
_("Do you wish to save the changes?")
topWindow.question(question,save_query)
else:
mainquit(obj)
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def save_query(value):
if value == 0:
on_save_activate(None)
mainquit(gtop)
#-------------------------------------------------------------------------
#
# Displays the about box. Called from Help menu
#
#-------------------------------------------------------------------------
def on_about_activate(obj):
GnomeAbout(const.progName,const.version,const.copyright,
const.authors,const.comments,const.logo).show()
#-------------------------------------------------------------------------
#
# Display the help box
#
#-------------------------------------------------------------------------
def on_contents_activate(obj):
GnomeOkDialog(_("Sorry. Online help for gramps is currently under development.\nUnfortunately, it is not yet ready."))
#-------------------------------------------------------------------------
#
# Called when the remove child button clicked on the family page. If
# no active person is specified, or if no active child is specified,
# then the button press is meaningless, and should be ignored. Otherwise,
# remove the child from the active family, and set the family the child
# belongs to to None.
#
#-------------------------------------------------------------------------
def on_remove_child_clicked(obj):
if not active_family or not active_child:
return
active_family.removeChild(active_child)
active_child.setMainFamily(None)
utils.modified()
load_family()
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def on_add_sp_clicked(obj):
add_spouse()
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def on_edit_sp_clicked(obj):
marriage_edit(active_family)
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def on_delete_sp_clicked(obj):
delete_spouse()
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def on_add_child_clicked(obj):
global addChildList
global childWindow
global select_child_list
childWindow = libglade.GladeXML(const.gladeFile,"selectChild")
childWindow.signal_autoconnect({
"on_save_child_clicked" : on_save_child_clicked,
"on_addChild_select_row" : on_addChild_select_row,
"on_addChild_unselect_row" : on_addChild_unselect_row,
"on_show_toggled" : on_show_toggled,
"destroy_passed_object" : utils.destroy_passed_object
})
select_child_list = {}
selectChild = childWindow.get_widget("selectChild")
addChildList = childWindow.get_widget("addChild")
addChildList.set_column_visibility(1,Config.id_visible)
father = active_family.getFather()
if father != None:
fname = father.getPrimaryName().getName()
childWindow.get_widget("flabel").set_text(_("Relationship to %s") % fname)
mother = active_family.getMother()
if mother != None:
mname = mother.getPrimaryName().getName()
childWindow.get_widget("mlabel").set_text(_("Relationship to %s") % mname)
childWindow.get_widget("mrel").set_text(_("Birth"))
childWindow.get_widget("frel").set_text(_("Birth"))
redraw_child_list(2)
selectChild.show()
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def redraw_child_list(filter):
person_list = database.getPersonMap().values()
person_list.sort(sort.by_last_name)
addChildList.freeze()
addChildList.clear()
index = 0
for person in person_list:
if filter and person.getMainFamily() != None:
continue
addChildList.append([utils.phonebook_name(person),birthday(person),\
person.getId()])
addChildList.set_row_data(index,person)
index = index + 1
addChildList.thaw()
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def on_show_toggled(obj):
redraw_child_list(obj.get_active())
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def on_add_new_child_clicked(obj):
global newChildWindow
newChildWindow = libglade.GladeXML(const.gladeFile,"addChild")
newChildWindow.signal_autoconnect({
"on_addchild_ok_clicked" : on_addchild_ok_clicked,
"destroy_passed_object" : utils.destroy_passed_object
})
if active_person.getGender() == Person.male:
surname = active_person.getPrimaryName().getSurname()
elif active_spouse:
surname = active_spouse.getPrimaryName().getSurname()
else:
surname = ""
father = active_family.getFather()
if father != None:
fname = father.getPrimaryName().getName()
newChildWindow.get_widget("flabel").set_text(_("Relationship to %s") % fname)
mother = active_family.getMother()
if mother != None:
mname = mother.getPrimaryName().getName()
newChildWindow.get_widget("mlabel").set_text(_("Relationship to %s") % mname)
newChildWindow.get_widget("childSurname").set_text(surname)
newChildWindow.get_widget("addChild").show()
newChildWindow.get_widget("mrel").set_text(_("Birth"))
newChildWindow.get_widget("frel").set_text(_("Birth"))
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def on_addchild_ok_clicked(obj):
global active_family
surname = newChildWindow.get_widget("childSurname").get_text()
given = newChildWindow.get_widget("childGiven").get_text()
person = Person()
database.addPerson(person)
name = Name()
name.setSurname(surname)
name.setFirstName(given)
person.setPrimaryName(name)
if newChildWindow.get_widget("childGender").get_active():
person.setGender(Person.male)
else:
person.setGender(Person.female)
if not active_family:
active_family = database.newFamily()
if active_person.getGender() == Person.male:
active_family.setFather(active_person)
else:
active_family.setMother(active_person)
active_person.addFamily(active_family)
mrel = const.childRelations[newChildWindow.get_widget("mrel").get_text()]
frel = const.childRelations[newChildWindow.get_widget("frel").get_text()]
if mrel == "Birth" and frel == "Birth":
person.setMainFamily(active_family)
else:
person.addAltFamily(active_family,mrel,frel)
active_family.addChild(person)
# must do an apply filter here to make sure the main window gets updated
apply_filter()
load_family()
utils.modified()
utils.destroy_passed_object(obj)
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def on_save_child_clicked(obj):
global active_family
for select_child in select_child_list.keys():
if active_family == None:
active_family = database.newFamily()
active_person.addFamily(active_family)
if active_person.getGender() == Person.male:
active_family.setFather(active_person)
else:
active_family.setMother(active_person)
active_family.addChild(select_child)
mrel = const.childRelations[childWindow.get_widget("mrel").get_text()]
mother = active_family.getMother()
if mother and mother.getGender() != Person.female:
if mrel == "Birth":
mrel = "Unknown"
frel = const.childRelations[childWindow.get_widget("frel").get_text()]
father = active_family.getFather()
if father and father.getGender() != Person.male:
if frel == "Birth":
frel = "Unknown"
if mrel == "Birth" and frel == "Birth":
family = select_child.getMainFamily()
if family != None and family != active_family:
family.removeChild(select_child)
select_child.setMainFamily(active_family)
else:
select_child.addAltFamily(active_family,mrel,frel)
utils.modified()
utils.destroy_passed_object(obj)
load_family()
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def get_option_index(obj):
active_item = obj.get_active()
index = 0
for item in obj.children():
if item == active_item:
break
index = index + 1
return index
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def on_choose_parents_clicked(obj):
global select_mother
global select_father
global family_window
if active_parents:
select_father = active_parents.getFather()
select_mother = active_parents.getMother()
else:
select_mother = None
select_father = None
family_window = libglade.GladeXML(const.gladeFile,"familyDialog")
familyDialog = family_window.get_widget("familyDialog")
if active_parents and active_parents == active_person.getMainFamily():
family_window.get_widget("mrel").set_text(_("Birth"))
family_window.get_widget("frel").set_text(_("Birth"))
else:
for f in active_person.getAltFamilyList():
if f[0] == active_parents:
family_window.get_widget("mrel").set_text(_(f[1]))
family_window.get_widget("frel").set_text(_(f[2]))
break
else:
family_window.get_widget("mrel").set_text(_("Unknown"))
family_window.get_widget("frel").set_text(_("Unknown"))
fcombo = family_window.get_widget("prel_combo")
prel = family_window.get_widget("prel")
prel.set_data("o",family_window)
fcombo.set_popdown_strings(const.familyRelations)
family_window.signal_autoconnect({
"on_motherList_select_row" : on_motherList_select_row,
"on_fatherList_select_row" : on_fatherList_select_row,
"on_save_parents_clicked" : on_save_parents_clicked,
"on_prel_changed" : on_prel_changed,
"destroy_passed_object" : utils.destroy_passed_object
})
text = _("Choose the Parents of %s") % Config.nameof(active_person)
family_window.get_widget("chooseTitle").set_text(text)
if active_parents:
prel.set_text(active_parents.getRelationship())
familyDialog.show()
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def on_prel_changed(obj):
family_window = obj.get_data("o")
type = obj.get_text()
fatherName = family_window.get_widget("fatherName")
fatherName.set_text(Config.nameof(select_father))
motherName = family_window.get_widget("motherName")
motherName.set_text(Config.nameof(select_mother))
fatherList = family_window.get_widget("fatherList")
motherList = family_window.get_widget("motherList")
fatherList.freeze()
motherList.freeze()
fatherList.clear()
motherList.clear()
fatherList.append(["Unknown",""])
fatherList.set_row_data(0,None)
fatherList.set_data("father_text",fatherName)
motherList.append(["Unknown",""])
motherList.set_row_data(0,None)
motherList.set_data("mother_text",motherName)
people = database.getPersonMap().values()
people.sort(sort.by_last_name)
father_index = 1
mother_index = 1
for person in people:
if person == active_person:
continue
elif type == "Partners":
fatherList.append([utils.phonebook_name(person),birthday(person)])
fatherList.set_row_data(father_index,person)
father_index = father_index + 1
motherList.append([utils.phonebook_name(person),birthday(person)])
motherList.set_row_data(mother_index,person)
mother_index = mother_index + 1
elif person.getGender() == Person.male:
fatherList.append([utils.phonebook_name(person),birthday(person)])
fatherList.set_row_data(father_index,person)
father_index = father_index + 1
else:
motherList.append([utils.phonebook_name(person),birthday(person)])
motherList.set_row_data(mother_index,person)
mother_index = mother_index + 1
if type == "Partners":
family_window.get_widget("mlabel").set_text(_("Parent"))
family_window.get_widget("flabel").set_text(_("Parent"))
else:
family_window.get_widget("mlabel").set_text(_("Mother"))
family_window.get_widget("flabel").set_text(_("Father"))
motherList.thaw()
fatherList.thaw()
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def on_new_clicked(obj):
msg = _("Do you want to close the current database and create a new one?")
topWindow.question(msg,new_database_response)
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def new_database_response(val):
global active_person, active_father
global active_family, active_mother
global active_child, select_father, select_mother
global id2col,person_list
if val == 1:
return
const.personalEvents = const.initialize_personal_event_list()
const.personalAttributes = const.initialize_personal_attribute_list()
const.marriageEvents = const.initialize_marriage_event_list()
const.familyAttributes = const.initialize_family_attribute_list()
const.familyRelations = const.initialize_family_relation_list()
const.places = []
database.new()
topWindow.set_title("Gramps")
active_person = None
active_father = None
active_family = None
active_mother = None
active_child = None
select_father = None
select_mother = None
id2col = {}
utils.clearModified()
change_active_person(None)
person_list.clear()
load_family()
load_sources()
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def marriage_edit(family):
Marriage.Marriage(family,database)
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def full_update():
gtop.get_widget(NOTEBOOK).set_show_tabs(Config.usetabs)
clist = gtop.get_widget("child_list")
clist.set_column_visibility(4,Config.show_detail)
clist.set_column_visibility(1,Config.id_visible)
apply_filter()
load_family()
load_sources()
load_tree()
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def update_display(changed):
page = gtop.get_widget(NOTEBOOK).get_current_page()
if page == 0:
if changed:
apply_filter()
else:
goto_active_person()
elif page == 1:
load_family()
elif page == 3:
load_sources()
else:
load_tree()
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def load_sources():
source_list.clear()
source_list.freeze()
color_clist = ListColors.ColorList(source_list,1)
current_row = source_list.get_data("i")
if current_row == None:
current_row = -1
index = 0
for src in database.getSourceMap().values():
source_list.append([src.getTitle(),src.getAuthor()])
source_list.set_row_data(index,src)
index = index + 1
if index > 0:
if current_row == -1:
current_row = 0
source_list.select_row(current_row,0)
source_list.moveto(current_row,0)
source_list.set_data("i",current_row)
source_list.thaw()
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def on_source_list_button_press_event(obj,event):
if event.button == 1 and event.type == GDK._2BUTTON_PRESS:
index = obj.get_data("i")
if index == -1:
return
source = obj.get_row_data(index)
EditSource.EditSource(source,database,update_source_after_edit)
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def on_source_list_select_row(obj,a,b,c):
obj.set_data("i",a)
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def on_add_source_clicked(obj):
EditSource.EditSource(Source(),database,new_source_after_edit)
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def on_delete_source_clicked(obj):
pass
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def on_edit_source_clicked(obj):
index = obj.get_data("i")
if index == -1:
return
source = obj.get_row_data(index)
EditSource.EditSource(source,database,update_source_after_edit)
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def new_source_after_edit(source):
database.addSource(source)
update_display(1)
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def update_source_after_edit(source):
update_display(1)
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def on_tools_clicked(obj):
if active_person:
Plugins.ToolPlugins(database,active_person,update_display)
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def on_reports_clicked(obj):
if active_person:
Plugins.ReportPlugins(database,active_person)
#-------------------------------------------------------------------------
#
# Called from the fileselector, when the OK button is pressed (Open
# command). Currently loads a GEDCOM file and destroys the fileselector
# window, which is passed as "obj"
#
#-------------------------------------------------------------------------
def on_ok_button1_clicked(obj):
new_database_response(0)
filename = obj.get_filename()
utils.destroy_passed_object(obj)
if filename != "":
read_file(filename)
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def read_file(filename):
base = os.path.basename(filename)
if base == const.indexFile:
filename = os.path.dirname(filename)
elif not os.path.isdir(filename):
displayError(_("%s is not a directory") % filename)
return
statusbar.set_status(_("Loading %s ...") % filename)
if load_database(filename) == 1:
topWindow.set_title("%s - %s" % (_("Gramps"),filename))
else:
statusbar.set_status("")
Config.save_last_file("")
for person in database.getPersonMap().values():
lastname = person.getPrimaryName().getSurname()
if lastname and lastname not in const.surnames:
const.surnames.append(lastname)
full_update()
statusbar.set_progress(0.0)
#-------------------------------------------------------------------------
#
# Called from the fileselector, when the OK button is pressed (Save
# command). Currently saves a GEDCOM file and destroys the fileselector
# window, which is passed as "obj"
#
#-------------------------------------------------------------------------
def on_ok_button2_clicked(obj):
filename = obj.get_filename()
if filename:
utils.destroy_passed_object(obj)
save_file(filename)
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def save_file(filename):
import WriteXML
filename = os.path.normpath(filename)
if sbar_active:
statusbar.set_status(_("Saving %s ...") % filename)
if os.path.exists(filename):
if os.path.isdir(filename) == 0:
displayError(_("%s is not a directory") % filename)
return
else:
try:
os.mkdir(filename)
except IOError, msg:
GnomeErrorDialog(_("Could not create %s") % filename + "\n" + str(msg))
return
except OSError, msg:
GnomeErrorDialog(_("Could not create %s") % filename + "\n" + str(msg))
return
except:
GnomeErrorDialog(_("Could not create %s") % filename)
return
old_file = filename
filename = filename + os.sep + const.indexFile
try:
WriteXML.exportData(database,filename,load_progress)
except IOError, msg:
GnomeErrorDialog(_("Could not create %s") % filename + "\n" + str(msg))
return
except OSError, msg:
GnomeErrorDialog(_("Could not create %s") % filename + "\n" + str(msg))
return
# except:
# GnomeErrorDialog(_("Could not create %s") % filename)
# return
database.setSavePath(old_file)
utils.clearModified()
Config.save_last_file(old_file)
if sbar_active:
statusbar.set_status("")
statusbar.set_progress(0)
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def find_family(father,mother):
if not father and not mother:
return None
families = database.getFamilyMap().values()
for family in families:
if family.getFather() == father and family.getMother() == mother:
return family
family = database.newFamily()
family.setFather(father)
family.setMother(mother)
if father:
father.addFamily(family)
if mother:
mother.addFamily(family)
return family
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def change_family_type(family,mrel,frel):
is_main = mrel == "Birth" and frel == "Birth"
if not family:
if is_main:
main = active_person.getMainFamily()
if main:
main.removeChild(active_person)
active_person.setMainFamily(None)
else:
for fam in active_person.getAltFamilyList():
if is_main:
active_person.removeAltFamily(fam[0])
fam.removeChild(active_person)
return
elif family == active_person.getMainFamily():
if is_main:
utils.modified()
active_person.setMainFamily(None)
found = 0
for fam in active_person.getAltFamilyList():
if fam[0] == family:
fam[1] = type
found = 1
elif fam[1] == type:
fam[0] = family
found = 1
if found == 0:
active_person.addAltFamily(family,mrel,frel)
else:
for fam in active_person.getAltFamilyList():
if family == fam[0]:
if is_main:
active_person.setMainFamily(family)
active_person.removeAltFamily(family)
utils.modified()
return
if mrel != fam[1] or frel != fam[2]:
active_person.removeAltFamily(family)
active_person.addAltFamily(family,mrel,frel)
utils.modified()
return
active_person.addAltFamily(family,mrel,frel)
utils.modified()
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def on_save_parents_clicked(obj):
global active_father
global active_mother
global active_family
mrel = family_window.get_widget("mrel").get_text()
frel = family_window.get_widget("frel").get_text()
type = family_window.get_widget("prel").get_text()
if select_father or select_mother:
if select_mother.getGender() == Person.male and \
select_father.getGender() == Person.female:
x = select_mother
select_mother = select_father
select_father = x
type = "Unknown"
elif select_mother.getGender() != select_father.getGender():
if type == "Partners":
type = "Unknown"
else:
type = "Partners"
family = find_family(select_father,select_mother)
else:
family = None
family.setRelationship(type)
change_family_type(family,mrel,frel)
active_mother = select_mother
active_father = select_father
active_family = family
utils.destroy_passed_object(obj)
load_family()
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def on_select_spouse_clicked(obj):
global active_spouse
global select_spouse
global active_family
# check to make sure that the person is not already listed as a
# spouse
for f in active_person.getFamilyList():
if select_spouse == f.getMother() or select_spouse == f.getFather():
utils.destroy_passed_object(obj)
return
utils.modified()
active_spouse = select_spouse
family = database.newFamily()
active_family = family
active_person.addFamily(family)
select_spouse.addFamily(family)
if active_person == Person.male:
family.setMother(select_spouse)
family.setFather(active_person)
else:
family.setFather(select_spouse)
family.setMother(active_person)
family.setRelationship(const.save_frel(obj.get_data("d").get_text()))
select_spouse = None
utils.destroy_passed_object(obj)
load_family()
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def on_edit_active_person(obj):
if active_person:
load_person(active_person)
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def on_edit_spouse_clicked(obj):
if active_spouse:
load_person(active_spouse)
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def on_edit_mother_clicked(obj):
if active_mother:
load_person(active_mother)
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def on_edit_father_clicked(obj):
if active_father:
load_person(active_father)
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def on_addperson_clicked(obj):
load_person(None)
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def on_delete_person_clicked(obj):
if not active_person:
return
topWindow.question(_("Do you really wish to delete %s?") % \
Config.nameof(active_person), delete_person_response)
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def delete_person_response(val):
if val == 1:
return
personmap = database.getPersonMap()
familymap = database.getPersonMap()
for family in active_person.getFamilyList():
if active_person.getGender == Person.male:
if family.getMother() == None:
for child in family.getChildList():
child.setMainFamily(None)
del familymap[family]
else:
family.setFather(None)
else:
if family.getFather() == None:
for child in family.getChildList():
child.setMainFamily(None)
del familymap[family]
else:
family.setMother(None)
family = active_person.getMainFamily()
if family:
family.removeChild(active_person)
del personmap[active_person.getId()]
apply_filter()
utils.modified()
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def on_editperson_clicked(obj):
load_person(active_person)
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def add_spouse():
spouseDialog = libglade.GladeXML(const.gladeFile, "spouseDialog")
spouseList = spouseDialog.get_widget("spouseList")
spouseDialog.get_widget("rel_combo").set_popdown_strings(const.familyRelations)
rel_type = spouseDialog.get_widget("rel_type")
rel_type.set_data("d",spouseList)
spouseDialog.get_widget("spouseDialog").set_data("d",rel_type)
spouseDialog.signal_autoconnect({
"on_spouseList_select_row" : on_spouseList_select_row,
"on_select_spouse_clicked" : on_select_spouse_clicked,
"on_rel_type_changed" : on_rel_type_changed,
"destroy_passed_object" : utils.destroy_passed_object
})
rel_type.set_text(_("Unknown"))
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def on_rel_type_changed(obj):
nameList = database.getPersonMap().values()
nameList.sort(sort.by_last_name)
spouse_list = obj.get_data("d")
spouse_list.clear()
spouse_list.freeze()
text = obj.get_text()
gender = active_person.getGender()
if text == _("Partners"):
if gender == Person.male:
gender = Person.female
else:
gender = Person.male
index = 0
for person in nameList:
if person.getGender() == gender:
continue
spouse_list.append([person.getPrimaryName().getName(),birthday(person)])
spouse_list.set_row_data(index,person)
index = index + 1
spouse_list.thaw()
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def on_delete_parents_clicked(obj):
if not active_parents:
return
active_parents.removeChild(active_person)
if active_parents == active_person.getMainFamily():
active_person.setMainFamily(None)
else:
active_person.removeAltFamily(active_parents)
load_family()
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def delete_spouse():
global active_family
if active_person == active_family.getFather():
person = active_family.getMother()
if person:
person.removeFamily(active_family)
if len(active_family.getChildList()) == 0:
active_person.removeFamily(active_family)
database.deleteFamily(active_family)
if len(active_person.getFamilyList()) > 0:
active_family = active_person.getFamilyIndex(0)
else:
active_family = None
else:
active_family.setMother(None)
else:
person = active_family.getFather()
if person:
person.removeFamily(active_family)
if len(active_family.getChildList()) == 0:
active_person.removeFamily(active_family)
database.deleteFamily(active_family)
if len(active_person.getFamilyList()) > 0:
active_family = active_person.getFamilyIndex(0)
else:
active_family = None
else:
active_family.setFather(None)
load_family()
utils.modified()
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def on_person_list_select_row(obj,a,b,c):
person = obj.get_row_data(a)
obj.set_data("a",person)
change_active_person(person)
#-------------------------------------------------------------------------
#
# on_person_list_click_column
#
# Called when the user selects a column header on the person_list window.
# Change the sort function (column 0 is the name column, and column 2 is
# the birthdate column), set the arrows on the labels to the correct
# orientation, and then call apply_filter to redraw the list
#
#-------------------------------------------------------------------------
def on_person_list_click_column(obj,column):
global sortFunc
nameArrow = gtop.get_widget("nameSort")
dateArrow = gtop.get_widget("dateSort")
deathArrow= gtop.get_widget("deathSort")
if column == 0:
dateArrow.hide()
deathArrow.hide()
nameArrow.show()
if sortFunc != sort.fast_name_sort:
sortFunc = sort.fast_name_sort
nameArrow.set(GTK.ARROW_DOWN,2)
else:
sortFunc = sort.reverse_name_sort
nameArrow.set(GTK.ARROW_UP,2)
elif column == 3:
nameArrow.hide()
deathArrow.hide()
dateArrow.show()
if sortFunc != sort.fast_birth_sort:
sortFunc = sort.fast_birth_sort
dateArrow.set(GTK.ARROW_DOWN,2)
else:
sortFunc = sort.reverse_birth_sort
dateArrow.set(GTK.ARROW_UP,2)
elif column == 4:
nameArrow.hide()
deathArrow.show()
dateArrow.hide()
if sortFunc != sort.fast_death_sort:
sortFunc = sort.fast_death_sort
deathArrow.set(GTK.ARROW_DOWN,2)
else:
sortFunc = sort.reverse_death_sort
deathArrow.set(GTK.ARROW_UP,2)
else:
return
apply_filter()
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def on_fatherList_select_row(obj,a,b,c):
global select_father
select_father = obj.get_row_data(a)
obj.get_data("father_text").set_text(Config.nameof(select_father))
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def on_addChild_select_row(obj,a,b,c):
select_child_list[obj.get_row_data(a)] = 1
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def on_addChild_unselect_row(obj,a,b,c):
del select_child_list[obj.get_row_data(a)]
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def on_motherList_select_row(obj,a,b,c):
global select_mother
select_mother = obj.get_row_data(a)
obj.get_data("mother_text").set_text(Config.nameof(select_mother))
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def on_child_list_button_press_event(obj,event):
if event.button == 1 and event.type == GDK._2BUTTON_PRESS:
if active_child:
load_person(active_child)
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def on_person_list_button_press(obj,event):
if event.button == 1 and event.type == GDK._2BUTTON_PRESS:
load_person(active_person)
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def change_active_person(person):
global active_person
active_person = person
modify_statusbar()
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def modify_statusbar():
if active_person == None:
statusbar.set_status("")
else:
pname = Config.nameof(active_person)
if Config.status_bar == 1:
name = "[%s] %s" % (active_person.getId(),pname)
elif Config.status_bar == 2:
name = pname
for attr in active_person.getAttributeList():
if attr.getType() == Config.attr_name:
name = "[%s] %s" % (attr.getValue(),pname)
break
else:
name = pname
statusbar.set_status(name)
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def on_child_list_select_row(obj,a,b,c):
global active_child
active_child = obj.get_row_data(a)
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def on_spouseList_select_row(obj,a,b,c):
global select_spouse
select_spouse = obj.get_row_data(a)
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def on_new_person_activate(obj):
load_person(None)
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def on_open_activate(obj):
wFs = libglade.GladeXML (const.gladeFile, FILESEL)
wFs.signal_autoconnect({
"on_ok_button1_clicked": on_ok_button1_clicked,
"destroy_passed_object": utils.destroy_passed_object
})
fileSelector = wFs.get_widget(FILESEL)
fileSelector.set_filename(Config.db_dir)
fileSelector.show()
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def on_revert_activate(obj):
if database.getSavePath() != "":
msg = _("Do you wish to abandon your changes and revert to the last saved database?")
topWindow.question(msg,revert_query)
else:
msg = _("Cannot revert to a previous database, since one does not exist")
topWindow.warning(msg)
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def revert_query(value):
if value == 0:
const.places = []
const.personalEvents = const.initialize_personal_event_list()
const.personalAttributes = const.initialize_personal_attribute_list()
const.marriageEvents = const.initialize_marriage_event_list()
const.familyAttributes = const.initialize_family_attribute_list()
const.familyRelations = const.initialize_family_relation_list()
file = database.getSavePath()
database.new()
read_file(file)
utils.clearModified()
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def on_save_as_activate(obj):
wFs = libglade.GladeXML (const.gladeFile, FILESEL)
wFs.signal_autoconnect({
"on_ok_button1_clicked": on_ok_button2_clicked,
"destroy_passed_object": utils.destroy_passed_object
})
fileSelector = wFs.get_widget(FILESEL)
fileSelector.show()
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def on_save_activate(obj):
if not database.getSavePath():
on_save_as_activate(obj)
else:
save_file(database.getSavePath())
#-------------------------------------------------------------------------
#
# Switch notebook pages from menu
#
#-------------------------------------------------------------------------
def on_person_list1_activate(obj):
notebk = gtop.get_widget(NOTEBOOK)
notebk.set_page(0)
def on_family1_activate(obj):
notebk = gtop.get_widget(NOTEBOOK)
notebk.set_page(1)
def on_pedegree1_activate(obj):
notebk = gtop.get_widget(NOTEBOOK)
notebk.set_page(2)
def on_sources_activate(obj):
notebk = gtop.get_widget(NOTEBOOK)
notebk.set_page(3)
#-------------------------------------------------------------------------
#
# Load the appropriate page after a notebook switch
#
#-------------------------------------------------------------------------
def on_notebook1_switch_page(obj,junk,page):
if not active_person:
return
if page == 0:
if id2col.has_key(active_person):
column = id2col[active_person]
person_list.select_row(column,0)
person_list.moveto(column,0)
elif page == 1:
load_family()
elif page == 2:
load_tree()
elif page == 3:
load_sources()
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def on_pv_button_press_event(obj,event):
if event.button == 1 and event.type == GDK._2BUTTON_PRESS:
person = obj.get_data("p")
if person == None:
return
load_person(person)
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def on_pv_n0_clicked(obj):
family = active_person.getMainFamily()
if family:
father = family.getFather()
if father:
change_active_person(father)
load_tree()
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def on_pv_n1_clicked(obj):
family = active_person.getMainFamily()
if family:
mother = family.getMother()
if mother:
change_active_person(mother)
load_tree()
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def on_arrow_left_clicked(obj):
if active_person:
myMenu = GtkMenu()
for family in active_person.getFamilyList():
for child in family.getChildList():
menuitem = GtkMenuItem(Config.nameof(child))
myMenu.append(menuitem)
menuitem.set_data("person",child)
menuitem.connect("activate",on_childmenu_changed)
menuitem.show()
myMenu.popup(None,None,None,0,0)
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def on_childmenu_changed(obj):
person = obj.get_data("person")
if person == None:
return
change_active_person(person)
load_tree()
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def on_mother_next_clicked(obj):
if active_parents:
mother = active_parents.getMother()
if mother:
change_active_person(mother)
obj.set_sensitive(1)
load_family()
else:
obj.set_sensitive(0)
else:
obj.set_sensitive(0)
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def on_father_next_clicked(obj):
if active_parents:
father = active_parents.getFather()
if father:
change_active_person(father)
obj.set_sensitive(1)
load_family()
else:
obj.set_sensitive(0)
else:
obj.set_sensitive(0)
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def on_fv_prev_clicked(obj):
if active_child:
change_active_person(active_child)
load_family()
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def on_swap_clicked(obj):
if not active_person:
return
if len(active_person.getFamilyList()) > 1:
spouse = gtop.get_widget("fv_spouse").get_menu().get_active().get_data("person")
else:
spouse = gtop.get_widget("fv_spouse1").get_data("person")
if not spouse:
return
change_active_person(spouse)
load_family()
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def on_apply_filter_clicked(obj):
global DataFilter
invert_filter = gtop.get_widget("invert").get_active()
qualifer = gtop.get_widget("filter").get_text()
menu = gtop.get_widget(FILTERNAME).get_menu()
function = menu.get_active().get_data("filter")
DataFilter = function(qualifer)
DataFilter.set_invert(invert_filter)
apply_filter()
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def on_filter_name_changed(obj):
function = obj.get_data("function")
gtop.get_widget("filter").set_sensitive(function())
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def on_spouselist_changed(obj):
if active_person == None :
return
display_marriage(obj.get_data("family"))
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def new_after_edit(person):
database.addPerson(person.person)
update_display(1)
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def update_after_edit(person):
update_display(1)
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def load_person(person):
if person == None:
EditPerson.EditPerson(Person(),database,new_after_edit)
else:
EditPerson.EditPerson(person,database,update_after_edit)
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def load_family():
global active_mother
global active_parents
global active_spouse
family_types = []
main_family = None
gtop.get_widget("fv_person").set_text(Config.nameof(active_person))
if active_person:
main_family = active_person.getMainFamily()
active_parents = main_family
family_types = active_person.getAltFamilyList()
if active_parents == None and len(family_types) > 0:
fam = family_types[0]
active_parents = fam[0]
else:
active_parents = None
if len(family_types) > 0:
typeMenu = GtkMenu()
if main_family:
menuitem = GtkMenuItem("Birth")
menuitem.set_data("parents",main_family)
menuitem.connect("activate",on_current_type_changed)
menuitem.show()
typeMenu.append(menuitem)
for fam in family_types:
if active_person == fam[0].getFather():
menuitem = GtkMenuItem("%s/%s" % (fam[1],fam[2]))
else:
menuitem = GtkMenuItem("%s/%s" % (fam[2],fam[1]))
menuitem.set_data("parents",fam[0])
menuitem.connect("activate",on_current_type_changed)
menuitem.show()
typeMenu.append(menuitem)
gtop.get_widget("childtype").set_menu(typeMenu)
gtop.get_widget("childtype").show()
else:
gtop.get_widget("childtype").hide()
change_parents(active_parents)
if active_person:
number_of_families = len(active_person.getFamilyList())
if number_of_families > 1:
myMenu = GtkMenu()
if active_person != None:
for family in active_person.getFamilyList():
person = None
if family.getMother() == active_person:
if family.getFather() != None:
person = family.getFather()
else:
if family.getMother() != None:
person = family.getMother()
menuitem = GtkMenuItem(Config.nameof(person))
myMenu.append(menuitem)
menuitem.set_data("person",person)
menuitem.set_data("family",family)
menuitem.connect("activate",on_spouselist_changed)
menuitem.show()
gtop.get_widget("fv_spouse").set_menu(myMenu)
gtop.get_widget("lab_or_list").set_page(1)
gtop.get_widget("edit_sp").set_sensitive(1)
gtop.get_widget("delete_sp").set_sensitive(1)
elif number_of_families == 1:
gtop.get_widget("lab_or_list").set_page(0)
family = active_person.getFamilyList()[0]
if active_person != family.getFather():
spouse = family.getFather()
else:
spouse = family.getMother()
active_spouse = spouse
fv_spouse1 = gtop.get_widget("fv_spouse1")
fv_spouse1.set_text(Config.nameof(spouse))
fv_spouse1.set_data("person",spouse)
fv_spouse1.set_data("family",active_person.getFamilyList()[0])
gtop.get_widget("edit_sp").set_sensitive(1)
gtop.get_widget("delete_sp").set_sensitive(1)
else:
gtop.get_widget("lab_or_list").set_page(0)
gtop.get_widget("fv_spouse1").set_text("")
fv_spouse1 = gtop.get_widget("fv_spouse1")
fv_spouse1.set_text("")
fv_spouse1.set_data("person",None)
fv_spouse1.set_data("family",None)
active_spouse = None
gtop.get_widget("edit_sp").set_sensitive(0)
gtop.get_widget("delete_sp").set_sensitive(0)
if number_of_families > 0:
display_marriage(active_person.getFamilyList()[0])
else:
display_marriage(None)
else:
fv_spouse1 = gtop.get_widget("fv_spouse1").set_text("")
display_marriage(None)
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def change_parents(family):
global active_father
global active_mother
fn = _("Father")
mn = _("Mother")
if active_parents and active_parents.getRelationship() == "Partners":
fn = _("Parent")
mn = _("Parent")
gtop.get_widget("editFather").children()[0].set_text(fn)
gtop.get_widget("editMother").children()[0].set_text(mn)
fv_father = gtop.get_widget("fv_father")
fv_mother = gtop.get_widget("fv_mother")
father_next = gtop.get_widget("father_next")
mother_next = gtop.get_widget("mother_next")
if family != None :
active_father = family.getFather()
if active_father != None :
fv_father.set_text(Config.nameof(active_father))
father_next.set_sensitive(1)
else :
fv_father.set_text("")
father_next.set_sensitive(0)
active_mother = family.getMother()
if active_mother != None :
fv_mother.set_text(Config.nameof(active_mother))
mother_next.set_sensitive(1)
else :
fv_mother.set_text("")
mother_next.set_sensitive(0)
elif active_person == None :
fv_father.set_text("")
fv_mother.set_text("")
mother_next.set_sensitive(0)
father_next.set_sensitive(0)
active_father = None
active_mother = None
else :
fv_father.set_text("")
fv_mother.set_text("")
mother_next.set_sensitive(0)
father_next.set_sensitive(0)
active_father = None
active_mother = None
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def load_tree():
text = {}
tip = {}
for i in range(1,16):
text[i] = ("",None)
tip[i] = ""
load_tree_values(active_person,1,16,text,tip)
tips = GtkTooltips()
for i in range(1,16):
pv[i].set_text(text[i][0])
pv[i].set_position(0)
pv[i].set_data("p",text[i][1])
if tip[i] != "":
tips.set_tip(pv[i],tip[i])
else:
tips.set_tip(pv[i],None)
if text[2] == "":
gtop.get_widget("ped_father_next").set_sensitive(0)
else:
gtop.get_widget("ped_father_next").set_sensitive(1)
if text[3] == "":
gtop.get_widget("ped_mother_next").set_sensitive(0)
else:
gtop.get_widget("ped_mother_next").set_sensitive(1)
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def load_tree_values(person,index,max,pv_text,tip):
if person == None:
return
msg = Config.nameof(person)
bdate = person.getBirth().getDate()
ddate = person.getDeath().getDate()
if bdate and ddate:
text = "%s\nb. %s\nd. %s" % (msg, bdate,ddate)
elif bdate and not ddate:
text = "%s\nb. %s" % (msg, bdate)
elif not bdate and ddate:
text = "%s\nb. %s" % (msg, ddate)
else:
text = msg
tip[index] = text
pv_text[index] = (msg,person)
if 2*index+1 < max:
family = person.getMainFamily()
if family != None:
load_tree_values(family.getFather(),2*index,max,pv_text,tip)
load_tree_values(family.getMother(),(2*index)+1,max,pv_text,tip)
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def display_marriage(family):
global active_child
global active_family
global active_spouse
active_family = family
clist = gtop.get_widget("child_list")
fv_prev = gtop.get_widget("fv_prev")
clist.clear()
active_child = None
active_fams = family
i = 0
if family != None:
if active_person.getGender() == Person.male:
active_spouse = family.getMother()
else:
active_spouse = family.getFather()
child_list = family.getChildList()
child_list.sort(sort.by_birthdate)
attr = ""
for child in child_list:
status = _("Unknown")
if child.getGender():
gender = const.male
else:
gender = const.female
if child.getMainFamily() == family:
status = _("Birth")
else:
for fam in child.getAltFamilyList():
if fam[0] == family:
if active_person == family.getFather():
status = "%s/%s" % (_(fam[2]),_(fam[1]))
else:
status = "%s/%s" % (_(fam[1]),_(fam[2]))
if Config.show_detail:
attr = ""
if child.getNote() != "":
attr = attr + "N"
if len(child.getEventList())>0:
attr = attr + "E"
if len(child.getAttributeList())>0:
attr = attr + "A"
if len(child.getFamilyList()) > 0:
for f in child.getFamilyList():
if f.getFather() and f.getMother():
attr = attr + "M"
break
if len(child.getPhotoList()) > 0:
attr = attr + "P"
clist.append([Config.nameof(child),child.getId(),\
gender,birthday(child),status,attr])
clist.set_row_data(i,child)
i=i+1
if i != 0:
fv_prev.set_sensitive(1)
clist.select_row(0,0)
else:
fv_prev.set_sensitive(0)
else:
fv_prev.set_sensitive(0)
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def load_progress(value):
if sbar_active:
statusbar.set_progress(value)
while events_pending():
mainiteration()
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def load_database(name):
import ReadXML
global active_person
filename = name + os.sep + const.indexFile
if ReadXML.loadData(database,filename,load_progress) == 0:
return 0
database.setSavePath(name)
res = database.getResearcher()
if res.getName() == "" and Config.owner.getName() != "":
database.setResearcher(Config.owner)
utils.modified()
setup_bookmarks()
mylist = database.getPersonEventTypes()
for type in mylist:
ntype = const.display_pevent(type)
if ntype not in const.personalEvents:
const.personalEvents.append(ntype)
const.places = database.getPlaces()
const.places.sort()
mylist = database.getFamilyEventTypes()
for type in mylist:
ntype = const.display_fevent(type)
if ntype not in const.marriageEvents:
const.marriageEvents.append(ntype)
mylist = database.getPersonAttributeTypes()
for type in mylist:
ntype = const.display_pattr(type)
if ntype not in const.personalAttributes:
const.personalAttributes.append(ntype)
mylist = database.getFamilyAttributeTypes()
for type in mylist:
if type not in const.familyAttributes:
const.familyAttributes.append(type)
mylist = database.getFamilyRelationTypes()
for type in mylist:
if type not in const.familyRelations:
const.familyRelations.append(type)
Config.save_last_file(name)
gtop.get_widget("filter").set_text("")
active_person = database.getDefaultPerson()
return 1
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def setup_bookmarks():
global bookmarks
menu = gtop.get_widget("jump_to")
person_map = database.getPersonMap()
bookmarks = Bookmarks.Bookmarks(database.getBookmarks(),person_map,\
menu,bookmark_callback)
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def displayError(msg):
topWindow.error(msg)
statusbar.set_status("")
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def apply_filter():
people = database.getPersonMap().values()
names = []
altnames = []
for person in people:
names.append((person.getPrimaryName(),person,0))
for name in person.getAlternateNames():
altnames.append((name,person,1))
if Config.hide_altnames == 0:
names = names + altnames
names = sortFunc(names)
person_list.freeze()
person_list.clear()
color_clist = ListColors.ColorList(person_list,1)
i=0
datacomp = DataFilter.compare
clistadd = color_clist.add_with_data
gname = utils.phonebook_from_name
person_list.set_column_visibility(1,Config.id_visible)
for name_tuple in names:
person = name_tuple[1]
alt = name_tuple[2]
name = name_tuple[0]
if datacomp(person):
if not alt:
id2col[person] = i
if person.getGender():
gender = const.male
else:
gender = const.female
bday = person.getBirth().getQuoteDate()
dday = person.getDeath().getQuoteDate()
clistadd([gname(name,alt),person.getId(), gender,bday, dday],\
person)
i = i + 1
person_list.thaw()
if i > 0:
goto_active_person()
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def goto_active_person():
if id2col.has_key(active_person):
column = id2col[active_person]
person_list.select_row(column,0)
person_list.moveto(column,0)
else:
person_list.select_row(0,0)
person_list.moveto(0,0)
person = person_list.get_row_data(0)
change_active_person(person)
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def on_home_clicked(obj):
temp = database.getDefaultPerson()
if temp:
change_active_person(temp)
update_display(0)
else:
topWindow.error(_("No default/home person has been set"))
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def on_add_bookmark_activate(obj):
bookmarks.add(active_person)
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def on_edit_bookmarks_activate(obj):
bookmarks.edit()
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def on_default_person_activate(obj):
if active_person:
name = active_person.getPrimaryName().getRegularName()
topWindow.question(_("Do you wish to set %s as the home person?") % name, \
set_person)
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def set_person(value):
if not value:
database.setDefaultPerson(active_person)
utils.modified()
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def on_current_type_changed(obj):
global active_parents
active_parents = obj.get_data("parents")
change_parents(active_parents)
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def on_statusbar_unmap(obj):
global sbar_active
sbar_active = 0
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def export_callback(obj,plugin_function):
if active_person:
plugin_function(database,active_person)
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def import_callback(obj,plugin_function):
plugin_function(database,active_person,update_display)
topWindow.set_title("Gramps - " + database.getSavePath())
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def bookmark_callback(obj,person):
change_active_person(person)
update_display(0)
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def on_preferences_activate(obj):
Config.display_preferences_box()
#-------------------------------------------------------------------------
#
# Main program
#
#-------------------------------------------------------------------------
def main(arg):
global database, gtop
global statusbar
global person_list, source_list, pv
global topWindow
import ReadXML
rc_parse(const.gtkrcFile)
Plugins.load_plugins(const.pluginsDir)
Filter.load_filters(const.filtersDir)
path = os.path.expanduser("~/.gramps/plugins")
if os.path.isdir(path):
Plugins.load_plugins(path)
path = os.path.expanduser("~/.gramps/filters")
if os.path.isdir(path):
Filter.load_filters(path)
gtop = libglade.GladeXML(const.gladeFile, "gramps")
statusbar = gtop.get_widget("statusbar")
topWindow = gtop.get_widget("gramps")
person_list = gtop.get_widget("person_list")
source_list = gtop.get_widget("source_list")
filter_list = gtop.get_widget("filter_list")
myMenu = GtkMenu()
for filter in Filter.filterList:
menuitem = GtkMenuItem(filter)
myMenu.append(menuitem)
menuitem.set_data("filter",Filter.filterMap[filter])
menuitem.set_data("function",Filter.filterEnb[filter])
menuitem.connect("activate",on_filter_name_changed)
menuitem.show()
filter_list.set_menu(myMenu)
gtop.get_widget("filter").set_sensitive(0)
# set the window icon
topWindow.set_icon(GtkPixmap(topWindow,const.logo))
person_list.column_titles_active()
for box in range(1,16):
pv[box] = gtop.get_widget("pv%d" % box)
gtop.signal_autoconnect({
"on_about_activate": on_about_activate,
"on_reports_clicked" : on_reports_clicked,
"on_person_list1_activate": on_person_list1_activate,
"on_family1_activate" : on_family1_activate,
"on_sources_activate" : on_sources_activate,
"on_pedegree1_activate" : on_pedegree1_activate,
"on_notebook1_switch_page": on_notebook1_switch_page,
"on_ok_button1_clicked": on_ok_button1_clicked,
"on_father_next_clicked": on_father_next_clicked,
"on_mother_next_clicked": on_mother_next_clicked,
"on_person_list_select_row": on_person_list_select_row,
"on_person_list_click_column": on_person_list_click_column,
"on_person_list_button_press": on_person_list_button_press,
"destroy_passed_object": utils.destroy_passed_object,
"on_swap_clicked" : on_swap_clicked,
"on_child_list_button_press_event" : on_child_list_button_press_event,
"on_child_list_select_row" : on_child_list_select_row,
"on_fv_prev_clicked" : on_fv_prev_clicked,
"on_delete_parents_clicked" : on_delete_parents_clicked,
"on_contents_activate" : on_contents_activate,
"on_choose_parents_clicked" : on_choose_parents_clicked,
"on_spouselist_changed" : on_spouselist_changed,
"on_home_clicked" : on_home_clicked,
"on_default_person_activate" : on_default_person_activate,
"on_pv_n0_clicked" : on_pv_n0_clicked,
"on_pv_n1_clicked" : on_pv_n1_clicked,
"on_apply_filter_clicked": on_apply_filter_clicked,
"on_save_as_activate" : on_save_as_activate,
"on_add_new_child_clicked" : on_add_new_child_clicked,
"on_tools_clicked" : on_tools_clicked,
"on_save_activate" : on_save_activate,
"on_revert_activate" : on_revert_activate,
"on_add_child_clicked" : on_add_child_clicked,
"on_edit_sp_clicked" : on_edit_sp_clicked,
"on_add_sp_clicked" : on_add_sp_clicked,
"on_delete_sp_clicked" : on_delete_sp_clicked,
"on_remove_child_clicked" : on_remove_child_clicked,
"on_new_clicked" : on_new_clicked,
"on_add_bookmark_activate" : on_add_bookmark_activate,
"on_arrow_left_clicked" : on_arrow_left_clicked,
"on_addperson_clicked" : on_addperson_clicked,
"on_delete_person_clicked" : on_delete_person_clicked,
"on_preferences_activate" : on_preferences_activate,
"on_pv_button_press_event" : on_pv_button_press_event,
"on_edit_bookmarks_activate" : on_edit_bookmarks_activate,
"on_edit_active_person" : on_edit_active_person,
"on_edit_spouse_clicked" : on_edit_spouse_clicked,
"on_edit_father_clicked" : on_edit_father_clicked,
"on_edit_mother_clicked" : on_edit_mother_clicked,
"on_exit_activate" : on_exit_activate,
"on_statusbar_unmap" : on_statusbar_unmap,
"on_add_source_clicked" : on_add_source_clicked,
"on_source_list_button_press_event" : on_source_list_button_press_event,
"on_source_list_select_row": on_source_list_select_row,
"on_delete_source_clicked" : on_delete_source_clicked,
"on_edit_source_clicked" : on_edit_source_clicked,
"delete_event" : delete_event,
"on_open_activate" : on_open_activate
})
database = RelDataBase()
Config.loadConfig(full_update)
person_list.set_column_visibility(1,Config.id_visible)
gtop.get_widget(NOTEBOOK).set_show_tabs(Config.usetabs)
gtop.get_widget("child_list").set_column_visibility(4,Config.show_detail)
if arg != None:
read_file(arg)
elif Config.lastfile != None and Config.lastfile != "" and Config.autoload:
read_file(Config.lastfile)
gtop.get_widget("export1").set_submenu(Plugins.export_menu(export_callback))
gtop.get_widget("import1").set_submenu(Plugins.import_menu(import_callback))
database.setResearcher(Config.owner)
mainloop()
#-------------------------------------------------------------------------
#
# Start it all
#
#-------------------------------------------------------------------------
if __name__ == '__main__':
main(None)
Reference in New Issue View Git Blame Copy Permalink