# # 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 # # Written by Billy C. Earney, 2003-2004 # Modified by Alex Roitman, 2004 # $Id$ """LPR document generator""" #------------------------------------------------------------------------ # # python modules # #------------------------------------------------------------------------ import string from gettext import gettext as _ #------------------------------------------------------------------------ # # GNOME/GTK Modules # #------------------------------------------------------------------------ import gtk.gdk ### FIXME ### # This is a dirty workaround for incomplete gnomeprint bindings. # Switching to local pygtk version before importing gnomeprint # (I have CVS version installed locally) import sys newpath = [ '/usr/local/lib/python2.3', '/usr/local/lib/python2.3/site-packages', '/usr/local/lib/python2.3/site-packages/gtk-2.0' ] sys.path = newpath + sys.path ### end FIXME ### import gnomeprint, gnomeprint.ui if gnomeprint.Context.__dict__.has_key('grestore'): support_photos = 1 else: support_photos = 0 print "LPRDoc: Photos and rotated text (used in TimeChart)" print "are not supported for direct priting." print "Get gnome-python from CVS or wait for the next gnome-python release." #------------------------------------------------------------------------ # # gramps modules # #------------------------------------------------------------------------ import BaseDoc import Plugins import ImgManip #------------------------------------------------------------------------ # # Constants # #------------------------------------------------------------------------ # Spacing in points (distance between the bottoms of two adjacent lines) _LINE_SPACING = 20 # Elevation of superscripts: a fraction of it's size _SUPER_ELEVATION_FRACTION = 0.3 # Number of points to subtract to get the superscrip size _SUPER_SIZE_REDUCTION = 2 # Font constants -- specific for gnome-print _FONT_SANS_SERIF = "Arial" _FONT_SERIF = "Times New Roman" _FONT_MONOSPACE = "Courier New" _FONT_BOLD = "Bold" _FONT_ITALIC = "Italic" _FONT_BOLD_ITALIC = "Bold Italic" _FONT_REGULAR = "Regular" # Formatting directive constants _LINE_BREAK = "Break" _BOLD = "Bold" _SUPER = "Super" _MONO = "Mono" #------------------------------------------------------------------------ # # Units conversion # #------------------------------------------------------------------------ def cm2u(cm): """ Convert cm to gnome-print units """ return cm * 72.0 / 2.54 #------------------------------------------------------------------------ # # font lookup function # #------------------------------------------------------------------------ def find_font_from_fontstyle(fontstyle): """ This function returns the gnomeprint.Font() object instance corresponding to the parameters of BaseDoc.FontStyle() object. fontstyle - a BaseDoc.FontStyle() instance """ 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) #------------------------------------------------------------------------ # # basic font-specific text formatting functions # #------------------------------------------------------------------------ def get_text_width(text,fontstyle): """ This function returns the width of text using given fontstyle when not formatted. text - a text whose width to find fontstyle - a BaseDoc.FontStyle() instance """ font = find_font_from_fontstyle(fontstyle) return font.get_width_utf8(text) #------------------------------------------------------------------------ # # add to paragraph taking care of the newline characters # #------------------------------------------------------------------------ def append_to_paragraph(paragraph,directive,text): """ Add a piece to the paragraph while taking care of the newline characters. paragraph - a GnomePrintParagraph() instance directive - what to do with this piece text - the text of the corresponding piece """ if not directive and not text: return text_list = text.split('\n') for the_text in text_list[:-1]: paragraph.add_piece(directive,the_text) paragraph.add_piece(_LINE_BREAK,"") paragraph.add_piece(directive,text_list[-1:][0]) #------------------------------------------------------------------------ # # Paragraph class # #------------------------------------------------------------------------ class GnomePrintParagraph: """ A paragraph abstraction which provides the means for in-paragraph formatting. """ def __init__(self,paragraph_style): """ Creates a GnomePrintParapgrah instance. paragraph_style - an instance of BaseDoc paragraph style object """ self.style = paragraph_style self.fontstyle = self.style.get_font() self.piece_list = [] self.lines = [] self.height = None def add_piece(self,directive,text): """ Add a piece to the paragraph. directive - what to do with this piece text - the text of the corresponding piece """ self.piece_list.append((directive,text)) def get_piece_list(self): """ Return a list of pieces for the paragraph. """ return self.piece_list def get_fontstyle(self): """ Return fontstyle for the paragraph """ return self.fontstyle def get_alignment(self): """ Return requested alignment of the paragraph """ return self.style.get_alignment() def get_min_width(self): """ Determine the minimal width of the paragraph (longest word) """ max_word_size = 0 for (directive,text) in self.piece_list: fontstyle = BaseDoc.FontStyle(self.fontstyle) if directive == _BOLD: fontstyle.set_bold(1) elif directive == _SUPER: size = fontstyle.get_size() fontstyle.set_size(size-_SUPER_SIZE_REDUCTION) elif directive == _MONO: fontstyle.set_type_face(BaseDoc.FONT_MONOSPACE) for word in text.split(): length = get_text_width(word,fontstyle) if length > max_word_size: max_word_size = length return max_word_size def get_height(self,width): """ Determine the height the paragraph would have if formatted for a given width. width - required formatting width """ if not self.lines: self.format(width) return self.height def format(self,width): """ Format the paragraph for a given width. This is a complex procedure. It assembles lines from the paragraph's pieces. It also sets the height of the whole paragraph and the widths available after the lines are assembled. width - required formatting width """ if self.lines: return width = width - cm2u(self.style.get_right_margin()) \ - cm2u(self.style.get_left_margin()) nlines = 1 avail_width = width start_piece = end_piece = start_word = end_word = 0 first = 1 for piece_num in range(len(self.piece_list)): end_piece = piece_num (directive,text) = self.piece_list[piece_num] fontstyle = BaseDoc.FontStyle(self.fontstyle) if directive == _BOLD: fontstyle.set_bold(1) elif directive == _SUPER: size = fontstyle.get_size() fontstyle.set_size(size-_SUPER_SIZE_REDUCTION) elif directive == _MONO: fontstyle.set_type_face(BaseDoc.FONT_MONOSPACE) if first: first = 0 avail_width = avail_width - cm2u(self.style.get_first_indent()) if text and avail_width > get_text_width(text,fontstyle): avail_width -= get_text_width(text,fontstyle) end_word = len(text.split()) elif directive == _LINE_BREAK: nlines += 1 end_word = 0 self.lines.append((start_piece,start_word,end_piece,end_word,avail_width)) avail_width = width start_piece = end_piece start_word = 0 elif text and avail_width <= get_text_width(text,fontstyle): # divide up text textlist = text.split() the_text = "" for word_num in range(len(textlist)): word = textlist[word_num] if get_text_width(the_text + word + " ",fontstyle) <= avail_width: the_text = the_text + word + " " else: # the_text contains as much as avail_width allows nlines += 1 end_word = word_num avail_width -= get_text_width(the_text,fontstyle) self.lines.append((start_piece,start_word,end_piece,end_word,avail_width)) avail_width = width the_text = word + " " start_piece = end_piece start_word = word_num # if the_text still contains data, we will want to print it out if the_text: avail_width = width - get_text_width(the_text,fontstyle) end_word = len(textlist) self.lines.append((start_piece,start_word,end_piece,end_word,avail_width)) self.height = nlines * self.fontstyle.get_size() \ + 2 * cm2u(self.style.get_padding()) def get_lines(self): """ Return a list of assemlbed lines for the paragraph. Each element is a tuple corresponding to the line's contents: (start_piece,start_word,end_piece,end_word,avail_width) """ return self.lines #------------------------------------------------------------------------ # # Photo class # #------------------------------------------------------------------------ class GnomePrintPhoto: """ A photo abstraction which provides the means for correct photo placement. Way less complex that paragraph, but still useful. """ def __init__(self,name,pos,x_size,y_size): """ Creates a GnomePrintPhoto instance. """ self.name = name self.alignment = pos self.pixbuf = gtk.gdk.pixbuf_new_from_file(name) self.height = self.pixbuf.get_height() self.width = self.pixbuf.get_width() max_size = cm2u(max(x_size,y_size)) self.scale_x = int( max_size * float(self.width)/max(self.height,self.width) ) self.scale_y = int( max_size * float(self.height)/max(self.height,self.width) ) def get_image(self): """ Return the raw image of the photo. """ return self.pixbuf.get_pixels() def get_has_alpha(self): """ Return has_alpha of the photo. """ return self.pixbuf.get_has_alpha() def get_rowstride(self): """ Return the rowstride of the photo. """ return self.pixbuf.get_rowstride() def get_height(self,width=None): """ Return the real height of the photo as it should appear on the page. """ return self.scale_y def get_width(self): """ Return the real width of the photo as it should appear on the page. """ return self.scale_x def get_min_width(self): """ Return the minimum width of the photo as it should appear on the page. """ return self.scale_x def get_image_height(self): """ Return the height of the photo in terms of image's pixels. """ return self.height def get_image_width(self): """ Return the width of the photo in terms of image's pixels. """ return self.width #------------------------------------------------------------------------ # # LPRDoc class # #------------------------------------------------------------------------ class LPRDoc(BaseDoc.BaseDoc): """Gnome-print document interface class. Derived from BaseDoc""" #------------------------------------------------------------------------ # # General methods # #------------------------------------------------------------------------ def open(self,filename): """Sets up initialization""" #set up variables needed to keep track of which state we are in self.__in_table = 0 self.__in_cell = 0 self.__page_count = 0 self.__page_open = 0 self.paragraph = None self.__cell_data = [] self.__table_data = [] #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 width, height = gnomeprint.job_get_page_size_from_config(self.__job.get_config()) 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()) self.start_page(self) def close(self): """Clean up and close the document""" #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 start_page(self,orientation=None): """Create a new 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""" if (self.__page_open): self.__page_open = 0 self.__pc.showpage() self.__y -= self.top_margin + _LINE_SPACING def page_break(self): "Forces a page break, creating a new page" # If we're already at the very top, relax and do nothing if self.__y != self.top_margin: self.end_page() self.start_page() #------------------------------------------------------------------------ # # Text methods # #------------------------------------------------------------------------ def line_break(self): "Forces a line break within a paragraph" # Add previously held text to the paragraph, # then add line break directive, # then start accumulating further text append_to_paragraph(self.paragraph,self.__paragraph_directive,self.__paragraph_text) self.paragraph.add_piece(_LINE_BREAK,"") self.__paragraph_text = "" 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.""" # Instantiate paragraph object and initialize buffers self.paragraph = GnomePrintParagraph(self.style_list[style_name]) self.__paragraph_directive = "" self.__paragraph_text = "" if leader: self.__paragraph_text += leader + " " def end_paragraph(self): """End the current paragraph""" # Add current text/directive to paragraoh, # then either add paragrah to the list of cell's paragraphs # or print it right away if not in cell append_to_paragraph(self.paragraph,self.__paragraph_directive,self.__paragraph_text) if self.__in_cell: # We're inside cell. Add paragrah to celldata self.__cell_data.append(self.paragraph) else: # paragraph not in table: write it right away self.__x, self.__y = self.write_paragraph(self.paragraph, self.__x, self.__y, self.right_margin - self.left_margin) self.paragraph = None def start_bold(self): """Bold face""" append_to_paragraph(self.paragraph,self.__paragraph_directive,self.__paragraph_text) self.__paragraph_directive = _BOLD self.__paragraph_text = "" def end_bold(self): """End bold face""" append_to_paragraph(self.paragraph,self.__paragraph_directive,self.__paragraph_text) self.__paragraph_directive = "" self.__paragraph_text = "" def start_superscript(self): append_to_paragraph(self.paragraph,self.__paragraph_directive,self.__paragraph_text) self.__paragraph_directive = _SUPER self.__paragraph_text = "" def end_superscript(self): append_to_paragraph(self.paragraph,self.__paragraph_directive,self.__paragraph_text) self.__paragraph_directive = "" self.__paragraph_text = "" def start_table(self,name,style_name): """Begin new table""" # initialize table, compute its width, find number of columns self.__table_data = [] self.__in_table = 1 self.__tbl_style = self.table_styles[style_name] self.__ncols = self.__tbl_style.get_columns() self.rownum = -1 self.__table_width = (self.right_margin - self.left_margin) * \ self.__tbl_style.get_width() / 100.0 self.__cell_widths = [] self.__cell_styles = [] def end_table(self): """Close the table environment""" # 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""" # Initialize row, compute cell widths self.__row_data = [] self.rownum = self.rownum + 1 self.cellnum = -1 self.__span = 1 self.__cell_widths.append([0] * self.__ncols) self.__cell_styles.append([None] * self.__ncols) for cell in range(self.__ncols): self.__cell_widths[self.rownum][cell] = self.__table_width * \ self.__tbl_style.get_column_width(cell) / 100.0 def end_row(self): """End the row (new line)""" # 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.""" # Initialize a cell, take care of span>1 cases self.__in_cell = 1 self.__cell_data = [] self.cellnum = self.cellnum + self.__span self.__span = span self.__cell_styles[self.rownum][self.cellnum] = \ self.cell_styles[style_name] for __extra_cell in range(1,span): self.__cell_widths[self.rownum][self.cellnum] += \ self.__cell_widths[self.rownum][self.cellnum + __extra_cell] self.__cell_widths[self.rownum][self.cellnum + __extra_cell] = 0 def end_cell(self): """Prepares for next 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""" photo = GnomePrintPhoto(name,pos,x,y) if self.__in_cell: # We're inside cell. Add photo to celldata self.__cell_data.append(photo) else: # photo not in table: write it right away self.__x, self.__y = self.write_photo(photo, self.__x, self.__y, self.right_margin - self.left_margin) def write_photo(self,photo,x,y,width): """ Write the photo. photo - GnomePrintPhoto instance x,y - coordinates to start at width - allocated width """ # FIXME -- remove when gnome-python is released and hits every distro if not support_photos: return (x,y) # end FIXME width = photo.get_width() height = photo.get_height() if y - height < self.bottom_margin: self.end_page() self.start_page() y = self.__y self.__pc.gsave() self.__pc.translate(x,y-height) self.__pc.scale(width,height) if photo.get_has_alpha(): self.__pc.rgbaimage(photo.get_image(), photo.get_image_width(), photo.get_image_height(), photo.get_rowstride()) else: self.__pc.rgbimage(photo.get_image(), photo.get_image_width(), photo.get_image_height(), photo.get_rowstride()) self.__pc.grestore() x = x y = y - height return (x,y) def write_text(self,text): """Add the text to the paragraph""" # Take care of superscript tags super_count = text.count('') for num in range(super_count): start = text.find('') self.__paragraph_text = self.__paragraph_text + text[:start] append_to_paragraph(self.paragraph,self.__paragraph_directive,self.__paragraph_text) self.__paragraph_text = "" text = text[start+7:] start = text.find('') self.__paragraph_text = self.__paragraph_text + text[:start] append_to_paragraph(self.paragraph,_SUPER,self.__paragraph_text) self.__paragraph_text = "" text = text[start+8:] self.__paragraph_text = self.__paragraph_text + text def write_note(self,text,format,style_name): if format == 1: for line in text.split('\n'): self.start_paragraph(style_name) self.__paragraph_directive = _MONO self.write_text(line) self.end_paragraph() elif format == 0: for line in text.split('\n\n'): self.start_paragraph(style_name) line = line.replace('\n',' ') line = string.join(string.split(line)) self.write_text(line) self.end_paragraph() #function to help us advance a line def __advance_line(self,y,paragraph=None): if paragraph: spacing = paragraph.fontstyle.get_size() else: spacing = _LINE_SPACING new_y = y - spacing if y < self.bottom_margin: x = self.__x self.end_page() self.start_page() new_y = self.__y self.__x = x return new_y def write_paragraph(self,paragraph,x,y,width): """ Write the contents of the paragraph, observing per-piece info. paragraph - GnomePrintParagraph instance x,y - coordinates to start at width - allocated width """ if not paragraph.get_piece_list(): return (x,y) paragraph.format(width) x = x + cm2u(paragraph.style.get_left_margin()) width = width - cm2u(paragraph.style.get_right_margin()) \ - cm2u(paragraph.style.get_left_margin()) left_margin = x no_space = 0 first = 1 if y - paragraph.fontstyle.get_size() < self.bottom_margin: self.end_page() self.start_page() x = left_margin y = self.__y if y != self.top_margin: y = y - cm2u(paragraph.style.get_padding()) # Loop over lines which were assembled by paragraph.format() for (start_piece,start_word,end_piece,end_word,avail_width) \ in paragraph.get_lines(): if paragraph.get_alignment() == BaseDoc.PARA_ALIGN_CENTER: x = x + 0.5 * avail_width elif paragraph.get_alignment() == BaseDoc.PARA_ALIGN_RIGHT: x = x + avail_width elif paragraph.get_alignment() == BaseDoc.PARA_ALIGN_LEFT: pass elif paragraph.get_alignment() == BaseDoc.PARA_ALIGN_JUSTIFY: print "Paragraph justification not supported." print "Falling back to left-justified mode." if first: first = 0 x = x + cm2u(paragraph.style.get_first_indent()) y = y - paragraph.fontstyle.get_size() # Loop over pieces that constitute the line for piece_num in range(start_piece,end_piece+1): (directive,text) = paragraph.get_piece_list()[piece_num] fontstyle = BaseDoc.FontStyle(paragraph.get_fontstyle()) if directive == _BOLD: fontstyle.set_bold(1) elif directive == _SUPER: size = fontstyle.get_size() fontstyle.set_size(size-_SUPER_SIZE_REDUCTION) y = y + _SUPER_ELEVATION_FRACTION * fontstyle.get_size() elif directive == _MONO: fontstyle.set_type_face(BaseDoc.FONT_MONOSPACE) textlist = text.split() if start_piece == end_piece: the_textlist = textlist[start_word:end_word] elif piece_num > start_piece and piece_num < end_piece: the_textlist = textlist[:] elif piece_num == start_piece: the_textlist = textlist[start_word:] elif piece_num == end_piece: the_textlist = textlist[:end_word] the_text = string.join(the_textlist) if piece_num == start_piece \ or directive == _SUPER \ or no_space \ or (the_text and the_text[0] in string.punctuation): spacer = "" else: spacer = " " the_text = spacer + the_text self.__pc.setfont(find_font_from_fontstyle(fontstyle)) self.__pc.moveto(x, y) self.__pc.show(the_text) x = x + get_text_width(the_text,fontstyle) if directive == _SUPER: y = y - _SUPER_ELEVATION_FRACTION * fontstyle.get_size() # If this was the linebreak, no space on the next line's start if end_word: no_space = 0 else: no_space = 1 y = self.__advance_line(y,paragraph) x = left_margin x = x - cm2u(paragraph.style.get_left_margin()) y = y - cm2u(paragraph.style.get_padding()) return (x,y) def __output_table(self): """do calcs on data in table and output data in a formatted way""" __min_col_size = [0] * self.__ncols __max_vspace = [0] * len(self.__table_data) 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): if not self.__cell_widths[__row_num][__col]: continue padding = cm2u(self.__cell_styles[__row_num][__col].get_padding()) __max = 0 for paragraph in __row[__col]: __min = paragraph.get_min_width() if __min > __min_col_size[__col]: __min_col_size[__col] = __min __max += paragraph.get_height( self.__cell_widths[__row_num][__col]) __max += 2 * padding if __max > __max_vspace[__row_num]: __max_vspace[__row_num] = __max #is table width larger than the width of the paper? __min_table_width = 0 for __size in __min_col_size: __min_table_width = __min_table_width + __size if __min_table_width > (self.right_margin - self.left_margin): print "Table does not fit onto the page.\n" #for now we will assume left justification of tables #output data in table for __row_num in range(len(self.__table_data)): __row = self.__table_data[__row_num] # 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() __x = self.left_margin #reset so that x is at margin col_y = self.__y # all columns start at the same height for __col in range(self.__ncols): if not self.__cell_widths[__row_num][__col]: continue self.__y = col_y padding = cm2u(self.__cell_styles [__row_num][__col].get_padding()) for paragraph in __row[__col]: if paragraph.__class__.__name__ == 'GnomePrintPhoto': write_item = self.write_photo else: write_item = self.write_paragraph junk, self.__y = write_item(paragraph, __x + padding, self.__y - padding, self.__cell_widths[__row_num][__col] \ - 2 * padding) __x = __x + self.__cell_widths[__row_num][__col] # set up margin for this row self.__y = col_y - __max_vspace[__row_num] #------------------------------------------------------------------------ # # Graphic methods # #------------------------------------------------------------------------ def horizontal_line(self): self.__pc.moveto(self.left_margin, self.__y) self.__pc.lineto(self.right_margin, self.__y) def draw_path(self,style,path): stype = self.draw_styles[style] color = [ val/255.0 for val in stype.get_fill_color()] point = path[0] x = cm2u(point[0]) + self.left_margin y = self.top_margin - cm2u(point[1]) self.__pc.moveto(x,y) for point in path[1:]: x = cm2u(point[0]) + self.left_margin y = self.top_margin - cm2u(point[1]) self.__pc.lineto(x,y) self.__pc.closepath() self.__pc.stroke() point = path[0] x = cm2u(point[0]) + self.left_margin y = self.top_margin - cm2u(point[1]) self.__pc.moveto(x,y) for point in path[1:]: x = cm2u(point[0]) + self.left_margin y = self.top_margin - cm2u(point[1]) self.__pc.lineto(x,y) self.__pc.closepath() self.__pc.setrgbcolor(color[0],color[1],color[2]) self.__pc.fill() self.__pc.setrgbcolor(0,0,0) def draw_box(self,style,text,x,y): #assuming that we start drawing box from current position x = self.left_margin + cm2u(x) y = self.top_margin - cm2u(y) box_style = self.draw_styles[style] para_name = box_style.get_paragraph_style() para_style = self.style_list[para_name] fontstyle = para_style.get_font() bh = cm2u(box_style.get_height()) bw = cm2u(box_style.get_width()) self.__pc.rect_stroked(x,y,bw,-bh) if text: lines = text.split('\n') start_x = x + 0.5 * fontstyle.get_size() start_y = y - fontstyle.get_size() for line in lines: if not line.split(): continue self.__pc.setfont(find_font_from_fontstyle(fontstyle)) self.__pc.moveto(start_x,start_y) self.__pc.show(line) start_y -= fontstyle.get_size() def write_at (self, style, text, x, y): para_style = self.style_list[style] fontstyle = para_style.get_font() self.__pc.setfont(find_font_from_fontstyle(fontstyle)) self.__pc.moveto(cm2u(x), cm2u(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,x,y): box_style = self.draw_styles[style] para_name = box_style.get_paragraph_style() para_style = self.style_list[para_name] fontstyle = para_style.get_font() start_x = self.left_margin + cm2u(x) start_y = self.top_margin - cm2u(y) - fontstyle.get_size() self.__pc.setfont(find_font_from_fontstyle(fontstyle)) self.__pc.moveto(start_x,start_y) self.__pc.show(text) def center_text(self,style,text,x,y): box_style = self.draw_styles[style] para_name = box_style.get_paragraph_style() para_style = self.style_list[para_name] fontstyle = para_style.get_font() width = get_text_width(text,fontstyle) start_x = self.left_margin + cm2u(x) - 0.5 * width self.__pc.setfont(find_font_from_fontstyle(fontstyle)) self.__pc.moveto(start_x, self.top_margin - cm2u(y) - fontstyle.get_size()) self.__pc.show(text) def rotate_text(self,style,text,x,y,angle): # FIXME - remove when new gnome-python is in all distros if not support_photos: return # end FIXME box_style = self.draw_styles[style] para_name = box_style.get_paragraph_style() para_style = self.style_list[para_name] fontstyle = para_style.get_font() y_start = self.top_margin - cm2u(y) x_start = self.left_margin + cm2u(x) size = fontstyle.get_size() self.__pc.gsave() self.__pc.translate(x_start,y_start) self.__pc.rotate(-angle) this_y = 0 for line in text: if not line.split(): continue width = get_text_width(line,fontstyle) this_x = -0.5 * width self.__pc.setfont(find_font_from_fontstyle(fontstyle)) self.__pc.moveto(this_x,this_y) self.__pc.show(line) this_y -= size self.__pc.grestore() def draw_line(self,style,x1,y1,x2,y2): x1 = cm2u(x1) + self.left_margin x2 = cm2u(x2) + self.left_margin y1 = self.top_margin - cm2u(y1) y2 = self.top_margin - cm2u(y2) self.__pc.line_stroked(x1,y1,x2,y2) #------------------------------------------------------------------------ # # Print job methods # #------------------------------------------------------------------------ #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, style=1, ext="" ) Plugins.register_book_doc( _("Print..."), LPRDoc, 1, 1, 1, "") Plugins.register_draw_doc( _("Print..."), LPRDoc, 1, 1, "");