2004-02-29 21:05:44 +05:30
|
|
|
#
|
|
|
|
# Gramps - a GTK+/GNOME based genealogy program
|
|
|
|
#
|
|
|
|
# Copyright (C) 2000-2004 Donald N. Allingham
|
|
|
|
#
|
|
|
|
# Modifications and feature additions:
|
|
|
|
# 2002 Donald A. Peterson
|
|
|
|
#
|
|
|
|
# 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
|
|
|
|
#
|
|
|
|
|
2004-02-29 23:12:38 +05:30
|
|
|
# Written by Billy C. Earney, 2003-2004
|
|
|
|
# Modified by Alex Roitman, 2004
|
|
|
|
|
|
|
|
# $Id$
|
|
|
|
|
2004-02-29 21:05:44 +05:30
|
|
|
"""LPR document generator"""
|
|
|
|
|
|
|
|
#------------------------------------------------------------------------
|
|
|
|
#
|
|
|
|
# python modules
|
|
|
|
#
|
|
|
|
#------------------------------------------------------------------------
|
|
|
|
import string
|
|
|
|
|
|
|
|
import pygtk
|
|
|
|
|
|
|
|
import gnomeprint, gnomeprint.ui, gtk
|
|
|
|
#------------------------------------------------------------------------
|
|
|
|
#
|
|
|
|
# gramps modules
|
|
|
|
#
|
|
|
|
#------------------------------------------------------------------------
|
|
|
|
import BaseDoc
|
|
|
|
import Plugins
|
|
|
|
import ImgManip
|
|
|
|
from gettext import gettext as _
|
|
|
|
|
|
|
|
#------------------------------------------------------------------------
|
|
|
|
#
|
|
|
|
# Units conversion
|
|
|
|
#
|
|
|
|
#------------------------------------------------------------------------
|
2004-03-01 22:20:23 +05:30
|
|
|
def u2cm(unit):
|
2004-02-29 21:05:44 +05:30
|
|
|
"""
|
|
|
|
Convert gnome-print units to cm
|
|
|
|
"""
|
|
|
|
return 2.54 * unit / 72.0
|
|
|
|
|
2004-03-01 22:20:23 +05:30
|
|
|
def cm2u(cm):
|
2004-02-29 21:05:44 +05:30
|
|
|
"""
|
2004-03-01 22:20:23 +05:30
|
|
|
Convert cm to gnome-print units
|
2004-02-29 21:05:44 +05:30
|
|
|
"""
|
2004-03-01 22:20:23 +05:30
|
|
|
return cm * 72.0 / 2.54
|
|
|
|
|
|
|
|
#------------------------------------------------------------------------
|
|
|
|
#
|
|
|
|
# Constants
|
|
|
|
#
|
|
|
|
#------------------------------------------------------------------------
|
|
|
|
|
|
|
|
# Spacing in points (distance between the bottoms of two adjacent lines)
|
|
|
|
_LINE_SPACING = 20
|
2004-03-02 06:06:53 +05:30
|
|
|
|
|
|
|
# Font constants -- specific for gnome-print
|
|
|
|
_FONT_SANS_SERIF = "Serif"
|
|
|
|
_FONT_SERIF = "Sans"
|
|
|
|
_FONT_MONOSPACE = "Monospace"
|
|
|
|
_FONT_BOLD = "Bold"
|
|
|
|
_FONT_ITALIC = "Italic"
|
|
|
|
_FONT_BOLD_ITALIC = "Bold Italic"
|
|
|
|
_FONT_REGULAR = "Regular"
|
2004-02-29 21:05:44 +05:30
|
|
|
|
|
|
|
#------------------------------------------------------------------------
|
|
|
|
#
|
2004-03-01 22:20:23 +05:30
|
|
|
# LPRDoc class
|
2004-02-29 21:05:44 +05:30
|
|
|
#
|
|
|
|
#------------------------------------------------------------------------
|
|
|
|
class LPRDoc(BaseDoc.BaseDoc):
|
|
|
|
"""Gnome-print document interface class. Derived from BaseDoc"""
|
|
|
|
|
|
|
|
def open(self,filename):
|
|
|
|
"""Sets up initialization"""
|
|
|
|
#set up variables needed to keep track of which state we are in
|
2004-03-02 06:06:53 +05:30
|
|
|
self.__in_table = 0
|
|
|
|
self.__in_cell = 0
|
|
|
|
self.__in_paragraph = 0
|
|
|
|
self.__page_count = 0
|
|
|
|
self.__page_open = 0
|
2004-02-29 21:05:44 +05:30
|
|
|
|
2004-03-02 06:06:53 +05:30
|
|
|
self.__paragraph_data = ""
|
|
|
|
self.__cell_data = ""
|
|
|
|
self.__table_data = []
|
2004-02-29 21:05:44 +05:30
|
|
|
|
|
|
|
#create main variables for this print job
|
|
|
|
self.__job = gnomeprint.Job(gnomeprint.config_default())
|
|
|
|
self.__pc = self.__job.get_context()
|
|
|
|
|
|
|
|
#find out what the width and height of the page is
|
2004-03-01 22:20:23 +05:30
|
|
|
__width, __height = gnomeprint.job_get_page_size_from_config(self.__job.get_config())
|
2004-03-02 06:06:53 +05:30
|
|
|
|
|
|
|
self.__left_margin = cm2u(self.get_left_margin())
|
|
|
|
self.__right_margin = __width - cm2u(self.get_right_margin())
|
|
|
|
self.__top_margin = __height - cm2u(self.get_top_margin())
|
|
|
|
self.__bottom_margin = cm2u(self.get_bottom_margin())
|
2004-02-29 21:05:44 +05:30
|
|
|
|
|
|
|
self.start_page(self)
|
|
|
|
|
2004-03-02 07:05:53 +05:30
|
|
|
|
2004-03-02 06:06:53 +05:30
|
|
|
def find_font_from_fontstyle(self,fontstyle):
|
|
|
|
"""
|
2004-03-02 07:05:53 +05:30
|
|
|
This function returns the gnomeprint.Font() object instance
|
|
|
|
corresponding to the parameters of BaseDoc.FontStyle()
|
2004-03-02 06:06:53 +05:30
|
|
|
"""
|
2004-03-02 07:05:53 +05:30
|
|
|
|
2004-03-02 06:06:53 +05:30
|
|
|
if fontstyle.get_type_face() == BaseDoc.FONT_SANS_SERIF:
|
|
|
|
face = _FONT_SANS_SERIF
|
|
|
|
elif fontstyle.get_type_face() == BaseDoc.FONT_SERIF:
|
|
|
|
face = _FONT_SERIF
|
|
|
|
elif fontstyle.get_type_face() == BaseDoc.FONT_MONOSPACE:
|
|
|
|
face = _FONT_MONOSPACE
|
|
|
|
|
|
|
|
if fontstyle.get_bold():
|
|
|
|
modifier = _FONT_BOLD
|
|
|
|
if fontstyle.get_italic():
|
|
|
|
modifier = _FONT_BOLD_ITALIC
|
|
|
|
elif fontstyle.get_italic():
|
|
|
|
modifier = _FONT_ITALIC
|
|
|
|
else:
|
|
|
|
modifier = _FONT_REGULAR
|
|
|
|
|
|
|
|
size = fontstyle.get_size()
|
|
|
|
|
|
|
|
return gnomeprint.font_find_closest("%s %s" % (face, modifier),size)
|
|
|
|
|
2004-02-29 21:05:44 +05:30
|
|
|
def close(self):
|
|
|
|
"""Clean up and close the document"""
|
|
|
|
#print "close doc"
|
|
|
|
#gracefully end page before we close the doc if a page is open
|
|
|
|
if self.__page_open:
|
|
|
|
self.end_page()
|
|
|
|
|
|
|
|
self.__job.close()
|
|
|
|
self.__show_print_dialog()
|
|
|
|
|
|
|
|
def line_break(self):
|
|
|
|
"Forces a line break within a paragraph"
|
|
|
|
self.__advance_line(self.__y)
|
|
|
|
|
|
|
|
def page_break(self):
|
|
|
|
"Forces a page break, creating a new page"
|
2004-03-02 07:05:53 +05:30
|
|
|
self.end_page()
|
2004-02-29 21:05:44 +05:30
|
|
|
self.start_page()
|
|
|
|
|
|
|
|
def start_page(self,orientation=None):
|
|
|
|
"""Create a new page"""
|
|
|
|
#print "begin page"
|
|
|
|
#reset variables dealing with opening a page
|
|
|
|
if (self.__page_open):
|
|
|
|
self.end_page()
|
|
|
|
|
|
|
|
self.__page_open=1
|
|
|
|
self.__page_count+=1
|
|
|
|
self.__x=self.__left_margin
|
|
|
|
self.__y=self.__top_margin
|
|
|
|
|
|
|
|
self.__pc.beginpage(str(self.__page_count))
|
|
|
|
self.__pc.moveto(self.__x, self.__y)
|
|
|
|
|
|
|
|
def end_page(self):
|
|
|
|
"""Close the current page"""
|
|
|
|
#print "end page"
|
|
|
|
if (self.__page_open):
|
|
|
|
self.__page_open=0
|
|
|
|
self.__pc.showpage()
|
|
|
|
|
|
|
|
def start_paragraph(self,style_name,leader=None):
|
|
|
|
"""Paragraphs handling - A Gramps paragraph is any
|
|
|
|
single body of text, from a single word, to several sentences.
|
|
|
|
We assume a linebreak at the end of each paragraph."""
|
|
|
|
#print "start paragraph"
|
|
|
|
#set paragraph variables so we know that we are in a paragraph
|
2004-03-02 06:06:53 +05:30
|
|
|
self.__in_paragraph = 1
|
|
|
|
self.__paragraph_data = ""
|
|
|
|
if self.__in_table:
|
|
|
|
self.__paragrapgh_styles[self.rownum][self.cellnum] = self.style_list[style_name]
|
|
|
|
else:
|
|
|
|
self.__paragraph_style = self.style_list[style_name]
|
2004-02-29 21:05:44 +05:30
|
|
|
|
|
|
|
def end_paragraph(self):
|
|
|
|
"""End the current paragraph"""
|
|
|
|
#print "end paragraph"
|
|
|
|
self.__in_paragraph=0
|
|
|
|
#print text in paragraph if any data exists
|
2004-03-02 07:05:53 +05:30
|
|
|
if self.__paragraph_data:
|
2004-03-02 06:06:53 +05:30
|
|
|
fontstyle = self.__paragraph_style.get_font()
|
|
|
|
self.__pc.setfont(self.find_font_from_fontstyle(fontstyle))
|
|
|
|
self.__pc.moveto(self.__x, self.__y)
|
2004-03-02 07:05:53 +05:30
|
|
|
self.__x, self.__y = self.__print_text(self.__paragraph_data,
|
2004-02-29 21:05:44 +05:30
|
|
|
self.__x, self.__y,
|
|
|
|
self.__left_margin,
|
2004-03-02 06:06:53 +05:30
|
|
|
self.__right_margin,
|
|
|
|
fontstyle)
|
2004-03-02 07:05:53 +05:30
|
|
|
self.__paragraph_data = ""
|
|
|
|
self.__y = self.__advance_line(self.__y)
|
2004-02-29 21:05:44 +05:30
|
|
|
|
2004-03-02 06:06:53 +05:30
|
|
|
#### FIXME BEGIN #########
|
|
|
|
# The following two functions don't work at the moment. The problem is
|
|
|
|
# in that the writing is deferred when in tables and/or paragraphs.
|
|
|
|
# Paragraph text is accumulated, so afterwards, when it's tim to write,
|
|
|
|
# one would need some pointers as to when to change the font (and where
|
|
|
|
# to change it back
|
|
|
|
#===========================
|
2004-02-29 21:05:44 +05:30
|
|
|
def start_bold(self):
|
|
|
|
"""Bold face"""
|
2004-03-02 06:06:53 +05:30
|
|
|
pass
|
2004-02-29 21:05:44 +05:30
|
|
|
|
|
|
|
def end_bold(self):
|
|
|
|
"""End bold face"""
|
2004-03-02 06:06:53 +05:30
|
|
|
pass
|
|
|
|
#==========================
|
|
|
|
#### FIXME END #########
|
2004-02-29 21:05:44 +05:30
|
|
|
|
|
|
|
def start_superscript(self):
|
|
|
|
pass
|
|
|
|
|
|
|
|
def end_superscript(self):
|
|
|
|
pass
|
|
|
|
|
|
|
|
def start_listing(self,style_name):
|
|
|
|
"""
|
|
|
|
Starts a new listing block, using the specified style name.
|
|
|
|
|
|
|
|
style_name - name of the ParagraphStyle to use for the block.
|
|
|
|
"""
|
|
|
|
pass
|
|
|
|
|
|
|
|
def end_listing(self):
|
|
|
|
pass
|
|
|
|
|
|
|
|
|
|
|
|
def start_table(self,name,style_name):
|
|
|
|
"""Begin new table"""
|
|
|
|
#print "start table"
|
|
|
|
#reset variables for this state
|
|
|
|
self.__table_data=[]
|
|
|
|
self.__in_table=1
|
2004-02-29 23:12:38 +05:30
|
|
|
self.__tbl_style = self.table_styles[style_name]
|
|
|
|
self.__ncols = self.__tbl_style.get_columns()
|
2004-03-02 06:06:53 +05:30
|
|
|
self.rownum = -1
|
|
|
|
self.__paragrapgh_styles = [[None] * self.__ncols]
|
2004-03-01 22:20:23 +05:30
|
|
|
table_width = (self.__right_margin - self.__left_margin) * \
|
|
|
|
self.__tbl_style.get_width() / 100.0
|
|
|
|
self.cell_widths = [0] * self.__ncols
|
|
|
|
for cell in range(self.__ncols):
|
|
|
|
self.cell_widths[cell] = table_width * \
|
|
|
|
self.__tbl_style.get_column_width(cell) / 100.0
|
2004-02-29 21:05:44 +05:30
|
|
|
|
|
|
|
def end_table(self):
|
|
|
|
"""Close the table environment"""
|
|
|
|
#print "end table"
|
|
|
|
#output table contents
|
|
|
|
self.__output_table()
|
|
|
|
self.__in_table=0
|
|
|
|
self.__y=self.__advance_line(self.__y)
|
|
|
|
|
|
|
|
def start_row(self):
|
|
|
|
"""Begin a new row"""
|
|
|
|
# doline/skipfirst are flags for adding hor. rules
|
|
|
|
#print "start row"
|
|
|
|
#reset this state, so we can get data from user
|
|
|
|
self.__row_data=[]
|
2004-03-02 06:06:53 +05:30
|
|
|
self.rownum = self.rownum + 1
|
|
|
|
self.cellnum = -1
|
|
|
|
self.__paragrapgh_styles.append([None] * self.__ncols)
|
2004-02-29 21:05:44 +05:30
|
|
|
|
|
|
|
def end_row(self):
|
|
|
|
"""End the row (new line)"""
|
|
|
|
#print "end row"
|
|
|
|
#add row data to the data we have for the current table
|
|
|
|
self.__table_data.append(self.__row_data)
|
|
|
|
|
|
|
|
def start_cell(self,style_name,span=1):
|
|
|
|
"""Add an entry to the table.
|
|
|
|
We always place our data inside braces
|
|
|
|
for safety of formatting."""
|
|
|
|
#print "start cell"
|
|
|
|
#reset this state
|
|
|
|
self.__in_cell=1
|
|
|
|
self.__cell_data=""
|
2004-03-02 06:06:53 +05:30
|
|
|
self.cellnum = self.cellnum + span
|
2004-02-29 21:05:44 +05:30
|
|
|
|
|
|
|
def end_cell(self):
|
|
|
|
"""Prepares for next cell"""
|
|
|
|
#print "end cell"
|
|
|
|
#append the cell text to the row data
|
|
|
|
self.__in_cell=0
|
|
|
|
self.__row_data.append(self.__cell_data)
|
|
|
|
|
|
|
|
def add_photo(self,name,pos,x,y):
|
|
|
|
"""Add photo to report"""
|
|
|
|
#print "add photo"
|
|
|
|
|
|
|
|
def horizontal_line(self):
|
|
|
|
self.__pc.moveto(self.__x, self.__y)
|
|
|
|
self.__pc.lineto(self.__right_margin, self.__y)
|
|
|
|
|
|
|
|
def write_cmdstr(self,text):
|
|
|
|
"""
|
|
|
|
Writes the text in the current paragraph. Should only be used after a
|
|
|
|
start_paragraph and before an end_paragraph.
|
|
|
|
|
|
|
|
text - text to write.
|
|
|
|
"""
|
2004-03-01 22:20:23 +05:30
|
|
|
if self.__in_paragraph != 1:
|
2004-02-29 21:05:44 +05:30
|
|
|
self.start_paragraph()
|
|
|
|
|
|
|
|
self.write(text)
|
|
|
|
|
|
|
|
def draw_arc(self,style,x1,y1,x2,y2,angle,extent):
|
|
|
|
pass
|
|
|
|
|
|
|
|
def draw_path(self,style,path):
|
|
|
|
pass
|
|
|
|
|
|
|
|
def draw_box(self,style,text,x,y):
|
2004-03-02 06:06:53 +05:30
|
|
|
box_style = self.draw_styles[style]
|
|
|
|
para_style = box_style.get_paragraph_style()
|
|
|
|
fontstyle = para_style.get_font()
|
|
|
|
|
2004-02-29 21:05:44 +05:30
|
|
|
#assuming that we start drawing box from current position
|
|
|
|
__width=x-self.__x
|
|
|
|
__height=y-self.__y
|
|
|
|
self.__pc.rect_stroked(self.__x, self.__y)
|
|
|
|
|
|
|
|
if text != None:
|
2004-03-02 06:06:53 +05:30
|
|
|
__text_width=self.__get_text_width(text,fontstyle)
|
2004-02-29 21:05:44 +05:30
|
|
|
#try to center text in box
|
2004-03-02 06:06:53 +05:30
|
|
|
self.__pc.setfont(self.find_font_from_fontstyle(fontstyle))
|
2004-02-29 21:05:44 +05:30
|
|
|
self.__pc.moveto(self.__x+(__width/2)-(__text_width/2),
|
|
|
|
self.__y+(__height/2))
|
|
|
|
self.__pc.show(text)
|
|
|
|
|
|
|
|
def write_at (self, style, text, x, y):
|
2004-03-02 06:06:53 +05:30
|
|
|
box_style = self.draw_styles[style]
|
|
|
|
para_style = box_style.get_paragraph_style()
|
|
|
|
fontstyle = para_style.get_font()
|
|
|
|
|
|
|
|
self.__pc.setfont(self.find_font_from_fontstyle(fontstyle))
|
2004-02-29 21:05:44 +05:30
|
|
|
self.__pc.moveto(x, y)
|
|
|
|
self.__pc.show(text)
|
|
|
|
|
|
|
|
def draw_bar(self, style, x1, y1, x2, y2):
|
|
|
|
self.__pc.moveto(x1, y1)
|
|
|
|
self.__pc.lineto(x2, y2)
|
|
|
|
|
|
|
|
def draw_text(self,style,text,x1,y1):
|
2004-03-02 06:06:53 +05:30
|
|
|
box_style = self.draw_styles[style]
|
|
|
|
para_style = box_style.get_paragraph_style()
|
|
|
|
fontstyle = para_style.get_font()
|
|
|
|
|
|
|
|
self.__pc.setfont(self.find_font_from_fontstyle(fontstyle))
|
2004-02-29 21:05:44 +05:30
|
|
|
self.__pc.moveto(x1,y1)
|
|
|
|
self.__pc.show(text)
|
|
|
|
|
|
|
|
def center_text(self,style,text,x1,y1):
|
2004-03-02 06:06:53 +05:30
|
|
|
box_style = self.draw_styles[style]
|
|
|
|
para_style = box_style.get_paragraph_style()
|
|
|
|
fontstyle = para_style.get_font()
|
|
|
|
|
2004-02-29 21:05:44 +05:30
|
|
|
#not sure how x1, y1 fit into this
|
|
|
|
#should we assume x1 y1 is the starting location
|
|
|
|
#and that the right margin is the right edge?
|
|
|
|
__width=self.get_text_width(text)
|
|
|
|
__center=self.__right_margin-self.__left_margin
|
|
|
|
__center-=__width/2
|
2004-03-02 06:06:53 +05:30
|
|
|
self.__pc.setfont(self.find_font_from_fontstyle(fontstyle))
|
2004-02-29 21:05:44 +05:30
|
|
|
self.__pc.moveto(__center, self.__y)
|
|
|
|
self.__pc.show(text)
|
|
|
|
|
|
|
|
def rotate_text(self,style,text,x,y,angle):
|
|
|
|
pass
|
|
|
|
|
|
|
|
def draw_line(self,style,x1,y1,x2,y2):
|
|
|
|
self.__pc.line_stroked(x1,y1,x2,y2)
|
|
|
|
|
|
|
|
def write_text(self,text):
|
|
|
|
"""Write the text to the file"""
|
|
|
|
#print "write text"
|
|
|
|
#if we are in a cell add this text to cell_data
|
|
|
|
if self.__in_cell:
|
|
|
|
self.__cell_data=self.__cell_data+str(text)
|
|
|
|
return
|
|
|
|
|
|
|
|
#if we are in a paragraph add this text to the paragraph data
|
|
|
|
if self.__in_paragraph:
|
|
|
|
self.__paragraph_data=self.__paragraph_data+str(text)
|
|
|
|
return
|
|
|
|
|
2004-03-02 07:05:53 +05:30
|
|
|
# write_text() should only be called from within a paragraph!!!
|
|
|
|
#
|
|
|
|
# #if we are at the bottom of the page, create a new page
|
|
|
|
# if self.__y < self.__bottom_margin:
|
|
|
|
# self.end_page()
|
|
|
|
# self.start_page()
|
|
|
|
#
|
|
|
|
# #output data if we get this far (we are not in a paragaph or
|
|
|
|
# #a table)
|
|
|
|
# self.__x, self.__y=self.__print_text(text, self.__x, self.__y,
|
|
|
|
# self.__left_margin, self.__right_margin)
|
|
|
|
# #self.__y=self.__advance_line(self.__y)
|
2004-02-29 21:05:44 +05:30
|
|
|
|
|
|
|
#function to help us advance a line
|
|
|
|
def __advance_line(self, y):
|
2004-03-01 22:20:23 +05:30
|
|
|
return y - _LINE_SPACING
|
2004-02-29 21:05:44 +05:30
|
|
|
|
|
|
|
#function to determine the width of text
|
2004-03-02 06:06:53 +05:30
|
|
|
def __text_width(self, text, fontstyle):
|
|
|
|
font = self.find_font_from_fontstyle(fontstyle)
|
|
|
|
return font.get_width_utf8(text)
|
2004-02-29 21:05:44 +05:30
|
|
|
|
|
|
|
#this function tells us the minimum size that a column can be
|
|
|
|
#by returning the width of the largest word in the text
|
2004-03-02 06:06:53 +05:30
|
|
|
def __min_column_size (self, text,fontstyle):
|
2004-02-29 21:05:44 +05:30
|
|
|
__textlist=string.split(text, " ")
|
|
|
|
__max_word_size=0
|
|
|
|
for __word in __textlist:
|
2004-03-02 06:06:53 +05:30
|
|
|
__length=self.__text_width(__word+" "*3,fontstyle)
|
2004-02-29 21:05:44 +05:30
|
|
|
if __length > __max_word_size:
|
|
|
|
__max_word_size=__length
|
|
|
|
|
|
|
|
return __max_word_size
|
|
|
|
|
2004-03-01 22:20:23 +05:30
|
|
|
#function to fund out the height of the text between left_margin
|
|
|
|
# and right_margin -- kinda like __print_text, but without printing.
|
2004-03-02 06:06:53 +05:30
|
|
|
def __text_height(self, text, width, fontstyle):
|
2004-03-01 22:20:23 +05:30
|
|
|
|
|
|
|
nlines = 1
|
|
|
|
|
2004-03-02 06:06:53 +05:30
|
|
|
if width < self.__text_width(text,fontstyle):
|
2004-03-01 22:20:23 +05:30
|
|
|
#divide up text and print
|
|
|
|
textlist = string.split(text)
|
|
|
|
text = ""
|
|
|
|
for element in textlist:
|
2004-03-02 06:06:53 +05:30
|
|
|
if self.__text_width(text + element + " ",fontstyle) < width:
|
2004-03-01 22:20:23 +05:30
|
|
|
text = text + element + " "
|
|
|
|
else:
|
|
|
|
#__text contains as many words as this __width allows
|
|
|
|
nlines = nlines + 1
|
|
|
|
text = element + " "
|
|
|
|
|
|
|
|
#if __text still contains data, we will want to print it out
|
|
|
|
if text:
|
|
|
|
nlines = nlines + 1
|
|
|
|
|
|
|
|
return nlines * _LINE_SPACING
|
|
|
|
|
2004-03-02 06:06:53 +05:30
|
|
|
def __print_text(self, text, x, y, left_margin, right_margin,fontstyle):
|
2004-02-29 21:05:44 +05:30
|
|
|
__width=right_margin-left_margin
|
2004-03-02 07:05:53 +05:30
|
|
|
|
|
|
|
if y - _LINE_SPACING < self.__bottom_margin:
|
|
|
|
self.end_page()
|
|
|
|
self.start_page()
|
|
|
|
x=self.__x
|
|
|
|
y=self.__y
|
2004-02-29 21:05:44 +05:30
|
|
|
|
|
|
|
#all text will fit within the width provided
|
2004-03-02 06:06:53 +05:30
|
|
|
if __width >= self.__text_width(text,fontstyle):
|
2004-03-02 07:05:53 +05:30
|
|
|
self.__pc.setfont(self.find_font_from_fontstyle(fontstyle))
|
2004-03-01 22:20:23 +05:30
|
|
|
self.__pc.moveto(left_margin, y)
|
2004-03-02 06:06:53 +05:30
|
|
|
x=left_margin+self.__text_width(text,fontstyle)
|
2004-03-01 22:20:23 +05:30
|
|
|
self.__pc.show(text)
|
|
|
|
y=self.__advance_line(y)
|
2004-02-29 21:05:44 +05:30
|
|
|
else:
|
2004-03-01 22:20:23 +05:30
|
|
|
#divide up text and print
|
|
|
|
__textlist=string.split(text, " ")
|
|
|
|
__text=""
|
|
|
|
for __element in __textlist:
|
2004-03-02 06:06:53 +05:30
|
|
|
if self.__text_width(__text+__element+" ",fontstyle) < __width:
|
2004-03-01 22:20:23 +05:30
|
|
|
__text=__text+__element+" "
|
|
|
|
else:
|
|
|
|
#__text contains as many words as this __width allows
|
2004-03-02 07:05:53 +05:30
|
|
|
self.__pc.setfont(self.find_font_from_fontstyle(fontstyle))
|
2004-03-01 22:20:23 +05:30
|
|
|
self.__pc.moveto(left_margin, y)
|
|
|
|
self.__pc.show(__text)
|
|
|
|
__text=__element+" "
|
|
|
|
y=self.__advance_line(y)
|
|
|
|
|
|
|
|
#if not in table and cursor is below bottom margin
|
2004-03-02 07:05:53 +05:30
|
|
|
if (not self.__in_table) and (y < self.__bottom_margin):
|
2004-02-29 21:05:44 +05:30
|
|
|
self.end_page()
|
|
|
|
self.start_page()
|
|
|
|
x=self.__x
|
|
|
|
y=self.__y
|
|
|
|
|
2004-03-01 22:20:23 +05:30
|
|
|
#if __text still contains data, we will want to print it out
|
|
|
|
if len(__text) > 0:
|
2004-03-02 07:05:53 +05:30
|
|
|
self.__pc.setfont(self.find_font_from_fontstyle(fontstyle))
|
2004-03-01 22:20:23 +05:30
|
|
|
self.__pc.moveto(left_margin, y)
|
|
|
|
self.__pc.show(__text)
|
|
|
|
y=self.__advance_line(y)
|
2004-02-29 21:05:44 +05:30
|
|
|
|
|
|
|
return (x,y)
|
|
|
|
|
|
|
|
def __output_table(self):
|
|
|
|
"""do calcs on data in table and output data in a formatted way"""
|
2004-03-01 22:20:23 +05:30
|
|
|
__min_col_size = [self.__right_margin - self.__left_margin] \
|
|
|
|
* self.__ncols
|
|
|
|
__max_vspace = [0] * len(self.__table_data)
|
2004-02-29 21:05:44 +05:30
|
|
|
|
2004-03-01 22:20:23 +05:30
|
|
|
for __row_num in range(len(self.__table_data)):
|
|
|
|
__row = self.__table_data[__row_num][:]
|
|
|
|
#do calcs on each __row and keep track on max length of each column
|
|
|
|
for __col in range(self.__ncols):
|
2004-03-02 06:06:53 +05:30
|
|
|
fontstyle = self.__paragrapgh_styles[__row_num][__col].get_font()
|
|
|
|
|
|
|
|
__min = self.__min_column_size(__row[__col]+" "*3,fontstyle)
|
2004-03-01 22:20:23 +05:30
|
|
|
if __min < __min_col_size[__col]:
|
|
|
|
__min_col_size[__col] = __min
|
2004-02-29 21:05:44 +05:30
|
|
|
|
2004-03-02 06:06:53 +05:30
|
|
|
__max = self.__text_height(__row[__col],
|
|
|
|
self.cell_widths[__col],
|
|
|
|
fontstyle)
|
2004-03-01 22:20:23 +05:30
|
|
|
if __max > __max_vspace[__row_num]:
|
|
|
|
__max_vspace[__row_num] = __max
|
2004-02-29 21:05:44 +05:30
|
|
|
|
|
|
|
#now we have an idea of the max size of each column
|
|
|
|
#now output data in the table
|
|
|
|
#find total width that the table needs to be.
|
|
|
|
#later this value may be used to cut the longest columns down
|
|
|
|
#so that data fits on the width of the page
|
2004-03-01 22:20:23 +05:30
|
|
|
__min_table_width = sum(__min_col_size)
|
2004-02-29 21:05:44 +05:30
|
|
|
|
|
|
|
#is table width larger than the width of the paper?
|
2004-03-01 22:20:23 +05:30
|
|
|
if __min_table_width > (self.__right_margin - self.__left_margin):
|
|
|
|
print "Table does not fit onto the page.\n"
|
2004-02-29 21:05:44 +05:30
|
|
|
|
|
|
|
#for now we will assume left justification of tables
|
|
|
|
#output data in table
|
|
|
|
__min_y=self.__y #need to keep track of tallest column of
|
|
|
|
#text in each row
|
2004-03-01 22:20:23 +05:30
|
|
|
for __row_num in range(len(self.__table_data)):
|
|
|
|
__row = self.__table_data[__row_num]
|
2004-02-29 21:05:44 +05:30
|
|
|
__x=self.__left_margin #reset so that x is at margin
|
2004-03-01 22:20:23 +05:30
|
|
|
# If this row puts us below the bottom, start new page here
|
|
|
|
if self.__y - __max_vspace[__row_num] < self.__bottom_margin:
|
|
|
|
self.end_page()
|
|
|
|
self.start_page()
|
|
|
|
__min_y=self.__y
|
|
|
|
|
2004-02-29 23:12:38 +05:30
|
|
|
for __col in range(self.__ncols):
|
2004-03-02 06:06:53 +05:30
|
|
|
fontstyle = self.__paragrapgh_styles[__row_num][__col].get_font()
|
|
|
|
|
2004-02-29 21:05:44 +05:30
|
|
|
__nothing, __y=self.__print_text(__row[__col],
|
|
|
|
self.__x, self.__y,
|
2004-03-02 06:06:53 +05:30
|
|
|
__x, __x+self.cell_widths[__col],
|
|
|
|
fontstyle)
|
2004-02-29 21:05:44 +05:30
|
|
|
|
2004-03-01 22:20:23 +05:30
|
|
|
__x=__x+self.cell_widths[__col] # set up margin for this row
|
2004-02-29 21:05:44 +05:30
|
|
|
if __y < __min_y: # if we go below current lowest
|
|
|
|
__min_y=__y # column
|
|
|
|
|
|
|
|
self.__y=__min_y #reset so that we do not overwrite
|
|
|
|
|
|
|
|
#function to print text to a printer
|
|
|
|
def __do_print(self,dialog, job):
|
|
|
|
__pc = gnomeprint.Context(dialog.get_config())
|
|
|
|
job.render(__pc)
|
|
|
|
__pc.close()
|
|
|
|
|
|
|
|
#I believe this is a print preview
|
|
|
|
def __show_preview(self, dialog):
|
|
|
|
__w = gnomeprint.ui.JobPreview(self.__job, _("Print Preview"))
|
|
|
|
__w.set_property('allow-grow', 1)
|
|
|
|
__w.set_property('allow-shrink', 1)
|
|
|
|
__w.set_transient_for(dialog)
|
|
|
|
__w.show_all()
|
|
|
|
|
|
|
|
#function used to get users response and do a certain
|
|
|
|
#action depending on that response
|
|
|
|
def __print_dialog_response(self, dialog, resp, job):
|
|
|
|
if resp == gnomeprint.ui.DIALOG_RESPONSE_PREVIEW:
|
|
|
|
self.__show_preview(dialog)
|
|
|
|
elif resp == gnomeprint.ui.DIALOG_RESPONSE_CANCEL:
|
|
|
|
dialog.destroy()
|
|
|
|
elif resp == gnomeprint.ui.DIALOG_RESPONSE_PRINT:
|
|
|
|
self.__do_print(dialog, self.__job)
|
|
|
|
dialog.destroy()
|
|
|
|
|
|
|
|
#function displays a window that allows user to choose
|
|
|
|
#to print, show, etc
|
|
|
|
def __show_print_dialog(self):
|
|
|
|
__dialog = gnomeprint.ui.Dialog(self.__job, _("Print..."), 0)
|
|
|
|
__dialog.connect('response', self.__print_dialog_response, self.__job)
|
|
|
|
__dialog.show()
|
|
|
|
|
|
|
|
#------------------------------------------------------------------------
|
|
|
|
#
|
|
|
|
# Register the document generator with the system
|
|
|
|
#
|
|
|
|
#------------------------------------------------------------------------
|
|
|
|
Plugins.register_text_doc(
|
|
|
|
name=_("Print..."),
|
|
|
|
classref=LPRDoc,
|
|
|
|
table=1,
|
|
|
|
paper=1,
|
2004-03-02 06:06:53 +05:30
|
|
|
style=1,
|
2004-02-29 21:05:44 +05:30
|
|
|
ext=""
|
|
|
|
)
|