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

* src/RelLib.py (Family.set_mother_handle): Typo.

Browse Source 
* src/Report.py: Use gen and pagebbg.
* src/ReportOptions.py: Use gen and pagebbg.
* src/plugins/Ancestors.py: Use gen and pagebbg.
* src/plugins/AncestorReport.py: Use gen and pagebbg.
* src/plugins/DescendReport.py: Use gen and pagebbg.
* src/plugins/FtmStyleDescendants.py: Use gen and pagebbg.
* src/plugins/FtmStyleAncestors.py: Use gen and pagebbg.
* src/plugins/IndivComplete.py: Convert to new scheme.
* src/plugins/TimeLine.py: Add custom filters to the pool.
* src/plugins/DetAncestralReport.py: Convert to new scheme.


svn: r3849
This commit is contained in:
Alex Roitman 2005-01-01 02:17:17 +00:00
parent b932aefbf2
commit 6494d8e7bb
12 changed files with 673 additions and 1227 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
ChangeLog
View File

@ -1,3 +1,16 @@
2004-12-31 Alex Roitman <shura@alex.neuro.umn.edu>
* src/RelLib.py (Family.set_mother_handle): Typo.
* src/Report.py: Use gen and pagebbg.
* src/ReportOptions.py: Use gen and pagebbg.
* src/plugins/Ancestors.py: Use gen and pagebbg.
* src/plugins/AncestorReport.py: Use gen and pagebbg.
* src/plugins/DescendReport.py: Use gen and pagebbg.
* src/plugins/FtmStyleDescendants.py: Use gen and pagebbg.
* src/plugins/FtmStyleAncestors.py: Use gen and pagebbg.
* src/plugins/IndivComplete.py: Convert to new scheme.
* src/plugins/TimeLine.py: Add custom filters to the pool.
* src/plugins/DetAncestralReport.py: Convert to new scheme.
2004-12-30 Alex Roitman <shura@alex.neuro.umn.edu>
* src/Report.py: Change finish_report to end_report.
* src/plugins/BookReport.py (cl_report):

2
src/RelLib.py
View File

@ -1256,7 +1256,7 @@ class Family(PrimaryObject,SourceNote):
@param person_handle: L{Person} database handle
@type person_handle: str
"""
self.mother_handle = person
self.mother_handle = person_handle
def get_mother_handle(self):
"""

32
src/Report.py
View File

@ -56,7 +56,7 @@ import StyleEditor
import GrampsGconfKeys
import PaperMenu
import Errors
import GenericFilter
from QuestionDialog import ErrorDialog, OptionDialog
#-------------------------------------------------------------------------
@ -433,19 +433,13 @@ class BareReportDialog:
It is called immediately before the window is displayed. All
calls to add_option or add_frame_option should be called in
this task."""
try:
self.options.add_user_options(self)
except AttributeError:
pass
self.options.add_user_options(self)
def parse_user_options(self):
"""Called to allow parsing of added widgets.
It is called when OK is pressed in a dialog.
All custom widgets should provide a parsing code here."""
try:
self.options.parse_user_options(self)
except AttributeError:
pass
self.options.parse_user_options(self)
def add_option(self,label_text,widget,tooltip=None):
"""Takes a text string and a Gtk Widget, and stores them to be
@ -597,8 +591,6 @@ class BareReportDialog:
generations fields and the filter combo box are used in most
(but not all) dialog boxes."""
import GenericFilter
(em_label, extra_map, preset, em_tip) = self.get_report_extra_menu_info()
(et_label, string, et_tip) = self.get_report_extra_textbox_info()
@ -1002,7 +994,7 @@ class ReportDialog(BareReportDialog):
self.doc = self.format(self.selected_style,self.paper,
self.template_name,self.orien)
self.options.handler.doc = self.doc
self.options.set_document(self.doc)
if self.print_report.get_active ():
self.doc.print_requested ()
@ -1565,8 +1557,8 @@ class CommandLineReport:
'template' : ["=name","Template name (HTML only)."],
'id' : ["=ID","Gramps ID of a central person. MANDATORY"],
'filter' : ["=num","Filter number."],
'max_gen' : ["=num","Number generations to follow."],
'page_breaks': ["=0/1","Page break between generations."],
'gen' : ["=num","Number of generations to follow."],
'pagebbg' : ["=0/1","Page break between generations."],
}
# Add report-specific options
@ -1580,8 +1572,6 @@ class CommandLineReport:
self.options_help[key] = self.option_class.options_help[key]
def parse_option_str(self):
import GenericFilter
for opt in self.options_str_dict.keys():
if opt in self.options_dict.keys():
converter = Utils.get_type_converter(self.options_dict[opt])
@ -1612,13 +1602,13 @@ class CommandLineReport:
self.options_help['filter'].append(filt_list)
self.options_help['filter'].append(True)
if self.options_dict.has_key('max_gen'):
max_gen = self.options_dict['max_gen']
page_breaks = self.options_dict['page_breaks']
if self.options_dict.has_key('gen'):
max_gen = self.options_dict['gen']
page_breaks = self.options_dict['pagebbg']
self.option_class.handler.set_report_generations(max_gen,page_breaks)
self.options_help['max_gen'].append("Whatever Number You Wish")
self.options_help['page_breaks'].append([
self.options_help['gen'].append("Whatever Number You Wish")
self.options_help['pagebbg'].append([
"No page break","Page break"])
self.options_help['page_breaks'].append(True)

26
src/ReportOptions.py
View File

@ -541,18 +541,18 @@ class OptionHandler:
self.option_list_collection.save()
def get_report_generations(self):
if self.default_options_dict.has_key('max_gen'):
max_gen = self.options_dict.get('max_gen',
self.default_options_dict['max_gen'])
page_breaks = self.options_dict.get('page_breaks',
self.default_options_dict['page_breaks'])
if self.default_options_dict.has_key('gen'):
max_gen = self.options_dict.get('gen',
self.default_options_dict['gen'])
page_breaks = self.options_dict.get('pagebbg',
self.default_options_dict['pagebbg'])
return (max_gen,page_breaks)
else:
return (0,0)
def set_report_generations(self,max_gen,page_breaks):
self.options_dict['max_gen'] = max_gen
self.options_dict['page_breaks'] = page_breaks
self.options_dict['gen'] = max_gen
self.options_dict['pagebbg'] = page_breaks
def get_stylesheet_savefile(self):
"""Where to save user defined styles for this report."""
@ -667,13 +667,13 @@ class ReportOptions:
but not common enough to be present in all reports. Here's the list
of possible keys for semi-commons:
'filter' - Filter number, selected among filters
available for this report. If defined,
get_report_filters() method must be defined
which returns the list of available filters.
'filter' - Filter number, selected among filters
available for this report. If defined,
get_report_filters() method must be defined
which returns the list of available filters.
'max_gen' - Maximum number of generations to consider.
'page_breaks' - Whether or not make page breaks between generations.
'gen' - Maximum number of generations to consider.
'pagebbg' - Whether or not make page breaks between generations.
A self.enable_dict dictionary MUST be defined here, whose keys

8
src/plugins/AncestorReport.py
View File

@ -40,13 +40,11 @@ import Report
import BaseDoc
import RelLib
import Errors
import DateHandler
from DateHandler import displayer as _dd
from QuestionDialog import ErrorDialog
import ReportOptions
import const
_dd = DateHandler.displayer
#------------------------------------------------------------------------
#
# AncestorReport
@ -270,8 +268,8 @@ class AncestorOptions(ReportOptions.ReportOptions):
def enable_options(self):
# Semi-common options that should be enabled for this report
self.enable_dict = {
'max_gen' : 10,
'page_breaks' : 0,
'gen' : 10,
'pagebbg' : 0,
}
def make_default_style(self,default_style):

29
src/plugins/Ancestors.py
View File

@ -46,11 +46,10 @@ import BaseDoc
import RelLib
import Errors
import Plugins
import DateHandler
from QuestionDialog import ErrorDialog
import ReportOptions
from DateHandler import displayer as _dd
_dd = DateHandler.displayer
#------------------------------------------------------------------------
#
# ComprehensiveAncestorsReport
@ -59,7 +58,22 @@ _dd = DateHandler.displayer
class ComprehensiveAncestorsReport (Report.Report):
def __init__(self,database,person,options_class):
#,max,pgbrk,cite,doc,output,newpage=0):
"""
Creates ComprehensiveAncestorsReport object that produces the report.
The arguments are:
database - the GRAMPS database instance
person - currently selected person
options_class - instance of the Options class for this report
This report needs the following parameters (class variables)
that come in the options class.
gen - Maximum number of generations to include.
pagebbg - Whether to include page breaks between generations.
cites - Whether or not to include source informaiton.
"""
Report.Report.__init__(self,database,person,options_class)
@ -67,7 +81,6 @@ class ComprehensiveAncestorsReport (Report.Report):
(self.max_generations,self.pgbrk) \
= options_class.get_report_generations()
#self.opt_cite = cite
self.opt_cite = options_class.handler.options_dict['cites']
self.output = options_class.get_output()
@ -900,8 +913,8 @@ class ComprehensiveAncestorsOptions(ReportOptions.ReportOptions):
def enable_options(self):
# Semi-common options that should be enabled for this report
self.enable_dict = {
'max_gen' : 10,
'page_breaks' : 0,
'gen' : 10,
'pagebbg' : 0,
}
def make_default_style(self,default_style):
@ -966,14 +979,14 @@ class ComprehensiveAncestorsOptions(ReportOptions.ReportOptions):
"""
self.cb_cite = gtk.CheckButton (_("Cite sources"))
self.cb_cite.set_active (gtk.TRUE)
self.cb_cite.set_active (self.options_dict['cites'])
dialog.add_option ('', self.cb_cite)
def parse_user_options(self,dialog):
"""
Parses the custom options that we have added.
"""
self.options_dict['cites'] = self.cb_cite.get_active ()
self.options_dict['cites'] = int(self.cb_cite.get_active ())
#------------------------------------------------------------------------

4
src/plugins/DescendReport.py
View File

@ -165,8 +165,8 @@ class DescendantOptions(ReportOptions.ReportOptions):
def enable_options(self):
# Semi-common options that should be enabled for this report
self.enable_dict = {
'max_gen' : 10,
'page_breaks' : 0,
'gen' : 10,
'pagebbg' : 0,
}
def make_default_style(self,default_style):

1019
src/plugins/DetAncestralReport.py
View File

File diff suppressed because it is too large Load Diff

16
src/plugins/FtmStyleAncestors.py
View File

@ -70,16 +70,8 @@ class FtmAncestorReport(Report.Report):
This report needs the following parameters (class variables)
that come in the options class.
max_gen - Maximum number of generations to include.
pg_breaks - Whether to include page breaks between generations.
document - BaseDoc instance for the output file. Any class derived
from BaseDoc may be used
output - name of the output file.
None if report is not a standalone, in which case
somebody must take care of opening and initializing report
prior to writing.
newpage - if True, newpage is made before writing a report
gen - Maximum number of generations to include.
pagebgg - Whether to include page breaks between generations.
"""
Report.Report.__init__(self,database,person,options_class)
@ -1057,8 +1049,8 @@ class FtmAncestorOptions(ReportOptions.ReportOptions):
def enable_options(self):
# Semi-common options that should be enabled for this report
self.enable_dict = {
'max_gen' : 10,
'page_breaks' : 0,
'gen' : 10,
'pagebbg' : 0,
}
def make_default_style(self,default_style):

16
src/plugins/FtmStyleDescendants.py
View File

@ -74,16 +74,8 @@ class FtmDescendantReport(Report.Report):
This report needs the following parameters (class variables)
that come in the options class.
max_gen - Maximum number of generations to include.
pg_breaks - Whether to include page breaks between generations.
document - BaseDoc instance for the output file. Any class derived
from BaseDoc may be used
output - name of the output file.
None if report is not a standalone, in which case
somebody must take care of opening and initializing report
prior to writing.
newpage - if True, newpage is made before writing a report
gen - Maximum number of generations to include.
pagebbg - Whether to include page breaks between generations.
"""
Report.Report.__init__(self,database,person,options_class)
@ -1481,8 +1473,8 @@ class FtmDescendantOptions(ReportOptions.ReportOptions):
def enable_options(self):
# Semi-common options that should be enabled for this report
self.enable_dict = {
'max_gen' : 10,
'page_breaks' : 0,
'gen' : 10,
'pagebbg' : 0,
}
def make_default_style(self,default_style):

726
src/plugins/IndivComplete.py
View File

@ -28,6 +28,13 @@
import os
from gettext import gettext as _
#------------------------------------------------------------------------
#
# Gnome/GTK modules
#
#------------------------------------------------------------------------
import gtk
#------------------------------------------------------------------------
#
# GRAMPS modules
@ -41,49 +48,47 @@ import Report
import GenericFilter
import Errors
from QuestionDialog import ErrorDialog
#------------------------------------------------------------------------
#
# Gnome/GTK modules
#
#------------------------------------------------------------------------
import gtk
#------------------------------------------------------------------------
#
# Set up sane defaults for the book_item
#
#------------------------------------------------------------------------
_person_handle = ""
_filter_num = 0
_use_srcs = 0
_options = ( _person_handle, _filter_num, _use_srcs )
import ReportOptions
#------------------------------------------------------------------------
#
# IndivComplete
#
#------------------------------------------------------------------------
class IndivComplete(Report.Report):
class IndivCompleteReport(Report.Report):
def __init__(self,database,person,options_class):
"""
Creates the IndivCompleteReport object that produces the report.
The arguments are:
database - the GRAMPS database instance
person - currently selected person
options_class - instance of the Options class for this report
This report needs the following parameters (class variables)
that come in the options class.
filter - Filter to be applied to the people of the database.
The option class carries its number, and the function
returning the list of filters.
cites - Whether or not to include source informaiton.
"""
Report.Report.__init__(self,database,person,options_class)
self.use_srcs = options_class.handler.options_dict['cites']
filter_num = options_class.get_filter_number()
filters = options_class.get_report_filters(person)
filters.extend(GenericFilter.CustomFilters.get_filters())
self.filter = filters[filter_num]
def __init__(self,database,person,output,document,filter,use_srcs,newpage=0):
self.d = document
self.use_srcs = use_srcs
self.filter = filter
c = database.get_researcher().get_name()
self.d.creator(c)
self.doc.creator(c)
self.map = {}
self.database = database
self.person = person
self.output = output
self.setup()
self.newpage = newpage
if output:
self.standalone = 1
self.d.open(output)
self.d.init()
else:
self.standalone = 0
def setup(self):
tbl = BaseDoc.TableStyle()
@ -91,30 +96,26 @@ class IndivComplete(Report.Report):
tbl.set_columns(2)
tbl.set_column_width(0,20)
tbl.set_column_width(1,80)
self.d.add_table_style("IDS-IndTable",tbl)
self.doc.add_table_style("IDS-IndTable",tbl)
tbl = BaseDoc.TableStyle()
tbl.set_width(100)
tbl.set_columns(2)
tbl.set_column_width(0,50)
tbl.set_column_width(1,50)
self.d.add_table_style("IDS-ParentsTable",tbl)
self.doc.add_table_style("IDS-ParentsTable",tbl)
cell = BaseDoc.TableCellStyle()
cell.set_top_border(1)
cell.set_bottom_border(1)
self.d.add_cell_style("IDS-TableHead",cell)
self.doc.add_cell_style("IDS-TableHead",cell)
cell = BaseDoc.TableCellStyle()
self.d.add_cell_style("IDS-NormalCell",cell)
self.doc.add_cell_style("IDS-NormalCell",cell)
cell = BaseDoc.TableCellStyle()
cell.set_longlist(1)
self.d.add_cell_style("IDS-ListCell",cell)
def end(self):
if self.standalone:
self.d.close()
self.doc.add_cell_style("IDS-ListCell",cell)
def write_fact(self,event):
if event == None:
@ -140,7 +141,7 @@ class IndivComplete(Report.Report):
'place' : place }
text = '%s %s' % (text,description)
self.d.start_row()
self.doc.start_row()
self.normal_cell(name)
if self.use_srcs:
for s in event.get_source_references():
@ -149,10 +150,10 @@ class IndivComplete(Report.Report):
text = "%s [%s]" % (text,src.get_gramps_id())
self.slist.append(s)
self.normal_cell(text)
self.d.end_row()
self.doc.end_row()
def write_p_entry(self,label,parent,rel):
self.d.start_row()
self.doc.start_row()
self.normal_cell(label)
if parent:
@ -160,48 +161,48 @@ class IndivComplete(Report.Report):
{ 'parent' : parent, 'relation' : rel })
else:
self.normal_cell('')
self.d.end_row()
self.doc.end_row()
def write_note(self):
note = self.person.get_note()
note = self.start_person.get_note()
if note == '':
return
self.d.start_table('note','IDS-IndTable')
self.d.start_row()
self.d.start_cell('IDS-TableHead',2)
self.d.start_paragraph('IDS-TableTitle')
self.d.write_text(_('Notes'))
self.d.end_paragraph()
self.d.end_cell()
self.d.end_row()
self.doc.start_table('note','IDS-IndTable')
self.doc.start_row()
self.doc.start_cell('IDS-TableHead',2)
self.doc.start_paragraph('IDS-TableTitle')
self.doc.write_text(_('Notes'))
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.end_row()
self.d.start_row()
self.d.start_cell('IDS-NormalCell',2)
format = self.person.get_note_format()
self.d.write_note(note,format,'IDS-Normal')
self.d.end_cell()
self.d.end_row()
self.doc.start_row()
self.doc.start_cell('IDS-NormalCell',2)
format = self.start_person.get_note_format()
self.doc.write_note(note,format,'IDS-Normal')
self.doc.end_cell()
self.doc.end_row()
self.d.end_table()
self.d.start_paragraph("IDS-Normal")
self.d.end_paragraph()
self.doc.end_table()
self.doc.start_paragraph("IDS-Normal")
self.doc.end_paragraph()
def write_alt_parents(self):
if len(self.person.get_parent_family_handle_list()) < 2:
if len(self.start_person.get_parent_family_handle_list()) < 2:
return
self.d.start_table("altparents","IDS-IndTable")
self.d.start_row()
self.d.start_cell("IDS-TableHead",2)
self.d.start_paragraph("IDS-TableTitle")
self.d.write_text(_("Alternate Parents"))
self.d.end_paragraph()
self.d.end_cell()
self.d.end_row()
self.doc.start_table("altparents","IDS-IndTable")
self.doc.start_row()
self.doc.start_cell("IDS-TableHead",2)
self.doc.start_paragraph("IDS-TableTitle")
self.doc.write_text(_("Alternate Parents"))
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.end_row()
for (family_handle,mrel,frel) in self.person.get_parent_family_handle_list():
if family_handle == self.person.get_main_parents_family_handle():
for (family_handle,mrel,frel) in self.start_person.get_parent_family_handle_list():
if family_handle == self.start_person.get_main_parents_family_handle():
continue
family = self.database.get_family_from_handle(family_handle)
@ -223,27 +224,27 @@ class IndivComplete(Report.Report):
else:
self.write_p_entry(_('Mother'),'','')
self.d.end_table()
self.d.start_paragraph("IDS-Normal")
self.d.end_paragraph()
self.doc.end_table()
self.doc.start_paragraph("IDS-Normal")
self.doc.end_paragraph()
def write_alt_names(self):
if len(self.person.get_alternate_names()) < 1:
if len(self.start_person.get_alternate_names()) < 1:
return
self.d.start_table("altparents","IDS-IndTable")
self.d.start_row()
self.d.start_cell("IDS-TableHead",2)
self.d.start_paragraph("IDS-TableTitle")
self.d.write_text(_("Alternate Names"))
self.d.end_paragraph()
self.d.end_cell()
self.d.end_row()
self.doc.start_table("altparents","IDS-IndTable")
self.doc.start_row()
self.doc.start_cell("IDS-TableHead",2)
self.doc.start_paragraph("IDS-TableTitle")
self.doc.write_text(_("Alternate Names"))
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.end_row()
for name in self.person.get_alternate_names():
for name in self.start_person.get_alternate_names():
type = const.NameTypesMap.find_value(name.get_type())
self.d.start_row()
self.doc.start_row()
self.normal_cell(type)
text = name.get_regular_name()
if self.use_srcs:
@ -253,43 +254,43 @@ class IndivComplete(Report.Report):
text = "%s [%s]" % (text,src.get_gramps_id())
self.slist.append(s)
self.normal_cell(text)
self.d.end_row()
self.d.end_table()
self.d.start_paragraph('IDS-Normal')
self.d.end_paragraph()
self.doc.end_row()
self.doc.end_table()
self.doc.start_paragraph('IDS-Normal')
self.doc.end_paragraph()
def write_families(self):
if not len(self.person.get_family_handle_list()):
if not len(self.start_person.get_family_handle_list()):
return
self.d.start_table("three","IDS-IndTable")
self.d.start_row()
self.d.start_cell("IDS-TableHead",2)
self.d.start_paragraph("IDS-TableTitle")
self.d.write_text(_("Marriages/Children"))
self.d.end_paragraph()
self.d.end_cell()
self.d.end_row()
self.doc.start_table("three","IDS-IndTable")
self.doc.start_row()
self.doc.start_cell("IDS-TableHead",2)
self.doc.start_paragraph("IDS-TableTitle")
self.doc.write_text(_("Marriages/Children"))
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.end_row()
for family_handle in self.person.get_family_handle_list():
for family_handle in self.start_person.get_family_handle_list():
family = self.database.get_family_from_handle(family_handle)
if self.person.get_handle() == family.get_father_handle():
if self.start_person.get_handle() == family.get_father_handle():
spouse_id = family.get_mother_handle()
else:
spouse_id = family.get_father_handle()
self.d.start_row()
self.d.start_cell("IDS-NormalCell",2)
self.d.start_paragraph("IDS-Spouse")
self.doc.start_row()
self.doc.start_cell("IDS-NormalCell",2)
self.doc.start_paragraph("IDS-Spouse")
if spouse_id:
spouse = self.database.get_person_from_handle(spouse_id)
text = spouse.get_primary_name().get_regular_name()
else:
text = _("unknown")
self.d.write_text(text)
self.d.end_paragraph()
self.d.end_cell()
self.d.end_row()
self.doc.write_text(text)
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.end_row()
for event_handle in family.get_event_list():
if event_handle:
@ -298,82 +299,78 @@ class IndivComplete(Report.Report):
child_handle_list = family.get_child_handle_list()
if len(child_handle_list):
self.d.start_row()
self.doc.start_row()
self.normal_cell(_("Children"))
self.d.start_cell("IDS-ListCell")
self.d.start_paragraph("IDS-Normal")
self.doc.start_cell("IDS-ListCell")
self.doc.start_paragraph("IDS-Normal")
first = 1
for child_handle in child_handle_list:
if first == 1:
first = 0
else:
self.d.write_text('\n')
self.doc.write_text('\n')
child = self.database.get_person_from_handle(child_handle)
self.d.write_text(child.get_primary_name().get_regular_name())
self.d.end_paragraph()
self.d.end_cell()
self.d.end_row()
self.d.end_table()
self.d.start_paragraph('IDS-Normal')
self.d.end_paragraph()
self.doc.write_text(child.get_primary_name().get_regular_name())
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.end_row()
self.doc.end_table()
self.doc.start_paragraph('IDS-Normal')
self.doc.end_paragraph()
def write_sources(self):
if len(self.slist) == 0:
return
self.d.start_table("three","IDS-IndTable")
self.d.start_row()
self.d.start_cell("IDS-TableHead",2)
self.d.start_paragraph("IDS-TableTitle")
self.d.write_text(_("Sources"))
self.d.end_paragraph()
self.d.end_cell()
self.d.end_row()
self.doc.start_table("three","IDS-IndTable")
self.doc.start_row()
self.doc.start_cell("IDS-TableHead",2)
self.doc.start_paragraph("IDS-TableTitle")
self.doc.write_text(_("Sources"))
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.end_row()
for source in self.slist:
self.d.start_row()
self.doc.start_row()
s_handle = source.get_base_handle()
src = self.database.get_source_from_handle(s_handle)
self.normal_cell(src.get_gramps_id())
self.normal_cell(src.get_title())
self.d.end_row()
self.d.end_table()
self.doc.end_row()
self.doc.end_table()
def write_facts(self):
self.d.start_table("two","IDS-IndTable")
self.d.start_row()
self.d.start_cell("IDS-TableHead",2)
self.d.start_paragraph("IDS-TableTitle")
self.d.write_text(_("Individual Facts"))
self.d.end_paragraph()
self.d.end_cell()
self.d.end_row()
self.doc.start_table("two","IDS-IndTable")
self.doc.start_row()
self.doc.start_cell("IDS-TableHead",2)
self.doc.start_paragraph("IDS-TableTitle")
self.doc.write_text(_("Individual Facts"))
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.end_row()
event_handle_list = [ self.person.get_birth_handle(), self.person.get_death_handle() ]
event_handle_list = event_handle_list + self.person.get_event_list()
event_handle_list = [ self.start_person.get_birth_handle(), self.start_person.get_death_handle() ]
event_handle_list = event_handle_list + self.start_person.get_event_list()
for event_handle in event_handle_list:
if event_handle:
event = self.database.get_event_from_handle(event_handle)
self.write_fact(event)
self.d.end_table()
self.d.start_paragraph("IDS-Normal")
self.d.end_paragraph()
self.doc.end_table()
self.doc.start_paragraph("IDS-Normal")
self.doc.end_paragraph()
def normal_cell(self,text):
self.d.start_cell('IDS-NormalCell')
self.d.start_paragraph('IDS-Normal')
self.d.write_text(text)
self.d.end_paragraph()
self.d.end_cell()
self.doc.start_cell('IDS-NormalCell')
self.doc.start_paragraph('IDS-Normal')
self.doc.write_text(text)
self.doc.end_paragraph()
self.doc.end_cell()
def write_report(self):
if self.newpage:
self.d.page_break()
#plist = self.database.get_person_handle_map().values()
plist = self.database.get_person_handles(sort_handles=False)
if self.filter:
ind_list = self.filter.apply(self.database,plist)
@ -382,39 +379,38 @@ class IndivComplete(Report.Report):
count = 0
for person_handle in ind_list:
self.person = self.database.get_person_from_handle(person_handle)
self.start_person = self.database.get_person_from_handle(person_handle)
self.write_person(count)
count = count + 1
self.end()
def write_person(self,count):
if count != 0:
self.d.page_break()
self.doc.page_break()
self.slist = []
media_list = self.person.get_media_list()
name = self.person.get_primary_name().get_regular_name()
self.d.start_paragraph("IDS-Title")
self.d.write_text(_("Summary of %s") % name)
self.d.end_paragraph()
media_list = self.start_person.get_media_list()
name = self.start_person.get_primary_name().get_regular_name()
self.doc.start_paragraph("IDS-Title")
self.doc.write_text(_("Summary of %s") % name)
self.doc.end_paragraph()
self.d.start_paragraph("IDS-Normal")
self.d.end_paragraph()
self.doc.start_paragraph("IDS-Normal")
self.doc.end_paragraph()
if len(media_list) > 0:
object_handle = media_list[0].get_reference_handle()
object = self.database.get_object_from_handle(object_handle)
if object.get_mime_type()[0:5] == "image":
file = object.get_path()
self.d.start_paragraph("IDS-Normal")
self.d.add_media_object(file,"row",4.0,4.0)
self.d.end_paragraph()
self.doc.start_paragraph("IDS-Normal")
self.doc.add_media_object(file,"row",4.0,4.0)
self.doc.end_paragraph()
self.d.start_table("one","IDS-IndTable")
self.doc.start_table("one","IDS-IndTable")
self.d.start_row()
self.doc.start_row()
self.normal_cell("%s:" % _("Name"))
name = self.person.get_primary_name()
name = self.start_person.get_primary_name()
text = name.get_regular_name()
if self.use_srcs:
for s in name.get_source_references():
@ -423,17 +419,17 @@ class IndivComplete(Report.Report):
src = self.database.get_source_from_handle(src_handle)
text = "%s [%s]" % (text,src.get_gramps_id())
self.normal_cell(text)
self.d.end_row()
self.doc.end_row()
self.d.start_row()
self.doc.start_row()
self.normal_cell("%s:" % _("Gender"))
if self.person.get_gender() == RelLib.Person.male:
if self.start_person.get_gender() == RelLib.Person.male:
self.normal_cell(_("Male"))
else:
self.normal_cell(_("Female"))
self.d.end_row()
self.doc.end_row()
family_handle = self.person.get_main_parents_family_handle()
family_handle = self.start_person.get_main_parents_family_handle()
if family_handle:
family = self.database.get_family_from_handle(family_handle)
father_inst_id = family.get_father_handle()
@ -452,19 +448,19 @@ class IndivComplete(Report.Report):
father = ""
mother = ""
self.d.start_row()
self.doc.start_row()
self.normal_cell("%s:" % _("Father"))
self.normal_cell(father)
self.d.end_row()
self.doc.end_row()
self.d.start_row()
self.doc.start_row()
self.normal_cell("%s:" % _("Mother"))
self.normal_cell(mother)
self.d.end_row()
self.d.end_table()
self.doc.end_row()
self.doc.end_table()
self.d.start_paragraph("IDS-Normal")
self.d.end_paragraph()
self.doc.start_paragraph("IDS-Normal")
self.doc.end_paragraph()
self.write_alt_names()
self.write_facts()
@ -478,300 +474,130 @@ class IndivComplete(Report.Report):
#
#
#------------------------------------------------------------------------
class IndivCompleteDialog(Report.TextReportDialog):
class IndivCompleteOptions(ReportOptions.ReportOptions):
report_options = {}
"""
Defines options and provides handling interface.
"""
def __init__(self,database,person):
Report.TextReportDialog.__init__(self,database,person,self.report_options)
def __init__(self,name,person_id=None):
ReportOptions.ReportOptions.__init__(self,name,person_id)
def add_user_options(self):
self.use_srcs = gtk.CheckButton(_('Include Source Information'))
self.use_srcs.show()
self.add_option('',self.use_srcs)
def set_new_options(self):
# Options specific for this report
self.options_dict = {
'cites' : 1,
}
self.options_help = {
'cites' : ("=0/1","Whether to cite sources.",
["Do not cite sources","Cite sources"],
True),
}
#------------------------------------------------------------------------
#
# Customization hooks
#
#------------------------------------------------------------------------
def get_title(self):
"""The window title for this dialog"""
return "%s - %s - GRAMPS" %(_("Complete Individual Report"),_("Text Reports"))
def enable_options(self):
# Semi-common options that should be enabled for this report
self.enable_dict = {
'filter' : 0,
}
def get_header(self, name):
"""The header line at the top of the dialog contents"""
return _("Complete Individual Report")
def get_target_browser_title(self):
"""The title of the window created when the 'browse' button is
clicked in the 'Save As' frame."""
return _("Save Complete Individual Report")
def get_stylesheet_savefile(self):
"""Where to save styles for this report."""
return "indiv_complete.xml"
def doc_uses_tables(self):
"""This report requires table support."""
return 1
def get_report_filters(self):
def get_report_filters(self,person):
"""Set up the list of possible content filters."""
return _get_report_filters(self.person)
#------------------------------------------------------------------------
#
# Create output styles appropriate to this report.
#
#------------------------------------------------------------------------
def make_default_style(self):
"""Make the default output style for the Individual Complete Report."""
_make_default_style(self.default_style)
def setup_report_options(self):
"""The 'Report Options' frame is not used in this dialog."""
pass
def make_report(self):
"""Create the object that will produce the Ancestor Chart.
All user dialog has already been handled and the output file
opened."""
act = self.use_srcs.get_active()
try:
MyReport = IndivComplete(self.db, self.person, self.target_path,
self.doc, self.filter, act)
MyReport.setup()
MyReport.write_report()
except Errors.FilterError, msg:
(m1,m2) = msg.messages()
ErrorDialog(m1,m2)
except Errors.ReportError, msg:
(m1,m2) = msg.messages()
ErrorDialog(m1,m2)
except:
import DisplayTrace
DisplayTrace.DisplayTrace()
def get_report_generations(self):
"""Return the default number of generations to start the
spinbox (zero to disable) and whether or not to include the
'page break between generations' check box"""
return (0, 0)
#------------------------------------------------------------------------
#
#
#
#------------------------------------------------------------------------
def report(database,person):
IndivCompleteDialog(database,person)
#------------------------------------------------------------------------
#
# Book Item Options dialog
#
#------------------------------------------------------------------------
class IndivCompleteBareReportDialog(Report.BareReportDialog):
def __init__(self,database,person,opt,stl):
self.options = opt
self.db = database
if self.options[0]:
self.person = self.db.get_person_from_handle(self.options[0])
if person:
name = person.get_primary_name().get_name()
handle = person.get_handle()
else:
self.person = person
self.style_name = stl
name = 'PERSON'
handle = ''
Report.BareReportDialog.__init__(self,database,self.person)
filt_id = GenericFilter.GenericFilter()
filt_id.set_name(name)
filt_id.add_rule(GenericFilter.HasIdOf([handle]))
self.filter_num = int(self.options[1])
self.use_srcs = int(self.options[2])
self.new_person = None
all = GenericFilter.GenericFilter()
all.set_name(_("Entire Database"))
all.add_rule(GenericFilter.Everyone([]))
self.filter_combo.set_history(self.filter_num)
self.use_srcs_checkbox.set_active(self.use_srcs)
des = GenericFilter.GenericFilter()
des.set_name(_("Descendants of %s") % name)
des.add_rule(GenericFilter.IsDescendantOf([handle,1]))
self.window.run()
ans = GenericFilter.GenericFilter()
ans.set_name(_("Ancestors of %s") % name)
ans.add_rule(GenericFilter.IsAncestorOf([handle,1]))
def make_default_style(self):
_make_default_style(self.default_style)
com = GenericFilter.GenericFilter()
com.set_name(_("People with common ancestor with %s") % name)
com.add_rule(GenericFilter.HasCommonAncestorWith([handle]))
def get_report_filters(self):
return _get_report_filters(self.person)
return [filt_id,all,des,ans,com]
def add_user_options(self):
self.use_srcs_checkbox = gtk.CheckButton(_('Include Source Information'))
self.use_srcs_checkbox.show()
self.add_option('',self.use_srcs_checkbox)
#------------------------------------------------------------------------
#
# Customization hooks
#
#------------------------------------------------------------------------
def get_title(self):
"""The window title for this dialog"""
return "%s - GRAMPS Book" % (_("Individual Complete"))
def get_header(self, name):
"""The header line at the top of the dialog contents"""
return _("Individual Complete Report for GRAMPS Book")
def get_stylesheet_savefile(self):
"""Where to save styles for this report."""
return "individual_summary.xml"
def on_cancel(self, obj):
pass
def on_ok_clicked(self, obj):
"""The user is satisfied with the dialog choices. Parse all options
and close the window."""
# Preparation
self.parse_style_frame()
self.parse_report_options_frame()
def add_user_options(self,dialog):
"""
Override the base class add_user_options task to add a menu that allows
the user to select the sort method.
"""
if self.new_person:
self.person = self.new_person
self.filter_num = self.filter_combo.get_history()
self.use_srcs = self.use_srcs_checkbox.get_active()
self.options = ( self.person.getId(), self.filter_num, self.use_srcs )
self.style_name = self.selected_style.get_name()
self.use_srcs = gtk.CheckButton(_('Include Source Information'))
self.use_srcs.set_active(self.options_dict['cites'])
dialog.add_option('',self.use_srcs)
def get_report_generations(self):
"""Return the default number of generations to start the
spinbox (zero to disable) and whether or not to include the
'page break between generations' check box"""
return (0, 0)
def parse_user_options(self,dialog):
"""
Parses the custom options that we have added.
"""
self.options_dict['cites'] = int(self.use_srcs.get_active ())
#------------------------------------------------------------------------
#
# Function to write Book Item
#
#------------------------------------------------------------------------
def write_book_item(database,person,doc,options,newpage=0):
"""Write the Individual Copmlete Report using the options set.
All user dialog has already been handled and the output file opened."""
try:
if options[0]:
person = database.get_person_from_handle(options[0])
filter_num = int(options[1])
filters = _get_report_filters(person)
the_filter = filters[filter_num]
act = int(options[2])
return IndivComplete(database, person, None, doc, the_filter, act, newpage)
except Errors.ReportError, msg:
(m1,m2) = msg.messages()
ErrorDialog(m1,m2)
except Errors.FilterError, msg:
(m1,m2) = msg.messages()
ErrorDialog(m1,m2)
except:
import DisplayTrace
DisplayTrace.DisplayTrace()
return None
#------------------------------------------------------------------------
#
# Makes the default styles
#
#------------------------------------------------------------------------
def _make_default_style(default_style):
"""Make the default output style for the Individual Complete Report."""
font = BaseDoc.FontStyle()
font.set_bold(1)
font.set_type_face(BaseDoc.FONT_SANS_SERIF)
font.set_size(16)
p = BaseDoc.ParagraphStyle()
p.set_alignment(BaseDoc.PARA_ALIGN_CENTER)
p.set_font(font)
p.set_description(_("The style used for the title of the page."))
default_style.add_style("IDS-Title",p)
font = BaseDoc.FontStyle()
font.set_bold(1)
font.set_type_face(BaseDoc.FONT_SANS_SERIF)
font.set_size(12)
font.set_italic(1)
p = BaseDoc.ParagraphStyle()
p.set_font(font)
p.set_description(_("The style used for category labels."))
default_style.add_style("IDS-TableTitle",p)
font = BaseDoc.FontStyle()
font.set_bold(1)
font.set_type_face(BaseDoc.FONT_SANS_SERIF)
font.set_size(12)
p = BaseDoc.ParagraphStyle()
p.set_font(font)
p.set_description(_("The style used for the spouse's name."))
default_style.add_style("IDS-Spouse",p)
font = BaseDoc.FontStyle()
font.set_size(12)
p = BaseDoc.ParagraphStyle()
p.set_font(font)
p.set_description(_('The basic style used for the text display.'))
default_style.add_style("IDS-Normal",p)
def make_default_style(self,default_style):
"""Make the default output style for the Individual Complete Report."""
font = BaseDoc.FontStyle()
font.set_bold(1)
font.set_type_face(BaseDoc.FONT_SANS_SERIF)
font.set_size(16)
p = BaseDoc.ParagraphStyle()
p.set_alignment(BaseDoc.PARA_ALIGN_CENTER)
p.set_font(font)
p.set_description(_("The style used for the title of the page."))
default_style.add_style("IDS-Title",p)
font = BaseDoc.FontStyle()
font.set_bold(1)
font.set_type_face(BaseDoc.FONT_SANS_SERIF)
font.set_size(12)
font.set_italic(1)
p = BaseDoc.ParagraphStyle()
p.set_font(font)
p.set_description(_("The style used for category labels."))
default_style.add_style("IDS-TableTitle",p)
#------------------------------------------------------------------------
#
# Builds filter list for this report
#
#------------------------------------------------------------------------
def _get_report_filters(person):
"""Set up the list of possible content filters."""
font = BaseDoc.FontStyle()
font.set_bold(1)
font.set_type_face(BaseDoc.FONT_SANS_SERIF)
font.set_size(12)
p = BaseDoc.ParagraphStyle()
p.set_font(font)
p.set_description(_("The style used for the spouse's name."))
default_style.add_style("IDS-Spouse",p)
name = person.get_primary_name().get_name()
filt_id = GenericFilter.GenericFilter()
filt_id.set_name(name)
filt_id.add_rule(GenericFilter.HasIdOf([person.get_handle()]))
des = GenericFilter.GenericFilter()
des.set_name(_("Descendants of %s") % name)
des.add_rule(GenericFilter.IsDescendantOf([person.get_handle(),1]))
ans = GenericFilter.GenericFilter()
ans.set_name(_("Ancestors of %s") % name)
ans.add_rule(GenericFilter.IsAncestorOf([person.get_handle(),1]))
all = GenericFilter.GenericFilter()
all.set_name(_("Entire Database"))
all.add_rule(GenericFilter.Everyone([]))
return [filt_id,des,ans,all]
font = BaseDoc.FontStyle()
font.set_size(12)
p = BaseDoc.ParagraphStyle()
p.set_font(font)
p.set_description(_('The basic style used for the text display.'))
default_style.add_style("IDS-Normal",p)
#------------------------------------------------------------------------
#
#
#
#------------------------------------------------------------------------
from Plugins import register_report, register_book_item
from Plugins import register_report
register_report(
report,
_("Complete Individual Report"),
name = 'indiv_complete',
category = const.CATEGORY_TEXT,
report_class = IndivCompleteReport,
options_class = IndivCompleteOptions,
modes = Report.MODE_GUI | Report.MODE_BKI | Report.MODE_CLI,
translated_name = _("Complete Individual Report"),
status=(_("Beta")),
category=_("Text Reports"),
description=_("Produces a complete report on the selected people."),
)
register_book_item(
_("Individual Complete"),
_("Text"),
IndivCompleteBareReportDialog,
write_book_item,
_options,
"default" ,
"individual_complete.xml",
_make_default_style
)

9
src/plugins/TimeLine.py
View File

@ -83,20 +83,13 @@ class TimeLine(Report.Report):
when given two personal handles (like cmp).
The option class carries its number, and the function
returning the list of sort functions.
document - BaseDoc instance for the output file. Any class derived
from BaseDoc may be used
output - name of the output file.
None if report is not a standalone, in which case
somebody must take care of opening and initializing report
prior to writing.
newpage - if True, newpage is made before writing a report
"""
Report.Report.__init__(self,database,person,options_class)
filter_num = options_class.get_filter_number()
filters = options_class.get_report_filters(person)
filters.extend(GenericFilter.CustomFilters.get_filters())
self.filter = filters[filter_num]
self.title = options_class.handler.options_dict['title']