gramps/src/docgen/GtkPrint.py

#
# Gramps - a GTK+/GNOME based genealogy program
#
# Copyright (C) 2000-2007  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
#

# $Id: PdfDoc.py 7855 2006-12-29 03:58:26Z dallingham $

#------------------------------------------------------------------------
#
# Python modules
#
#------------------------------------------------------------------------
from gettext import gettext as _

#------------------------------------------------------------------------
#
# gramps modules
#
#------------------------------------------------------------------------
import BaseDoc
from PluginUtils import register_text_doc, register_draw_doc, register_book_doc
import Errors

#------------------------------------------------------------------------
#
# Set up logging
#
#------------------------------------------------------------------------
import logging
log = logging.getLogger(".GtkDoc")

#------------------------------------------------------------------------
#
# GtkPrint 
#
#------------------------------------------------------------------------

import pygtk
import gtk

if not hasattr(gtk, "PrintOperation"):
    raise Errors.UnavailableError(
        _("Cannot be loaded because PyGtk 2.10 or later is not installed"))

import cairo
import pango


#------------------------------------------------------------------------
#
# PreviewCanvas and PreviewWindow
#
# These classes provide a simple print preview functionality.
# They do not actually render anything themselves, they rely
# upon the Print opertaion to do the rendering.
#
#------------------------------------------------------------------------
class PreviewCanvas(gtk.DrawingArea):
    """This provides a simple widget for displaying a
    cairo rendering used to show print preview windows.
    """
    
    def __init__(self,
                 operation,
                 preview_operation,
                 print_context):
        gtk.DrawingArea.__init__(self)
        self._operation = operation
        self._preview_operation = preview_operation
        self._print_context = print_context

        self.connect("expose_event",self.expose)
        self.connect("realize",self.realize)
        
        self._page_no = 1 # always start on page 1


    def set_page(self,page):
        """Change which page is displayed"""
        if page > 0:
            self._page_no = page
            self.queue_draw()
        
    def realize(self, dummy=None):
        """Generate the cairo context for this drawing area
        and pass it to the print context."""
        gtk.DrawingArea.realize(self)
        self._context = self.window.cairo_create()
        self._print_context.set_cairo_context(self._context,72,72)

    def expose(self, widget, event):
        """Ask the print operation to actually draw the page."""
        self.window.clear()
        self._preview_operation.render_page(self._page_no)

        # need to calculate how large the widget now is and
        # set it so that the scrollbars are updated.
        # I can't work out how to do this.
        #self.set_size_request(200, 300)

    
class PreviewWindow(gtk.Window):
    """A dialog to show a print preview."""
    
    def __init__(self,
                 operation,
                 preview_operation,
                 print_context,
                 parent):
        gtk.Window.__init__(self)
        self.set_default_size(640, 480)

        self._operation = operation
        self._preview_operation = preview_operation

        self.connect("delete_event", self.delete_event)

        self.set_title("Print Preview")
        self.set_transient_for(parent)

        # Setup widgets
        self._vbox = gtk.VBox()
        self.add(self._vbox)
        self._spin = gtk.SpinButton()
        self._spin.set_value(1)
        
        self._close_bt = gtk.Button(stock=gtk.STOCK_CLOSE)
        self._close_bt.connect("clicked",self.close)
                               
        self._hbox = gtk.HBox()
        self._hbox.pack_start(self._spin)
        self._hbox.pack_start(self._close_bt,expand=False)
        self._vbox.pack_start(self._hbox,expand=False)


        self._scroll = gtk.ScrolledWindow(None,None)
        self._canvas = PreviewCanvas(operation,preview_operation,print_context)
        self._scroll.add_with_viewport(self._canvas)
        self._vbox.pack_start(self._scroll,expand=True,fill=True)

        # The print operation does not know how many pages there are until
        # after the first expose event, so we use the expose event to
        # trigger an update of the spin box.
        # This still does not work properly, sometimes the first expose event
        # happends before this gets connected and the spin box does not get
        # updated, I am probably just not doing it very cleverly.
        self._change_n_pages_connect_id = self._canvas.connect("expose_event", self.change_n_pages)
        self._spin.connect("value-changed",
                           lambda spinbutton: self._canvas.set_page(spinbutton.get_value_as_int()))
        
        self._canvas.set_double_buffered(False)

        self.show_all()



    def change_n_pages(self, widget, event ):
        """Update the spin box to have the correct number of pages for the
        print operation"""
        n_pages = self._preview_operation.get_property("n_pages")
        
        if n_pages != -1:
            # As soon as we have a valid number of pages we no
            # longer need this call back so we can disconnect it.
            self._canvas.disconnect(self._change_n_pages_connect_id)
            
        value = int(self._spin.get_value())
        if value == -1: value = 1
        self._spin.configure(gtk.Adjustment(value,1,
                                            n_pages,
                                            1,1,1),1,0)

    def end_preview(self):
        self._operation.end_preview()
        
    def delete_event(self, widget, event, data=None):
        self.end_preview()
        return False

    def close(self,btn):
        self.end_preview()
        self.destroy()

        # I am not sure that this is the correct way to do this
        # but I expect the print dialog to reappear after I
        # close the print preview button.
        self._operation.do_print()
        return False       

#------------------------------------------------------------------------
#
# 
#
#------------------------------------------------------------------------
def paperstyle_to_pagesetup(paper_style):
    """convert a gramps paper_style instance into a gtk.PageSetup instance.
    """
    page_setup = gtk.PageSetup()
    if paper_style.get_orientation() == BaseDoc.PAPER_PORTRAIT:
        page_setup.set_orientation(gtk.PAGE_ORIENTATION_PORTRAIT)
    else:
        page_setup.set_orientation(gtk.PAGE_ORIENTATION_LANDSCAPE)

    gpaper_size = paper_style.get_size()

    # This causes my gtk to seg fault.
    paper_size = gtk.PaperSize('na_'+paper_style.get_size().get_name().lower())
    if paper_size.is_custom():
        paper_size.set_size(paper_style.get_width()*10,
                            paper_style.get_height()*10,
                            gtk.UNIT_MM)
        
    # So we just to this instead.
    # This does not appear to work either, it reports an
    # GtkWarning: gtk_paper_size_set_size: assertion `size->is_custom' failed
    # But I don't know how to tell it that it is custom without it segfaulting.
##     paper_size = gtk.PaperSize()
##     paper_size.set_size(gpaper_size.get_width()*10,
##                         gpaper_size.get_height()*10,
##                         gtk.UNIT_MM)

    page_setup.set_paper_size(paper_size)

    return page_setup
    
class PrintFacade(gtk.PrintOperation):
    """Provides the main print operation functions."""
    
    def __init__(self, renderer,page_setup):
        """
        render must be an object with the following interface:
           render: callable that takes (operation, context, page_nr)
                   it should render the page_nr page onto the provided context.
           get_n_pages: a callable that takes (operation, context) and
                        returns the number of pages that would be needed to render
                        onto the given context.
        """
        gtk.PrintOperation.__init__(self)

        self._renderer = renderer
        
        self.set_default_page_setup(page_setup)
        
        self.connect("begin_print", self.begin_print)
        self.connect("draw_page", self.draw_page)
        self.connect("paginate", self.paginate)
        self.connect("preview", self.preview)        

        self._settings = None
        self._print_op = None
        
    def begin_print(self,operation, context):
        operation.set_n_pages(self._renderer.get_n_pages(operation, context))

    def paginate(self, operation, context):
        return True

    def preview(self, operation, preview, context, parent, dummy=None):
        preview = PreviewWindow(self,preview,context,parent)
        return True
        
    def draw_page(self,operation, context, page_nr):
        self._renderer.render(operation, context, page_nr)
        
    def do_print(self, widget=None, data=None):
        """This is the method that actually runs the Gtk Print operation."""

        # We need to store the settings somewhere so that they are remembered
        # each time the dialog is restarted.
        if self._settings != None:
            self.set_print_settings(self._settings)

        res = self.run(gtk.PRINT_OPERATION_ACTION_PRINT_DIALOG, None)
        
        if res == gtk.PRINT_OPERATION_RESULT_APPLY:
            self._settings = self.get_print_settings()


#------------------------------------------------------------------------
#
# CairoJob and GtkDoc
#
# These classes to the real work. GtkDoc provides the BaseDoc interface
# and CairoJob performs the job that gnomeprintjob does. It has to
# maintain an abstract model of the document and then render it onto
# a cairo context when asked.
#
#------------------------------------------------------------------------
class CairoJob(object):
    """Class to act as a abstract document that can render onto a
    cairo context."""

    def __init__(self):
        self._doc = []

    #
    # interface required for PrintFacade
    #
    def render(self, operation, context, page_nr):
        """Renders the document on the cairo context.
        A useful reference is: http://www.tortall.net/mu/wiki/CairoTutorial
        """
        cr = context.get_cairo_context()

        y = 20
        x = 30

        text="\n".join(self._doc)
        
        # Draw some text
        layout = context.create_pango_layout()
        layout.set_text(text)
        desc = pango.FontDescription("sans 28")
        layout.set_font_description(desc)

        cr.move_to(x, y)
        cr.show_layout(layout)


    def get_n_pages(self, operation, context):
        """return the number of pages required to print onto the
        provided context."""

        return 3
    
    #
    # methods to add content to abstract document.
    #

    def write_text(self,text):
        self._doc.append(text)
        
#------------------------------------------------------------------------
#
# 
#
#------------------------------------------------------------------------
class GtkDoc(BaseDoc.BaseDoc,BaseDoc.TextDoc,BaseDoc.DrawDoc):

    def open(self,filename):
        self._job = CairoJob()
    
    def close(self):
        PrintFacade(self._job,
                    paperstyle_to_pagesetup(self.paper)).do_print()
        
    def page_break(self):
        pass

    def start_paragraph(self,style_name,leader=None):
        pass
    
    def end_paragraph(self):
        pass
    
    def start_bold(self):
        pass
    
    def end_bold(self):
        pass
    
    def start_superscript(self):
        pass
    
    def end_superscript(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 add_media_object(self,name,pos,x_cm,y_cm):
        pass
    
    def write_note(self,text,format,style_name):
        print "write_note: ", text
        self._job.write_text(text)
    
    def write_text(self,text,mark=None):
        print "write_text: ", text
        self._job.write_text(text)
    
    def start_page(self):
        pass
    
    def end_page(self):
        pass
    
    def draw_line(self,style,x1,y1,x2,y2):
        pass

    def draw_path(self,style,path):
        pass
        
    def draw_box(self,style,text,x,y, w, h):
        pass
    
    def draw_text(self,style,text,x,y):
        pass
    
    def rotate_text(self,style,text,x,y,angle):
        pass
    
    def center_text(self,style,text,x,y):
        pass
    
    def center_print(self,lines,font,x,y,w,h):
        pass
    
    def left_print(self,lines,font,x,y):
        pass
    

#------------------------------------------------------------------------
#
# Register the document generator with the GRAMPS plugin system
#
#------------------------------------------------------------------------
register_text_doc(_('GtkPrint'), GtkDoc,1, 1, 1,"", None)
register_draw_doc(_('GtkPrint'), GtkDoc,1, 1,   "", None)
register_book_doc(name=_("GtkPrint"),classref=GtkDoc,
                  table=1,paper=1,style=1,ext="")