237 lines
7.8 KiB
Plaintext
237 lines
7.8 KiB
Plaintext
#------------------------------------------------------------------------------
|
|
#
|
|
# PyGUI - TextEditor Printing - Gtk
|
|
#
|
|
#------------------------------------------------------------------------------
|
|
|
|
import re
|
|
from Printing import Printable
|
|
|
|
class TextEditorPrintView(Printable):
|
|
|
|
def __init__(self, base_view, page_setup):
|
|
self.base_view = base_view; self.width = page_setup.page_width; self.page_height = page_setup.page_height; self.lay_out_text(); lines_per_page = int(page_setup.page_height / base_view.font.line_height); self.lines_per_page = lines_per_page; num_lines = len(self.lines); self.num_pages = (num_lines + lines_per_page - 1) // lines_per_page
|
|
self.height = self.num_pages * self.page_height
|
|
print "TextEditorPrintView: lines_per_page =", self.lines_per_page ###
|
|
print "...num_lines =", num_lines ###
|
|
print "...height =", self.height ###
|
|
print "...page_height =", self.page_height ###
|
|
|
|
def lay_out_text(self):
|
|
base_view = self.base_view
|
|
font = base_view.font
|
|
space_width = font.width(" ")
|
|
tab_spacing = base_view.tab_spacing
|
|
page_width = self.width
|
|
wrap = not base_view.get_hscrolling()
|
|
if wrap:
|
|
pat = re.compile(r"[ \t]|[^ \t]+")
|
|
else:
|
|
pat = re.compile(r"\t|[^ \t]+")
|
|
lines = []
|
|
line = []
|
|
x = 0
|
|
for text_line in base_view.text.splitlines():
|
|
for match in pat.finditer(text_line):
|
|
item = match.group()
|
|
if item == " ":
|
|
item_width = space_width
|
|
item = ""
|
|
elif item == "\t":
|
|
item_width = tab_spacing - x % tab_spacing
|
|
item = ""
|
|
else:
|
|
item_width = font.width(item)
|
|
if wrap and x + item_width > page_width and x > 0:
|
|
lines.append(line); line = []; x = 0
|
|
line.append((x, item))
|
|
x += item_width
|
|
lines.append(line); line = []; x = 0
|
|
self.lines = lines
|
|
|
|
def get_print_extent(self):
|
|
return self.width, self.height
|
|
|
|
def draw(self, canvas, page_rect):
|
|
l, t, r, b = page_rect
|
|
page_no = int(t / self.page_height)
|
|
print "TextEditorPrintView.draw: page_no =", page_no ###
|
|
n = self.lines_per_page
|
|
i = page_no * n
|
|
font = self.base_view.font
|
|
y = t + font.ascent
|
|
dy = font.line_height
|
|
for line in self.lines[i : i + n]:
|
|
for x, item in line:
|
|
canvas.moveto(x, y)
|
|
canvas.show_text(item)
|
|
y += dy
|
|
|
|
#------------------------------------------------------------------------------
|
|
#
|
|
# PyGUI - Printing - Generic
|
|
#
|
|
#------------------------------------------------------------------------------
|
|
|
|
from __future__ import division
|
|
from math import ceil
|
|
import cPickle as pickle
|
|
from Properties import overridable_property
|
|
from Globals import application
|
|
|
|
class PageSetup(object):
|
|
"""Holder of information specified by the "Page Setup" command."""
|
|
|
|
paper_name = overridable_property('paper_name')
|
|
paper_width = overridable_property('paper_width')
|
|
paper_height = overridable_property('paper_height')
|
|
left_margin = overridable_property('left_margin')
|
|
top_margin = overridable_property('top_margin')
|
|
right_margin = overridable_property('right_margin')
|
|
bottom_margin = overridable_property('bottom_margin')
|
|
orientation = overridable_property('orientation')
|
|
|
|
paper_size = overridable_property('paper_size')
|
|
margins = overridable_property('margins')
|
|
page_width = overridable_property('page_width')
|
|
page_height = overridable_property('page_height')
|
|
page_size = overridable_property('page_size')
|
|
page_rect = overridable_property('page_rect')
|
|
printable_rect = overridable_property('printable_rect') # May not work
|
|
printer_name = overridable_property('printer_name')
|
|
|
|
_pickle_attributes = ['paper_name', 'paper_size', 'margins',
|
|
'printer_name', 'orientation']
|
|
|
|
def __getstate__(self):
|
|
state = {}
|
|
for name in self._pickle_attributes:
|
|
state[name] = getattr(self, name)
|
|
return state
|
|
|
|
def __setstate__(self, state):
|
|
for name, value in state.iteritems():
|
|
setattr(self, name, value)
|
|
|
|
def from_string(s):
|
|
"""Restore a pickled PageSetup object from a string."""
|
|
return pickle.loads(s)
|
|
|
|
from_string = staticmethod(from_string)
|
|
|
|
def to_string(self):
|
|
"""Pickle the PageSetup object and return it as a string."""
|
|
return pickle.dumps(self, 2)
|
|
|
|
def get_paper_size(self):
|
|
return self.paper_width, self.paper_height
|
|
|
|
def set_paper_size(self, x):
|
|
self.paper_width, self.paper_height = x
|
|
|
|
def get_margins(self):
|
|
return self.left_margin, self.top_margin, self.right_margin, self.bottom_margin
|
|
|
|
def set_margins(self, x):
|
|
self.left_margin, self.top_margin, self.right_margin, self.bottom_margin = x
|
|
|
|
def get_page_width(self):
|
|
return self.paper_width - self.left_margin - self.right_margin
|
|
|
|
def get_page_height(self):
|
|
return self.paper_height - self.top_margin - self.bottom_margin
|
|
|
|
def get_page_size(self):
|
|
return (self.page_width, self.page_height)
|
|
|
|
def get_page_rect(self):
|
|
lm, tm, rm, bm = self.margins
|
|
pw, ph = self.paper_size
|
|
return (lm, tm, pw - rm, ph - bm)
|
|
|
|
#------------------------------------------------------------------------------
|
|
|
|
class Printable(object):
|
|
"""Mixin class for components implementing the "Print" command."""
|
|
|
|
printable = overridable_property('printable', "Whether this component should handle the 'Print' command.")
|
|
page_setup = overridable_property('page_setup', "The PageSetup object to use for printing.")
|
|
print_title = overridable_property('print_title', "Title for print job.")
|
|
|
|
_printable = True
|
|
|
|
def get_printable(self):
|
|
return self._printable
|
|
|
|
def set_printable(self, x):
|
|
self._printable = x
|
|
|
|
def get_print_title(self):
|
|
window = self.window
|
|
if window:
|
|
return window.title
|
|
else:
|
|
return ""
|
|
|
|
def get_page_setup(self):
|
|
result = None
|
|
model = getattr(self, 'model', None)
|
|
if model:
|
|
result = getattr(model, 'page_setup', None)
|
|
if not result:
|
|
result = application().page_setup
|
|
return result
|
|
|
|
def setup_menus(self, m):
|
|
if self.printable:
|
|
m.print_cmd.enabled = True
|
|
|
|
def print_cmd(self):
|
|
if self.printable:
|
|
page_setup = self.page_setup
|
|
if page_setup:
|
|
self.print_view(page_setup)
|
|
else:
|
|
self.pass_to_next_handler('print_cmd')
|
|
|
|
#------------------------------------------------------------------------------
|
|
|
|
class Paginator(object):
|
|
"""Used internally. A generic pagination algorithm for printing."""
|
|
|
|
def __init__(self, view, page_setup):
|
|
self.view = view
|
|
extent_width, extent_height = view.get_print_extent()
|
|
#paper_width, paper_height = page_setup.paper_size
|
|
#lm, tm, rm, bm = page_setup.margins
|
|
#page_width = int(paper_width - lm - rm)
|
|
#page_height = int(paper_height - tm - bm)
|
|
page_width, page_height = page_setup.page_size
|
|
if page_width <= 0 or page_height <= 0:
|
|
from AlertFunctions import stop_alert
|
|
stop_alert("Margins are too large for the page size.")
|
|
return
|
|
self.extent_rect = (0, 0, extent_width, extent_height)
|
|
self.page_width = page_width
|
|
self.page_height = page_height
|
|
self.left_margin = page_setup.left_margin
|
|
self.top_margin = page_setup.top_margin
|
|
self.pages_wide = int(ceil(extent_width / page_width))
|
|
self.pages_high = int(ceil(extent_height / page_height))
|
|
self.num_pages = self.pages_wide * self.pages_high
|
|
|
|
def draw_page(self, canvas, page_num):
|
|
row, col = divmod(page_num, self.pages_wide)
|
|
view_left = col * self.page_width
|
|
view_top = row * self.page_height
|
|
view_right = view_left + self.page_width
|
|
view_bottom = view_top + self.page_height
|
|
view_rect = (view_left, view_top, view_right, view_bottom)
|
|
dx = self.left_margin - view_left
|
|
dy = self.top_margin - view_top
|
|
canvas.translate(dx, dy)
|
|
canvas.rectclip(self.extent_rect)
|
|
canvas.rectclip(view_rect)
|
|
canvas._printing = True
|
|
self.view.draw(canvas, view_rect)
|