Cyclone-Team/gramps
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Improved text, enhanced event comparison to load/save complex filters

Browse Source 
svn: r514
This commit is contained in:
Don Allingham
2001-10-28 23:28:38 +00:00
parent 6be70630d2
commit 28cf95c4d7
10 changed files with 633 additions and 565 deletions
Download Patch File Download Diff File Expand all files Collapse all files

695
src/plugins/EventCmp.py
View File

@ -22,7 +22,7 @@
#------------------------------------------------------------------------
#
#
# Module imports
#
#------------------------------------------------------------------------
import os
@ -30,6 +30,14 @@ import re
import sort
import utils
import string
from gtk import *
from gnome.ui import *
from libglade import *
import ListColors
import Filter
import const
from TextDoc import *
from OpenSpreadSheet import *
import intl
_ = intl.gettext
@ -39,30 +47,7 @@ _ = intl.gettext
#
#
#------------------------------------------------------------------------
from gtk import *
from gnome.ui import *
from libglade import *
#------------------------------------------------------------------------
#
#
#
#------------------------------------------------------------------------
import ListColors
import Filter
import const
from TextDoc import *
from OpenSpreadSheet import *
#------------------------------------------------------------------------
#
#
#
#------------------------------------------------------------------------
OBJECT = "o"
INDEX = "i"
FILTER = "filter"
FUNCTION = "function"
QUALIFIER= "qual"
@ -79,11 +64,6 @@ class TableReport:
self.filename = filename
self.doc = doc
#--------------------------------------------------------------------
#
#
#
#--------------------------------------------------------------------
def initialize(self,cols):
t = TableStyle()
@ -112,20 +92,10 @@ class TableReport:
self.doc.open(self.filename)
self.doc.start_page("Page 1","mytbl")
#--------------------------------------------------------------------
#
#
#
#--------------------------------------------------------------------
def finalize(self):
self.doc.end_page()
self.doc.close()
#--------------------------------------------------------------------
#
#
#
#--------------------------------------------------------------------
def write_table_data(self,data):
length = len(data)
@ -136,19 +106,9 @@ class TableReport:
self.doc.end_cell()
self.doc.end_row()
#--------------------------------------------------------------------
#
#
#
#--------------------------------------------------------------------
def set_row(self,val):
self.row = val + 2
#--------------------------------------------------------------------
#
#
#
#--------------------------------------------------------------------
def write_table_head(self,data):
length = len(data)
self.prev = 3
@ -167,25 +127,24 @@ class TableReport:
#------------------------------------------------------------------------
class EventComparison:
#------------------------------------------------------------------------
#
#
#
#------------------------------------------------------------------------
def __init__(self,database):
self.db = database
base = os.path.dirname(__file__)
self.glade_file = base + os.sep + "eventcmp.glade"
self.qual = 0
xml = os.path.expanduser("~/.gramps/eventcmp.xml")
self.interface = ComplexFilterFile(xml)
self.filterDialog = GladeXML(self.glade_file,"filters")
self.filterDialog.signal_autoconnect({
"on_add_clicked": on_add_clicked,
"on_delete_clicked":on_delete_clicked,
"on_select_row" : on_select_row,
"on_filter_save_clicked" : on_filter_save_clicked,
"on_apply_clicked":on_apply_clicked,
"destroy_passed_object" : utils.destroy_passed_object
"on_add_clicked" : self.on_add_clicked,
"on_delete_clicked" : self.on_delete_clicked,
"on_filter_save_clicked" : self.on_filter_save_clicked,
"on_filter_load_clicked" : self.on_filter_load_clicked,
"on_apply_clicked" : self.on_apply_clicked,
"destroy_passed_object" : utils.destroy_passed_object
})
top =self.filterDialog.get_widget("filters")
@ -193,51 +152,290 @@ class EventComparison:
self.filter_list_obj = self.filterDialog.get_widget("active_filters")
qualifier = self.filterDialog.get_widget("qualifier")
self.filter_list_obj.set_data(INDEX,-1)
self.filter_list_obj.set_data(OBJECT,self)
self.filter_list = []
myMenu = Filter.build_filter_menu(on_filter_name_changed,qualifier)
myMenu = Filter.build_filter_menu(self.on_filter_name_changed,qualifier)
self.filter_menu.set_menu(myMenu)
top.set_data(OBJECT,self)
top.show()
#------------------------------------------------------------------------
#
#
#
#------------------------------------------------------------------------
def display_results(self):
def on_apply_clicked(self,obj):
my_list = []
for person in self.db.getPersonMap().values():
match = 1
for filter in self.filter_list:
if not filter.compare(person):
match = 0
if match == 1:
break
else:
my_list.append(person)
if len(my_list) == 0:
GnomeWarningDialog("No matches were found")
return
else:
DisplayChart(my_list)
self.topDialog = GladeXML(self.glade_file,"top")
def on_delete_clicked(self,obj):
if len(self.filter_list_obj.selection) != 1:
return
row = self.filter_list_obj.selection[0]
self.filter_list_obj.remove(row)
self.filter_list_obj.unselect_all()
del self.filter_list[row]
def on_add_clicked(self,obj):
invert = self.filterDialog.get_widget("invert").get_active()
qwidget = self.filterDialog.get_widget("qualifier")
if self.qual:
qualifier = qwidget.get_text()
else:
qualifier = ""
menu = self.filter_menu.get_menu()
function = menu.get_active().get_data(FUNCTION)
name = menu.get_active().get_data(NAME)
myfilter = function(qualifier)
myfilter.set_invert(invert)
self.filter_list.append(myfilter)
if invert:
invert_text = "yes"
else:
invert_text = "no"
self.filter_list_obj.append([name,qualifier,invert_text])
def on_filter_save_clicked(self,obj):
self.load_dialog = GladeXML(self.glade_file,"filter_file")
self.filter_combo = self.load_dialog.get_widget("filter_combo")
self.load_dialog.get_widget("title").set_text("Save complex filter")
names = self.interface.get_filter_names()
if len(names) > 0:
self.filter_combo.set_popdown_strings(names)
self.load_dialog.signal_autoconnect({
"destroy_passed_object" : utils.destroy_passed_object,
"combo_insert_text" : utils.combo_insert_text,
"on_load_filter" : self.on_save_filter,
})
def on_filter_load_clicked(self,obj):
self.load_dialog = GladeXML(self.glade_file,"filter_file")
self.filter_combo = self.load_dialog.get_widget("filter_combo")
self.load_dialog.get_widget("title").set_text("Load complex filter")
names = self.interface.get_filter_names()
if len(names) > 0:
self.filter_combo.set_popdown_strings(names)
self.load_dialog.signal_autoconnect({
"destroy_passed_object" : utils.destroy_passed_object,
"combo_insert_text" : utils.combo_insert_text,
"on_load_filter" : self.on_load_filter,
})
def on_load_filter(self,obj):
name = self.load_dialog.get_widget("name").get_text()
self.filter_list = self.interface.get_filter(name)
self.filter_list_obj.freeze()
self.filter_list_obj.clear()
for f in self.filter_list:
if f.get_invert():
invert = "yes"
else:
invert = "no"
name = str(f.__class__)
name = Filter.get_filter_description(name)
self.filter_list_obj.append([name,f.get_text(),invert])
self.filter_list_obj.thaw()
utils.destroy_passed_object(obj)
def on_save_filter(self,obj):
name = self.load_dialog.get_widget("name").get_text()
self.interface.save_filter(name,self.filter_list)
utils.destroy_passed_object(obj)
def on_filter_name_changed(self,obj):
self.qual = obj.get_data(QUALIFIER)
obj.get_data(FILTER).set_sensitive(self.qual)
class ComplexFilterFile:
def __init__(self,name):
self.filters = {}
self.fname = name
f = open(self.fname)
parser = make_parser()
parser.setContentHandler(ComplexFilterParser(self))
parser.parse(f)
f.close()
def get_filter_names(self):
return self.filters.keys()
def get_filter(self,name):
if self.filters.has_key(name):
return self.filters[name]
else:
return []
def save_filter(self,name,filter_list):
self.filters[name] = filter_list
f = open(self.fname,"w")
f.write('<?xml version="1.0" encoding="iso-8859-1"?>\n')
f.write('<filterlist>\n')
for name in self.filters.keys():
f.write(' <complex_filter name="%s">\n' % name)
for filter in self.filters[name]:
val = (filter.get_name(),filter.get_text(),filter.get_invert())
f.write(' <filter name="%s" text="%s" invert="%d"/>\n' % val)
f.write(' </complex_filter>\n')
f.write('</filterlist>\n')
f.close()
class ComplexFilterParser(handler.ContentHandler):
def __init__(self,parent):
self.parent = parent
self.curfilter = []
self.curname = ""
def startElement(self,tag,attrs):
if tag == "complex_filter":
self.curname = attrs['name']
self.curfilter = []
elif tag == "filter":
name = attrs['name']
qual = attrs['text']
invert = int(attrs['invert'])
f = Filter.make_filter_from_name(name,qual,invert)
self.curfilter.append(f)
def endElement(self,tag):
if tag == "complex_filter":
self.parent.filters[self.curname] = self.curfilter
#------------------------------------------------------------------------
#
#
#
#------------------------------------------------------------------------
def runTool(database,person,callback):
EventComparison(database)
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def by_value(first,second):
return cmp(second[0],first[0])
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def fix(line):
l = string.strip(line)
l = string.replace(l,'&','&amp;')
l = string.replace(l,'>','&gt;')
l = string.replace(l,'<','&lt;')
return string.replace(l,'"','&quot;')
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
class DisplayChart:
def __init__(self,people_list):
self.my_list = people_list
self.row_data = []
base = os.path.dirname(__file__)
self.glade_file = base + os.sep + "eventcmp.glade"
self.topDialog = GladeXML(self.glade_file,"view")
self.topDialog.signal_autoconnect({
"on_write_table" : on_write_table,
"on_write_table" : self.on_write_table,
"destroy_passed_object" : utils.destroy_passed_object
})
top = self.topDialog.get_widget("top")
top.set_data(OBJECT,self)
table = self.topDialog.get_widget("addarea")
self.top = self.topDialog.get_widget("view")
self.table = self.topDialog.get_widget("addarea")
my_list.sort(sort.by_last_name)
self.my_list.sort(sort.by_last_name)
self.event_titles = self.make_event_titles()
self.build_row_data()
self.draw_clist_display()
self.top.show()
def draw_clist_display(self):
eventlist = GtkCList(len(self.event_titles),self.event_titles)
self.table.add(eventlist)
eventlist.show()
color_clist = ListColors.ColorList(eventlist,2)
for (top,bottom) in self.row_data:
color_clist.add(top)
color_clist.add(bottom)
for index in range(0,len(self.event_titles)):
width = min(150,eventlist.optimal_column_width(index))
eventlist.set_column_width(index,width)
def build_row_data(self):
for individual in self.my_list:
name = individual.getPrimaryName().getName()
birth = individual.getBirth()
death = individual.getDeath()
map = {}
elist = individual.getEventList()[:]
for ievent in elist:
event_name = ievent.getName()
if map.has_key(event_name):
map[event_name].append(ievent)
else:
map[event_name] = [ievent]
first = 1
done = 0
while done == 0:
added = 0
if first:
tlist = [name,birth.getDate(),death.getDate()]
blist = ["",birth.getPlaceName(),death.getPlaceName()]
else:
tlist = ["","",""]
blist = ["","",""]
for ename in self.event_titles[3:]:
if map.has_key(ename) and len(map[ename]) > 0:
event = map[ename][0]
del map[ename][0]
tlist.append(event.getDate())
blist.append(event.getPlaceName())
added = 1
else:
tlist.append("")
blist.append("")
if first:
first = 0
self.row_data.append((tlist,blist))
elif added == 0:
done = 1
else:
self.row_data.append((tlist,blist))
def make_event_titles(self):
"""Creates the list of unique event types, along with the person's
name, birth, and death. This should be the column titles of the report"""
map = {}
for individual in my_list:
for individual in self.my_list:
elist = individual.getEventList()
for event in elist:
name = event.getName()
@ -257,334 +455,41 @@ class EventComparison:
for item in unsort_list:
sort_list.append(item[1])
event_titles = ["Person","Birth","Death"] + sort_list
return [_("Person"),_("Birth"),_("Death")] + sort_list
eventlist = GtkCList(len(event_titles),event_titles)
eventlist.set_data(INDEX,-1)
table.add(eventlist)
eventlist.show()
color_clist = ListColors.ColorList(eventlist,2)
for individual in my_list:
name = individual.getPrimaryName().getName()
birth = individual.getBirth()
death = individual.getDeath()
map = {}
elist = individual.getEventList()[:]
for ievent in elist:
event_name = ievent.getName()
if map.has_key(event_name):
map[event_name].append(ievent)
else:
map[event_name] = [ievent]
def on_write_table(self,obj):
self.form = GladeXML(self.glade_file,"dialog1")
self.form.signal_autoconnect({
"on_save_clicked" : self.on_save_clicked,
"on_html_toggled" : self.on_html_toggled,
"destroy_passed_object" : utils.destroy_passed_object
})
self.save_form = self.form.get_widget("dialog1")
self.save_form.show()
first = 1
done = 0
while done == 0:
added = 0
if first:
tlist = [name,birth.getDate(),death.getDate()]
blist = ["",birth.getPlaceName(),death.getPlaceName()]
else:
tlist = ["","",""]
blist = ["","",""]
for ename in event_titles[3:]:
if map.has_key(ename) and len(map[ename]) > 0:
mylist = map[ename]
event = mylist[0]
del mylist[0]
tlist.append(event.getDate())
blist.append(event.getPlaceName())
added = 1
else:
tlist.append("")
blist.append("")
if first:
first = 0
color_clist.add(tlist)
color_clist.add(blist)
elif added == 0:
done = 1
else:
color_clist.add(tlist)
color_clist.add(blist)
def on_html_toggled(self,obj):
active = self.form.get_widget("html").get_active()
self.form.get_widget("htmltemplate").set_sensitive(active)
for index in range(0,len(event_titles)):
eventlist.set_column_width(index,eventlist.optimal_column_width(index))
top.show()
#------------------------------------------------------------------------
#
#
#
#------------------------------------------------------------------------
def save_data(self):
def on_save_clicked(self,obj):
my_list = []
for person in self.db.getPersonMap().values():
match = 1
for filter in self.filter_list:
if not filter.compare(person):
match = 0
if match == 1:
my_list.append(person)
my_list.sort(sort.by_last_name)
map = {}
for individual in my_list:
elist = individual.getEventList()[:]
for event in elist:
name = event.getName()
if not name:
break
if map.has_key(name):
map[name] = map[name] + 1
else:
map[name] = 1
unsort_list = []
for item in map.keys():
unsort_list.append((map[item],item))
unsort_list.sort(by_value)
sort_list = []
for item in unsort_list:
sort_list.append(item[1])
event_titles = ["Person","Birth","Death"] + sort_list
name = self.form.get_widget("filename").get_text()
doc = OpenSpreadSheet(PaperStyle("junk",10,10),PAPER_PORTRAIT)
spreadsheet = TableReport(name,doc)
spreadsheet.initialize(len(event_titles))
spreadsheet.initialize(len(self.event_titles))
spreadsheet.write_table_head(self.event_titles)
spreadsheet.write_table_head(event_titles)
index = 0
for individual in my_list:
for (top,bottom) in self.row_data:
spreadsheet.set_row(index%2)
index = index + 1
name = individual.getPrimaryName().getName()
birth = individual.getBirth()
death = individual.getDeath()
map = {}
elist = individual.getEventList()[:]
for ievent in elist:
event_name = ievent.getName()
if map.has_key(event_name):
map[event_name].append(ievent)
else:
map[event_name] = [ievent]
first = 1
done = 0
while done == 0:
added = 0
if first:
tlist = [name,birth.getDate(),death.getDate()]
blist = ["",birth.getPlaceName(),death.getPlaceName()]
else:
tlist = ["","",""]
blist = ["","",""]
for ename in event_titles[3:]:
if map.has_key(ename) and len(map[ename]) > 0:
mylist = map[ename]
event = mylist[0]
del mylist[0]
tlist.append(event.getDate())
blist.append(event.getPlaceName())
added = 1
else:
tlist.append("")
blist.append("")
if first:
first = 0
spreadsheet.write_table_data(tlist)
spreadsheet.write_table_data(blist)
elif added == 0:
done = 1
else:
spreadsheet.write_table_data(tlist)
spreadsheet.write_table_data(blist)
spreadsheet.write_table_data(top)
spreadsheet.write_table_data(bottom)
spreadsheet.finalize()
#------------------------------------------------------------------------
#
#
#
#------------------------------------------------------------------------
def display_save_form(self):
self.form = GladeXML(self.glade_file,"dialog1")
self.form.signal_autoconnect({
"on_save_clicked": on_save_clicked,
"on_html_toggled": on_html_toggled,
"destroy_passed_object" : utils.destroy_passed_object
})
self.save_form = self.form.get_widget("dialog1")
self.save_form.set_data(OBJECT,self)
self.save_form.show()
#------------------------------------------------------------------------
#
#
#
#------------------------------------------------------------------------
def runTool(database,person,callback):
EventComparison(database)
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def on_apply_clicked(obj):
myobj = obj.get_data(OBJECT)
myobj.display_results()
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def on_write_table(obj):
myobj = obj.get_data(OBJECT)
myobj.display_save_form()
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def on_save_clicked(obj):
myobj = obj.get_data(OBJECT)
myobj.save_data()
utils.destroy_passed_object(obj)
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def on_html_toggled(obj):
myobj = obj.get_data(OBJECT)
if myobj.form.get_widget("html").get_active():
myobj.form.get_widget("htmltemplate").set_sensitive(1)
else:
myobj.form.get_widget("htmltemplate").set_sensitive(0)
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def on_double_click(obj,event):
import EditPerson
row = obj.get_data(INDEX)
if event.button == 1 and event.type == GDK._2BUTTON_PRESS and row != -1:
EditPerson.EditPerson(obj.get_row_data(row))
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def on_select_row(obj,row,b,c):
obj.set_data(INDEX,row)
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def on_delete_clicked(obj):
myobj = obj.get_data(OBJECT)
row = myobj.filter_list_obj.get_data(INDEX)
if row == -1:
return
myobj.filter_list_obj.remove(row)
myobj.filter_list_obj.set_data(INDEX,row-1)
myobj.filter_list_obj.unselect_all()
del myobj.filter_list[row]
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def on_add_clicked(obj):
myobj = obj.get_data(OBJECT)
invert = myobj.filterDialog.get_widget("invert").get_active()
qualifier = myobj.filterDialog.get_widget("qualifier").get_text()
menu = myobj.filter_menu.get_menu()
function = menu.get_active().get_data(FUNCTION)
name = menu.get_active().get_data(NAME)
myfilter = function(qualifier)
myfilter.set_invert(invert)
myobj.filter_list.append(myfilter)
row = myobj.filter_list_obj.get_data(INDEX)
myobj.filter_list_obj.set_data(INDEX,row+1)
if invert:
invert_text = "yes"
else:
invert_text = "no"
myobj.filter_list_obj.append([name,qualifier,invert_text])
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def on_filter_name_changed(obj):
obj.get_data(FILTER).set_sensitive(obj.get_data(QUALIFIER))
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def by_value(first,second):
return cmp(second[0],first[0])
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def on_filter_save_clicked(obj):
myobj = obj.get_data(OBJECT)
for filter in myobj.filter_list:
print "%s(\"%s\"),%d" % (filter,filter.text,filter.invert)
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def fix(line):
l = string.strip(line)
l = string.replace(l,'&','&amp;')
l = string.replace(l,'>','&gt;')
l = string.replace(l,'<','&lt;')
return string.replace(l,'"','&quot;')
utils.destroy_passed_object(obj)
#-------------------------------------------------------------------------
#