def set_gtk_state(gtk_page_setup, state):
gtk_page_setup.set_orientation(state['orientation'])
gtk_page_setup.set_paper_size(gtk.PaperSize(state['paper_size']))
gtk_page_setup.set_top_margin(state['top_margin'], UNIT_POINTS)
gtk_page_setup.set_bottom_margin(state['bottom_margin'], UNIT_POINTS)
gtk_page_setup.set_left_margin(state['left_margin'], UNIT_POINTS)
gtk_page_setup.set_right_margin(state['right_margin'], UNIT_POINTS)
class HtmlPrinter(object):
"""
Idea and code-snippets taken from interwibble,
"A non-interactive tool for converting any given website to PDF"
(http://github.com/eeejay/interwibble/)
"""
PAPER_SIZES = {
'a3': gtk.PAPER_NAME_A3,
'a4': gtk.PAPER_NAME_A4,
'a5': gtk.PAPER_NAME_A5,
'b5': gtk.PAPER_NAME_B5,
'executive': gtk.PAPER_NAME_EXECUTIVE,
'legal': gtk.PAPER_NAME_LEGAL,
'letter': gtk.PAPER_NAME_LETTER
}
def __init__(self, paper='a4'):
self._webview = Browser()
try:
self._webview.connect('load-error', self._load_error_cb)
self._webview.connect('title-changed', self._title_changed_cb)
self._webview.connect('load-finished', self._load_finished_cb)
except TypeError, err:
logging.info(err)
self._paper_size = gtk.PaperSize(self.PAPER_SIZES[paper])
self.outfile = None
class HtmlPrinter(object):
'''
Idea and some code taken from interwibble,
"A non-interactive tool for converting any given website to PDF"
(http://github.com/eeejay/interwibble/)
'''
PAPER_SIZES = {
'a3': gtk.PAPER_NAME_A3,
'a4': gtk.PAPER_NAME_A4,
'a5': gtk.PAPER_NAME_A5,
'b5': gtk.PAPER_NAME_B5,
'executive': gtk.PAPER_NAME_EXECUTIVE,
'legal': gtk.PAPER_NAME_LEGAL,
'letter': gtk.PAPER_NAME_LETTER
}
def __init__(self, paper='a4'):
self._webview = webkit.WebView()
webkit_settings = self._webview.get_settings()
webkit_settings.set_property('enable-plugins', False)
try:
self._webview.connect('load-error', self._load_error_cb)
except TypeError, err:
logging.info(err)
self._paper_size = gtk.PaperSize(self.PAPER_SIZES[paper])
def __init__(self,
content="",
font_name="monospace",
font_size=10,
wrap=False,
set_statusbar_msg=None):
self.content = "\n" * 11 + content # Dirty offset for the logo
self.layout = None
self.font_name = font_name
self.font_size = font_size
self.wrap = wrap
self._linesppage = 0
self._current_line = 0
self.operation = gtk.PrintOperation()
self.operation.set_unit(gtk.UNIT_MM)
# Setting paper size as A4
paper_size = gtk.PaperSize(gtk.PAPER_NAME_A4)
setup = gtk.PageSetup()
setup.set_paper_size(paper_size)
self.operation.set_default_page_setup(setup)
self.operation.connect("begin_print", self.begin_print)
self.operation.connect("draw_page", self.draw_page)
if set_statusbar_msg is not None:
self.operation.connect("status-changed", status_cb,
set_statusbar_msg)
def __init__(self, unit=gtk.UNIT_MM, size=gtk.PAPER_NAME_A4,
orientation=gtk.PAGE_ORIENTATION_PORTRAIT):
"""
Parameters
----------
unit : gtk unit constant
size : gtk paper name constant
orientation : gtk page orientation constant
see http://www.pygtk.org/pygtk2reference/gtk-constants.html
for available constantes
"""
self.op = None
self.page_setup = gtk.PageSetup()
self.page_setup.set_orientation(orientation)
self.page_setup.set_paper_size(gtk.PaperSize(size))
self.unit = unit
self.w = self.page_setup.get_paper_size().get_width(unit)
self.h = self.page_setup.get_paper_size().get_height(unit)
# Workaround:
# Variable `self.error` keeps track of exceptions raised during print
# operation in the methods `PDF._paginate()` or `PDF._draw_page()`. To
# catch the exceptions, the calls of these methods are encapsulated
# within `PDF.__paginate()` or `PDF.__draw_page()`, where this variable
# is set to the exception and the print operation is canceled via
# `op.cancel()`.
# The reason for this is that exceptions thrown during the run of the
# print operation are caught internally and can not be handled further.
# This leads to fatal uncaught exception error.
self.error = None
def on_print_clicked(self, widget):
printop = gtk.PrintOperation()
page_setup = gtk.PageSetup()
page_setup.set_paper_size(gtk.PaperSize(gtk.PAPER_NAME_A4))
printop.set_default_page_setup(page_setup)
order_products = OrderProduct.find_all_not_yet_ordered_on(
self.calendardate())
self.printer = OrderProductPrinter(order_products)
n_pages = self.printer.calc_n_pages()
printop.set_n_pages(n_pages)
printop.connect("draw_page", self.print_ordered_products)
printop.run(gtk.PRINT_OPERATION_ACTION_PRINT_DIALOG)
def do_print(self):
print_op = gtk.PrintOperation()
# Page size and orientation
# FIXME: sizes other than letter do not work
print "paper size:", self.papersize
paper_size = gtk.PaperSize(gtk.PAPER_NAME_LETTER)
if self.papersize[0] > self.papersize[1]:
print " landscape"
paper_size.set_size(self.papersize[1], self.papersize[0],
gtk.UNIT_POINTS)
orientation = gtk.PAGE_ORIENTATION_LANDSCAPE
else:
print " portrait"
paper_size.set_size(self.papersize[0], self.papersize[1],
gtk.UNIT_POINTS)
orientation = gtk.PAGE_ORIENTATION_PORTRAIT
print "is_custom:", paper_size.is_custom()
page_setup = gtk.PageSetup()
page_setup.set_paper_size_and_default_margins(paper_size)
page_setup.set_orientation(orientation)
print_op.set_default_page_setup(page_setup)
#if self.print_settings is not None:
# print_op.set_print_settings(self.print_settings)
print_op.set_show_progress(False) # appears late
print_op.set_use_full_page(True)
print_op.set_embed_page_setup(True)
print_op.connect('draw_page', self.draw_page)
print_op.set_n_pages(1)
result = print_op.run(gtk.PRINT_OPERATION_ACTION_PRINT_DIALOG,
self.main_window)
print "Printing result:", result
if self.map_failure:
return self.map_failure
elif result == gtk.PRINT_OPERATION_RESULT_ERROR:
return print_op.get_error()
#elif result == gtk.PRINT_OPERATION_RESULT_APPLY:
# self.print_settings = print_op.get_print_settings()
# return None
else:
return None
def set_document(self, filename, operation, context):
if not filename.startswith('file'):
filename = 'file://' + os.path.realpath(filename)
self.d = poppler.document_new_from_file(filename, None)
operation.set_n_pages(self.d.get_n_pages())
# Assume all pages are same
page = self.d.get_page(0)
w, h = page.get_size()
if w > h:
w, h = h, w
ori = gtk.PAGE_ORIENTATION_LANDSCAPE
else:
ori = gtk.PAGE_ORIENTATION_PORTRAIT
page_setup = gtk.PageSetup()
page_setup.set_orientation(ori)
size = int(round(w)), int(round(h))
gtk_size = rl2gtk_papersizes.get(size, None)
if gtk_size:
ps = gtk.PaperSize(gtk_size)
else:
ps = gtk.paper_size_new_custom('', '', w, h, gtk.UNIT_POINTS)
page_setup.set_paper_size(ps)
operation.set_default_page_setup(page_setup)
def paperstyle_to_pagesetup(paper_style):
"""Convert a PaperStyle instance into a gtk.PageSetup instance.
@param paper_style: Gramps paper style object to convert
@param type: PaperStyle
@return: page_setup
@rtype: gtk.PageSetup
"""
# paper size names according to 'PWG Candidate Standard 5101.1-2002'
# ftp://ftp.pwg.org/pub/pwg/candidates/cs-pwgmsn10-20020226-5101.1.pdf
gramps_to_gtk = {
"Letter": "na_letter",
"Legal": "na_legal",
"A0": "iso_a0",
"A1": "iso_a1",
"A2": "iso_a2",
"A3": "iso_a3",
"A4": "iso_a4",
"A5": "iso_a5",
"B0": "iso_b0",
"B1": "iso_b1",
"B2": "iso_b2",
"B3": "iso_b3",
"B4": "iso_b4",
"B5": "iso_b5",
"B6": "iso_b6",
"B": "na_ledger",
"C": "na_c",
"D": "na_d",
"E": "na_e",
}
# First set the paper size
gramps_paper_size = paper_style.get_size()
gramps_paper_name = gramps_paper_size.get_name()
# All sizes not included in the translation table (even if a standard size)
# are handled as custom format, because we are not intelligent enough.
if gramps_paper_name in gramps_to_gtk:
paper_size = gtk.PaperSize(gramps_to_gtk[gramps_paper_name])
log.debug("Selected paper size: %s" % gramps_to_gtk[gramps_paper_name])
else:
if paper_style.get_orientation() == PAPER_PORTRAIT:
paper_width = gramps_paper_size.get_width() * 10
paper_height = gramps_paper_size.get_height() * 10
else:
paper_width = gramps_paper_size.get_height() * 10
paper_height = gramps_paper_size.get_width() * 10
paper_size = gtk.paper_size_new_custom("custom", "Custom Size",
paper_width, paper_height,
gtk.UNIT_MM)
log.debug("Selected paper size: (%f,%f)" % (paper_width, paper_height))
page_setup = gtk.PageSetup()
page_setup.set_paper_size(paper_size)
# Set paper orientation
if paper_style.get_orientation() == PAPER_PORTRAIT:
page_setup.set_orientation(gtk.PAGE_ORIENTATION_PORTRAIT)
else:
page_setup.set_orientation(gtk.PAGE_ORIENTATION_LANDSCAPE)
# Set paper margins
page_setup.set_top_margin(paper_style.get_top_margin() * 10, gtk.UNIT_MM)
page_setup.set_bottom_margin(paper_style.get_bottom_margin() * 10,
gtk.UNIT_MM)
page_setup.set_left_margin(paper_style.get_left_margin() * 10, gtk.UNIT_MM)
page_setup.set_right_margin(paper_style.get_right_margin() * 10,
gtk.UNIT_MM)
return page_setup
def set_paper_name(self, x):
psize = gtk.PaperSize(gtk_paper_formats.get(x) or x)
self._gtk_page_setup.set_paper_size(psize)
def gtk_default_page_setup():
pset = gtk.PageSetup()
pset.set_paper_size(gtk.PaperSize())
return pset
def init_gtk_paper_formats():
for gtk_name in gtk_paper_names:
display_name = gtk.PaperSize(gtk_name).get_display_name()
gtk_paper_formats[display_name] = gtk_name
def request_page_setup(operation, context, page_nr, page_setup):
## Make the second page landscape mode a5
if page_nr == 1:
page_setup.set_orientation(gtk.PAGE_ORIENTATION_LANDSCAPE)
page_setup.set_paper_size(gtk.PaperSize("iso_a5"))
