669 lines
18 KiB
Python
669 lines
18 KiB
Python
#
|
|
# Gramps - a GTK+/GNOME based genealogy program
|
|
#
|
|
# Copyright (C) 2000 Donald N. Allingham
|
|
#
|
|
# This program is free software; you can redistribute it and/or modify
|
|
# it under the terms of the GNU General Public License as published by
|
|
# the Free Software Foundation; either version 2 of the License, or
|
|
# (at your option) any later version.
|
|
#
|
|
# This program is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU General Public License
|
|
# along with this program; if not, write to the Free Software
|
|
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
#
|
|
|
|
import string
|
|
import os
|
|
|
|
#-------------------------------------------------------------------------
|
|
#
|
|
# Try to abstract SAX1 from SAX2
|
|
#
|
|
#-------------------------------------------------------------------------
|
|
try:
|
|
from xml.sax import make_parser,handler,SAXParseException
|
|
except:
|
|
from _xmlplus.sax import make_parser,handler,SAXParseException
|
|
|
|
FONT_SANS_SERIF = 0
|
|
FONT_SERIF = 1
|
|
|
|
PAPER_PORTRAIT = 0
|
|
PAPER_LANDSCAPE = 1
|
|
|
|
PARA_ALIGN_CENTER = 0
|
|
PARA_ALIGN_LEFT = 1
|
|
PARA_ALIGN_RIGHT = 2
|
|
PARA_ALIGN_JUSTIFY= 3
|
|
|
|
def cnv2color(text):
|
|
c0 = string.atoi(text[1:3],16)
|
|
c1 = string.atoi(text[3:5],16)
|
|
c2 = string.atoi(text[5:7],16)
|
|
return (c0,c1,c2)
|
|
|
|
#------------------------------------------------------------------------
|
|
#
|
|
#
|
|
#
|
|
#------------------------------------------------------------------------
|
|
class PaperStyle:
|
|
def __init__(self,name,height,width):
|
|
self.name = name
|
|
self.orientation = PAPER_PORTRAIT
|
|
self.height = height
|
|
self.width = width
|
|
|
|
def get_name(self):
|
|
return self.name
|
|
|
|
def get_orientation(self):
|
|
return self.orientation
|
|
|
|
def set_orientation(self,val):
|
|
self.orientation = val
|
|
|
|
def get_height(self):
|
|
return self.height
|
|
|
|
def get_width(self):
|
|
return self.width
|
|
|
|
def get_height_inches(self):
|
|
return self.height / 2.54
|
|
|
|
def get_width_inches(self):
|
|
return self.width / 2.54
|
|
|
|
#------------------------------------------------------------------------
|
|
#
|
|
#
|
|
#
|
|
#------------------------------------------------------------------------
|
|
class FontStyle:
|
|
def __init__(self, style=None):
|
|
if style:
|
|
self.face = style.face
|
|
self.size = style.size
|
|
self.italic = style.italic
|
|
self.bold = style.bold
|
|
self.color = style.color
|
|
self.under = style.under
|
|
else:
|
|
self.face = FONT_SERIF
|
|
self.size = 12
|
|
self.italic = 0
|
|
self.bold = 0
|
|
self.color = (0,0,0)
|
|
self.under = 0
|
|
|
|
def set(self,face=None,size=None,italic=None,bold=None,underline=None,color=None):
|
|
if face != None:
|
|
self.set_type_face(face)
|
|
if size != None:
|
|
self.set_size(size)
|
|
if italic != None:
|
|
self.set_italic(italic)
|
|
if bold != None:
|
|
self.set_bold(bold)
|
|
if underline != None:
|
|
self.set_underline(underline)
|
|
if color != None:
|
|
self.set_color(color)
|
|
|
|
def set_italic(self,val):
|
|
"0 disables italics, 1 enables italics"
|
|
self.italic = val
|
|
|
|
def get_italic(self):
|
|
"1 indicates use italics"
|
|
return self.italic
|
|
|
|
def set_bold(self,val):
|
|
"0 disables bold face, 1 enables bold face"
|
|
self.bold = val
|
|
|
|
def get_bold(self):
|
|
"1 indicates use bold face"
|
|
return self.bold
|
|
|
|
def set_color(self,val):
|
|
"sets the color using an RGB color tuple"
|
|
self.color = val
|
|
|
|
def get_color(self):
|
|
"Returns an RGB color tuple"
|
|
return self.color
|
|
|
|
def set_size(self,val):
|
|
"sets font size in points"
|
|
self.size = val
|
|
|
|
def get_size(self):
|
|
"returns font size in points"
|
|
return self.size
|
|
|
|
def set_type_face(self,val):
|
|
"sets the font face type"
|
|
self.face = val
|
|
|
|
def get_type_face(self):
|
|
"returns the font face type"
|
|
return self.face
|
|
|
|
def set_underline(self,val):
|
|
"1 enables underlining"
|
|
self.under = val
|
|
|
|
def get_underline(self):
|
|
"1 indicates underlining"
|
|
return self.under
|
|
|
|
#------------------------------------------------------------------------
|
|
#
|
|
#
|
|
#
|
|
#------------------------------------------------------------------------
|
|
class TableStyle:
|
|
def __init__(self,obj=None):
|
|
if obj:
|
|
self.width = obj.width
|
|
self.columns = obj.columns
|
|
self.colwid = obj.colwid[:]
|
|
else:
|
|
self.width = 0
|
|
self.columns = 0
|
|
self.colwid = [ 0 ] * 100
|
|
|
|
def set_width(self,width):
|
|
self.width = width
|
|
|
|
def get_width(self):
|
|
return self.width
|
|
|
|
def set_columns(self,columns):
|
|
self.columns = columns
|
|
|
|
def get_columns(self):
|
|
return self.columns
|
|
|
|
def set_column_widths(self, list):
|
|
self.columns = len(list)
|
|
for i in range(self.columns):
|
|
self.colwid[i] = list[i]
|
|
|
|
def set_column_width(self,index,width):
|
|
self.colwid[index] = width
|
|
|
|
def get_column_width(self,index):
|
|
return self.colwid[index]
|
|
|
|
#------------------------------------------------------------------------
|
|
#
|
|
#
|
|
#
|
|
#------------------------------------------------------------------------
|
|
class TableCellStyle:
|
|
def __init__(self,obj=None):
|
|
if obj:
|
|
self.rborder = obj.rborder
|
|
self.lborder = obj.lborder
|
|
self.tborder = obj.tborder
|
|
self.bborder = obj.bborder
|
|
self.padding = obj.padding
|
|
self.longlist = obj.longlist
|
|
else:
|
|
self.rborder = 0
|
|
self.lborder = 0
|
|
self.tborder = 0
|
|
self.bborder = 0
|
|
self.padding = 0
|
|
self.longlist = 0
|
|
|
|
def set_padding(self,val):
|
|
self.padding = val
|
|
|
|
def set_right_border(self,val):
|
|
self.rborder = val
|
|
|
|
def set_left_border(self,val):
|
|
self.lborder = val
|
|
|
|
def set_top_border(self,val):
|
|
self.tborder = val
|
|
|
|
def set_bottom_border(self,val):
|
|
self.bborder = val
|
|
|
|
def set_longlist(self,val):
|
|
self.longlist = val
|
|
|
|
def get_padding(self):
|
|
return self.padding
|
|
|
|
def get_right_border(self):
|
|
return self.rborder
|
|
|
|
def get_left_border(self):
|
|
return self.lborder
|
|
|
|
def get_top_border(self):
|
|
return self.tborder
|
|
|
|
def get_bottom_border(self):
|
|
return self.bborder
|
|
|
|
def get_longlist(self):
|
|
return self.longlist
|
|
|
|
#------------------------------------------------------------------------
|
|
#
|
|
#
|
|
#
|
|
#------------------------------------------------------------------------
|
|
class ParagraphStyle:
|
|
def __init__(self,p=None):
|
|
if p:
|
|
self.font = FontStyle(p.font)
|
|
self.rmargin = p.rmargin
|
|
self.lmargin = p.lmargin
|
|
self.first_indent = p.first_indent
|
|
self.align = p.align
|
|
self.level = p.level
|
|
self.top_border = p.top_border
|
|
self.bottom_border = p.bottom_border
|
|
self.right_border = p.right_border
|
|
self.left_border = p.left_border
|
|
self.pad = p.pad
|
|
self.bgcolor = p.bgcolor
|
|
else:
|
|
self.font = FontStyle()
|
|
self.rmargin = 0
|
|
self.lmargin = 0
|
|
self.first_indent = 0
|
|
self.align = PARA_ALIGN_LEFT
|
|
self.level = 0
|
|
self.top_border = 0
|
|
self.bottom_border = 0
|
|
self.right_border = 0
|
|
self.left_border = 0
|
|
self.pad = 0
|
|
self.bgcolor = (255,255,255)
|
|
|
|
def set(self,rmargin=None,lmargin=None,first_indent=None,align=None,\
|
|
tborder=None,bborder=None,rborder=None,lborder=None,pad=None,
|
|
bgcolor=None,font=None):
|
|
if font != None:
|
|
self.font = FontStyle(font)
|
|
if pad != None:
|
|
self.set_padding(pad)
|
|
if tborder != None:
|
|
self.set_top_border(tborder)
|
|
if bborder != None:
|
|
self.set_bottom_border(bborder)
|
|
if rborder != None:
|
|
self.set_right_border(rborder)
|
|
if lborder != None:
|
|
self.set_left_border(lborder)
|
|
if bgcolor != None:
|
|
self.set_background_color(bgcolor)
|
|
if align != None:
|
|
self.set_alignment(align)
|
|
if rmargin != None:
|
|
self.set_right_margin(rmargin)
|
|
if lmargin != None:
|
|
self.set_left_margin(lmargin)
|
|
if first_indent != None:
|
|
self.set_first_indent(first_indent)
|
|
|
|
def set_header_level(self,level):
|
|
self.level = level
|
|
|
|
def get_header_level(self):
|
|
return self.level
|
|
|
|
def set_font(self,font):
|
|
self.font = FontStyle(font)
|
|
|
|
def get_font(self):
|
|
return self.font
|
|
|
|
def set_padding(self,val):
|
|
self.pad = val
|
|
|
|
def get_padding(self):
|
|
return self.pad
|
|
|
|
def set_top_border(self,val):
|
|
self.top_border = val
|
|
|
|
def get_top_border(self):
|
|
return self.top_border
|
|
|
|
def set_bottom_border(self,val):
|
|
self.bottom_border = val
|
|
|
|
def get_bottom_border(self):
|
|
return self.bottom_border
|
|
|
|
def set_left_border(self,val):
|
|
self.left_border = val
|
|
|
|
def get_background_color(self):
|
|
return self.bgcolor
|
|
|
|
def set_background_color(self,color):
|
|
self.bgcolor = color
|
|
|
|
def get_left_border(self):
|
|
return self.left_border
|
|
|
|
def set_right_border(self,val):
|
|
self.right_border = val
|
|
|
|
def get_right_border(self):
|
|
return self.right_border
|
|
|
|
def set_alignment(self,align):
|
|
self.align = align
|
|
|
|
def get_alignment(self):
|
|
return self.align
|
|
|
|
def get_alignment_text(self):
|
|
if self.align == PARA_ALIGN_LEFT:
|
|
return "left"
|
|
elif self.align == PARA_ALIGN_CENTER:
|
|
return "center"
|
|
elif self.align == PARA_ALIGN_RIGHT:
|
|
return "right"
|
|
elif self.align == PARA_ALIGN_JUSTIFY:
|
|
return "justify"
|
|
return "unknown"
|
|
|
|
def set_left_margin(self,value):
|
|
"sets the left paragraph margin in centimeters"
|
|
self.lmargin = value
|
|
|
|
def set_right_margin(self,value):
|
|
"sets the right paragraph margin in centimeters"
|
|
self.rmargin = value
|
|
|
|
def set_first_indent(self,value):
|
|
"sets the first indent margin in centimeters"
|
|
self.first_indent = value
|
|
|
|
def get_left_margin(self):
|
|
"returns the left margin in centimeters"
|
|
return self.lmargin
|
|
|
|
def get_right_margin(self):
|
|
"returns the right margin in centimeters"
|
|
return self.rmargin
|
|
|
|
def get_first_indent(self):
|
|
"returns the first indent margin in centimeters"
|
|
return self.first_indent
|
|
|
|
#------------------------------------------------------------------------
|
|
#
|
|
#
|
|
#
|
|
#------------------------------------------------------------------------
|
|
class StyleSheetList:
|
|
def __init__(self,file,defstyle):
|
|
self.map = { "default" : defstyle }
|
|
self.file = os.path.expanduser("~/.gramps/" + file)
|
|
self.parse()
|
|
|
|
def delete_style_sheet(self,name):
|
|
del self.map[name]
|
|
|
|
def get_style_sheet_map(self):
|
|
return self.map
|
|
|
|
def get_style_sheet(self,name):
|
|
return self.map[name]
|
|
|
|
def get_style_names(self):
|
|
return self.map.keys()
|
|
|
|
def set_style_sheet(self,name,style):
|
|
if name != "default":
|
|
self.map[name] = style
|
|
|
|
def save(self):
|
|
f = open(self.file,"w")
|
|
f.write("<?xml version=\"1.0\" encoding=\"iso-8859-1\"?>\n")
|
|
f.write('<stylelist>\n')
|
|
for name in self.map.keys():
|
|
if name == "default":
|
|
continue
|
|
sheet = self.map[name]
|
|
f.write('<sheet name="%s">\n' % name)
|
|
for p_name in sheet.get_names():
|
|
p = sheet.get_style(p_name)
|
|
f.write('<style name="%s">\n' % p_name)
|
|
font = p.get_font()
|
|
f.write('<font face="%d" ' % font.get_type_face())
|
|
f.write('size="%d" ' % font.get_size())
|
|
f.write('italic="%d" ' % font.get_italic())
|
|
f.write('bold="%d" ' % font.get_bold())
|
|
f.write('underline="%d" ' % font.get_underline())
|
|
f.write('color="#%02x%02x%02x"/>\n' % font.get_color())
|
|
f.write('<para ')
|
|
rm = float(p.get_right_margin())
|
|
lm = float(p.get_left_margin())
|
|
fi = float(p.get_first_indent())
|
|
f.write('rmargin="%.3f" ' % rm)
|
|
f.write('lmargin="%.3f" ' % lm)
|
|
f.write('first="%.3f" ' % fi)
|
|
f.write('pad="%.3f" ' % p.get_padding())
|
|
f.write('bgcolor="#%02x%02x%02x" ' % p.get_background_color())
|
|
f.write('level="%d" ' % p.get_header_level())
|
|
f.write('align="%d" ' % p.get_alignment())
|
|
f.write('tborder="%d" ' % p.get_top_border())
|
|
f.write('lborder="%d" ' % p.get_left_border())
|
|
f.write('rborder="%d" ' % p.get_right_border())
|
|
f.write('bborder="%d"/>\n' % p.get_bottom_border())
|
|
f.write('</style>\n')
|
|
f.write('</sheet>\n')
|
|
f.write('</stylelist>\n')
|
|
f.close()
|
|
|
|
|
|
def parse(self):
|
|
try:
|
|
parser = make_parser()
|
|
parser.setContentHandler(SheetParser(self))
|
|
parser.parse(self.file)
|
|
except (IOError,OSError,SAXParseException):
|
|
pass
|
|
|
|
#------------------------------------------------------------------------
|
|
#
|
|
#
|
|
#
|
|
#------------------------------------------------------------------------
|
|
class StyleSheet:
|
|
def __init__(self,obj=None):
|
|
self.style_list = {}
|
|
if obj != None:
|
|
for style_name in obj.style_list.keys():
|
|
style = obj.style_list[style_name]
|
|
self.style_list[style_name] = ParagraphStyle(style)
|
|
|
|
def clear(self):
|
|
self.style_list = {}
|
|
|
|
def add_style(self,name,style):
|
|
self.style_list[name] = ParagraphStyle(style)
|
|
|
|
def get_names(self):
|
|
return self.style_list.keys()
|
|
|
|
def get_styles(self):
|
|
return self.style_list
|
|
|
|
def get_style(self,name):
|
|
return self.style_list[name]
|
|
|
|
#-------------------------------------------------------------------------
|
|
#
|
|
#
|
|
#
|
|
#-------------------------------------------------------------------------
|
|
class SheetParser(handler.ContentHandler):
|
|
def __init__(self,sheetlist):
|
|
handler.ContentHandler.__init__(self)
|
|
self.sheetlist = sheetlist
|
|
self.f = None
|
|
self.p = None
|
|
self.s = None
|
|
self.sname = None
|
|
self.pname = None
|
|
|
|
def setDocumentLocator(self,locator):
|
|
self.locator = locator
|
|
|
|
def startElement(self,tag,attrs):
|
|
if tag == "sheet":
|
|
self.s = StyleSheet(self.sheetlist.map["default"])
|
|
self.sname = attrs['name']
|
|
elif tag == "font":
|
|
self.f = FontStyle()
|
|
self.f.set_type_face(int(attrs['face']))
|
|
self.f.set_size(int(attrs['size']))
|
|
self.f.set_italic(int(attrs['italic']))
|
|
self.f.set_bold(int(attrs['bold']))
|
|
self.f.set_underline(int(attrs['underline']))
|
|
self.f.set_color(cnv2color(attrs['color']))
|
|
elif tag == "para":
|
|
self.p.set_right_margin(float(attrs['rmargin']))
|
|
self.p.set_left_margin(float(attrs['lmargin']))
|
|
self.p.set_first_indent(float(attrs['first']))
|
|
self.p.set_padding(float(attrs['pad']))
|
|
self.p.set_alignment(int(attrs['align']))
|
|
self.p.set_right_border(int(attrs['rborder']))
|
|
self.p.set_header_level(int(attrs['level']))
|
|
self.p.set_left_border(int(attrs['lborder']))
|
|
self.p.set_top_border(int(attrs['tborder']))
|
|
self.p.set_bottom_border(int(attrs['bborder']))
|
|
self.p.set_background_color(cnv2color(attrs['bgcolor']))
|
|
elif tag == "style":
|
|
self.p = ParagraphStyle()
|
|
self.pname = attrs['name']
|
|
|
|
def endElement(self,tag):
|
|
if tag == "style":
|
|
self.p.set_font(self.f)
|
|
self.s.add_style(self.pname,self.p)
|
|
elif tag == "sheet":
|
|
self.sheetlist.set_style_sheet(self.sname,self.s)
|
|
|
|
def characters(self, data):
|
|
pass
|
|
|
|
#------------------------------------------------------------------------
|
|
#
|
|
#
|
|
#
|
|
#------------------------------------------------------------------------
|
|
class TextDoc:
|
|
def __init__(self,styles,type,template,orientation=PAPER_PORTRAIT):
|
|
self.orientation = orientation
|
|
self.template = template
|
|
if orientation == PAPER_PORTRAIT:
|
|
self.width = type.get_width()
|
|
self.height = type.get_height()
|
|
else:
|
|
self.width = type.get_height()
|
|
self.height = type.get_width()
|
|
self.paper = type
|
|
self.tmargin = 2.54
|
|
self.bmargin = 2.54
|
|
self.lmargin = 2.54
|
|
self.rmargin = 2.54
|
|
self.title = ""
|
|
|
|
self.font = FontStyle()
|
|
self.style_list = styles.get_styles()
|
|
self.table_styles = {}
|
|
self.cell_styles = {}
|
|
self.name = ""
|
|
self.photo_list = []
|
|
|
|
def add_photo(self,name,align,w_cm,h_cm):
|
|
"""adds a photo of the specified width (in centimeters)"""
|
|
pass
|
|
|
|
def get_usable_width(self):
|
|
return self.width - (self.rmargin + self.lmargin)
|
|
|
|
def get_usable_height(self):
|
|
return self.height - (self.tmargin + self.bmargin)
|
|
|
|
def creator(self,name):
|
|
self.name = name
|
|
|
|
def set_title(self,name):
|
|
self.title = name
|
|
|
|
def add_table_style(self,name,style):
|
|
self.table_styles[name] = TableStyle(style)
|
|
|
|
def add_cell_style(self,name,style):
|
|
self.cell_styles[name] = TableCellStyle(style)
|
|
|
|
def open(self,filename):
|
|
pass
|
|
|
|
def close(self):
|
|
pass
|
|
|
|
def page_break(self):
|
|
pass
|
|
|
|
def start_bold(self):
|
|
pass
|
|
|
|
def end_bold(self):
|
|
pass
|
|
|
|
def start_paragraph(self,style_name,leader=None):
|
|
pass
|
|
|
|
def end_paragraph(self):
|
|
pass
|
|
|
|
def start_table(self,name,style_name):
|
|
pass
|
|
|
|
def end_table(self):
|
|
pass
|
|
|
|
def start_row(self):
|
|
pass
|
|
|
|
def end_row(self):
|
|
pass
|
|
|
|
def start_cell(self,style_name,span=1):
|
|
pass
|
|
|
|
def end_cell(self):
|
|
pass
|
|
|
|
def horizontal_line(self):
|
|
pass
|
|
|
|
def write_text(self,text):
|
|
pass
|
|
|