1066 lines
39 KiB
Python
1066 lines
39 KiB
Python
#!/usr/bin/env python3
|
||
# -*- coding: utf-8 -*-
|
||
|
||
from collections import OrderedDict
|
||
import math
|
||
import fitz
|
||
import tkinter
|
||
import tkinter.filedialog
|
||
import sys
|
||
import argparse
|
||
import os.path
|
||
import platform
|
||
|
||
VERSION = "0.1"
|
||
|
||
PAGE_SIZES = OrderedDict(
|
||
[
|
||
("custom", (None, None)),
|
||
("A0 (84.1 cm × 118.9 cm)", (841, 1189)),
|
||
("A1 (59.4 cm × 84.1 cm)", (594, 841)),
|
||
("A2 (42.0 cm × 59.4 cm)", (420, 594)),
|
||
("A3 (29.7 cm × 42.0 cm)", (297, 420)),
|
||
("A4 (21.0 cm × 29.7 cm)", (210, 297)),
|
||
("A5 (14.8 cm × 21.0 cm)", (148, 210)),
|
||
("Letter (8.5 in × 11 in)", (215.9, 279.4)),
|
||
("Legal (8.5 in × 14 in)", (215.9, 355.6)),
|
||
("Tabloid (11 in × 17 in)", (279.4, 431.8)),
|
||
]
|
||
)
|
||
|
||
|
||
def mm_to_pt(length):
|
||
return (72.0 * length) / 25.4
|
||
|
||
|
||
def pt_to_mm(length):
|
||
return (25.4 * length) / 72.0
|
||
|
||
|
||
class Plakativ:
|
||
def __init__(self, infile=None):
|
||
self.doc = None
|
||
if infile is not None:
|
||
self.open(infile)
|
||
|
||
def open(self, infile):
|
||
self.doc = fitz.open(infile)
|
||
# only allow pdf documents with exactly a single page
|
||
assert len(self.doc) == 1
|
||
self.dlist = self.doc[0].getDisplayList()
|
||
|
||
self.pagesize = PAGE_SIZES["A4 (21.0 cm × 29.7 cm)"]
|
||
self.border_left = 20
|
||
self.border_right = 20
|
||
self.border_top = 20
|
||
self.border_bottom = 20
|
||
self.config = {
|
||
"pagesize": (
|
||
pt_to_mm(self.dlist.rect.width),
|
||
pt_to_mm(self.dlist.rect.height),
|
||
),
|
||
"postersize": PAGE_SIZES["A1 (59.4 cm × 84.1 cm)"],
|
||
}
|
||
self.layout = {"pagesize": PAGE_SIZES["A4 (21.0 cm × 29.7 cm)"]}
|
||
|
||
def compute_layout(self, mode, size=None, mult=None, npages=None):
|
||
if self.doc is None:
|
||
return
|
||
|
||
self.config["mode"] = mode
|
||
self.config["postersize"] = None
|
||
self.config["mult"] = None
|
||
self.config["npages"] = None
|
||
if mode == "size":
|
||
self.config["postersize"] = size
|
||
elif mode == "mult":
|
||
self.config["mult"] = mult
|
||
elif mode == "npages":
|
||
self.config["npages"] = npages
|
||
else:
|
||
raise Exception("unsupported mode: %s" % mode)
|
||
|
||
printable_width = self.layout["pagesize"][0] - (
|
||
self.border_left + self.border_right
|
||
)
|
||
printable_height = self.layout["pagesize"][1] - (
|
||
self.border_top + self.border_bottom
|
||
)
|
||
|
||
if mode in ["size", "mult"]:
|
||
if mode == "size":
|
||
# fit the input page size into the selected postersize
|
||
poster_width = self.config["postersize"][0]
|
||
poster_height = (
|
||
poster_width * self.config["pagesize"][1]
|
||
) / self.config["pagesize"][0]
|
||
if poster_height > self.config["postersize"][1]:
|
||
poster_height = self.config["postersize"][1]
|
||
poster_width = (
|
||
poster_height * self.config["pagesize"][0]
|
||
) / self.config["pagesize"][1]
|
||
elif mode == "mult":
|
||
area = self.config["pagesize"][0] * self.config["pagesize"][1] * mult
|
||
poster_width = math.sqrt(
|
||
area * self.config["pagesize"][0] / self.config["pagesize"][1]
|
||
)
|
||
poster_height = math.sqrt(
|
||
area * self.config["pagesize"][1] / self.config["pagesize"][0]
|
||
)
|
||
else:
|
||
raise Exception("unsupported mode: %s" % mode)
|
||
|
||
self.layout["postersize"] = poster_width, poster_height
|
||
|
||
pages_x_portrait = math.ceil(poster_width / printable_width)
|
||
pages_y_portrait = math.ceil(poster_height / printable_height)
|
||
|
||
pages_x_landscape = math.ceil(poster_width / printable_height)
|
||
pages_y_landscape = math.ceil(poster_height / printable_width)
|
||
|
||
portrait = True
|
||
if (
|
||
pages_x_portrait * pages_y_portrait
|
||
> pages_x_landscape * pages_y_landscape
|
||
):
|
||
portrait = False
|
||
|
||
if portrait:
|
||
pages_x = pages_x_portrait
|
||
pages_y = pages_y_portrait
|
||
self.layout["overallsize"] = (
|
||
pages_x * printable_width + (self.border_right + self.border_left),
|
||
pages_y * printable_height + (self.border_top + self.border_bottom),
|
||
)
|
||
else:
|
||
pages_x = pages_x_landscape
|
||
pages_y = pages_y_landscape
|
||
self.layout["overallsize"] = (
|
||
pages_x * printable_height + (self.border_top + self.border_bottom),
|
||
pages_y * printable_width + (self.border_right + self.border_left),
|
||
)
|
||
elif mode == "npages":
|
||
# stupid bruteforce algorithm to determine the largest printable
|
||
# postersize with N pages
|
||
best_area = 0
|
||
best = None
|
||
for x in range(1, self.config["npages"] + 1):
|
||
for y in range(1, self.config["npages"] + 1):
|
||
if x * y > self.config["npages"]:
|
||
continue
|
||
width_portrait = x * printable_width
|
||
height_portrait = y * printable_height
|
||
|
||
poster_width = width_portrait
|
||
poster_height = (
|
||
poster_width * self.config["pagesize"][1]
|
||
) / self.config["pagesize"][0]
|
||
if poster_height > height_portrait:
|
||
poster_height = height_portrait
|
||
poster_width = (
|
||
poster_height * self.config["pagesize"][0]
|
||
) / self.config["pagesize"][1]
|
||
|
||
area_portrait = poster_width * poster_height
|
||
|
||
if area_portrait > best_area:
|
||
best_area = area_portrait
|
||
best = (x, y, True, poster_width, poster_height)
|
||
|
||
width_landscape = x * printable_height
|
||
height_landscape = y * printable_width
|
||
|
||
poster_width = width_landscape
|
||
poster_height = (
|
||
poster_width * self.config["pagesize"][1]
|
||
) / self.config["pagesize"][0]
|
||
if poster_height > height_landscape:
|
||
poster_height = height_landscape
|
||
poster_width = (
|
||
poster_height * self.config["pagesize"][0]
|
||
) / self.config["pagesize"][1]
|
||
|
||
area_landscape = poster_width * poster_height
|
||
|
||
if area_landscape > best_area:
|
||
best_area = area_landscape
|
||
best = (x, y, False, poster_width, poster_height)
|
||
|
||
pages_x, pages_y, portrait, poster_width, poster_height = best
|
||
self.layout["postersize"] = poster_width, poster_height
|
||
if portrait:
|
||
self.layout["overallsize"] = (
|
||
pages_x * printable_width + (self.border_right + self.border_left),
|
||
pages_y * printable_height + (self.border_top + self.border_bottom),
|
||
)
|
||
else:
|
||
self.layout["overallsize"] = (
|
||
pages_x * printable_height + (self.border_top + self.border_bottom),
|
||
pages_y * printable_width + (self.border_right + self.border_left),
|
||
)
|
||
else:
|
||
raise Exception("unsupported mode: %s" % mode)
|
||
|
||
self.layout["positions"] = []
|
||
for y in range(pages_y):
|
||
for x in range(pages_x):
|
||
if portrait:
|
||
posx = x * printable_width
|
||
posy = y * printable_height
|
||
else:
|
||
posx = x * printable_height
|
||
posy = y * printable_width
|
||
self.layout["positions"].append((posx, posy, portrait))
|
||
|
||
# return (self.postersize, (poster_width*poster_height)/(pt_to_mm(self.dlist.rect.width)*pt_to_mm(self.dlist.rect.height)), pages_x*pages_y)
|
||
if mode == "size":
|
||
self.config["mult"] = (poster_width * poster_height) / (
|
||
self.config["pagesize"][0] * self.config["pagesize"][1]
|
||
)
|
||
self.config["npages"] = pages_x * pages_y
|
||
elif mode == "mult":
|
||
self.config["postersize"] = poster_width, poster_height
|
||
self.config["npages"] = pages_x * pages_y
|
||
elif mode == "npages":
|
||
self.config["postersize"] = poster_width, poster_height
|
||
self.config["mult"] = (poster_width * poster_height) / (
|
||
self.config["pagesize"][0] * self.config["pagesize"][1]
|
||
)
|
||
else:
|
||
raise Exception("unsupported mode: %s" % mode)
|
||
|
||
return self.config["postersize"], self.config["mult"], self.config["npages"]
|
||
|
||
def render(self, outfile):
|
||
outdoc = fitz.open()
|
||
|
||
xref = 0
|
||
r = self.dlist.rect
|
||
|
||
for (x, y, portrait) in self.layout["positions"]:
|
||
if portrait:
|
||
page_width=mm_to_pt(self.layout["pagesize"][0])
|
||
page_height=mm_to_pt(self.layout["pagesize"][1])
|
||
else:
|
||
page_width=mm_to_pt(self.layout["pagesize"][1])
|
||
page_height=mm_to_pt(self.layout["pagesize"][0])
|
||
page = outdoc.newPage(
|
||
-1, # insert after last page
|
||
width=page_width,
|
||
height=page_height,
|
||
)
|
||
|
||
target_x = (
|
||
x - self.layout["overallsize"][0] / 2 + self.layout["postersize"][0] / 2
|
||
)
|
||
target_y = (
|
||
y - self.layout["overallsize"][1] / 2 + self.layout["postersize"][1] / 2
|
||
)
|
||
target_xoffset = 0
|
||
target_yoffset = 0
|
||
if portrait:
|
||
target_width = self.layout["pagesize"][0]
|
||
target_height = self.layout["pagesize"][1]
|
||
else:
|
||
target_width = self.layout["pagesize"][1]
|
||
target_height = self.layout["pagesize"][0]
|
||
if target_x < 0:
|
||
target_xoffset = -target_x
|
||
target_width += target_x
|
||
target_x = 0
|
||
if target_y < 0:
|
||
target_yoffset = -target_y
|
||
target_height += target_y
|
||
target_y = 0
|
||
if target_x + target_width > self.layout["postersize"][0]:
|
||
target_width = self.layout["postersize"][0] - target_x
|
||
if target_y + target_height > self.layout["postersize"][1]:
|
||
target_height = self.layout["postersize"][1] - target_y
|
||
|
||
targetrect = fitz.Rect(
|
||
mm_to_pt(target_xoffset),
|
||
mm_to_pt(target_yoffset),
|
||
mm_to_pt(target_xoffset + target_width),
|
||
mm_to_pt(target_yoffset + target_height),
|
||
)
|
||
|
||
# FIXME: this should probably the pagesize of the input document instead
|
||
factor = self.layout["pagesize"][0] / self.layout["postersize"][0]
|
||
sourcerect = fitz.Rect(
|
||
mm_to_pt(factor * target_x),
|
||
mm_to_pt(factor * target_y),
|
||
mm_to_pt(factor * (target_x + target_width)),
|
||
mm_to_pt(factor * (target_y + target_height)),
|
||
)
|
||
|
||
# update xref
|
||
xref = page.showPDFpage(
|
||
targetrect, # fill the whole page
|
||
self.doc, # input document
|
||
0, # input page number
|
||
clip=sourcerect, # part of the input page to use
|
||
#rotate=0 if portrait else 90,
|
||
)
|
||
|
||
outdoc.save(outfile, garbage=4, deflate=True)
|
||
|
||
|
||
# from Python 3.7 Lib/idlelib/configdialog.py
|
||
# Copyright 2015-2017 Terry Jan Reedy
|
||
# Python License
|
||
class VerticalScrolledFrame(tkinter.Frame):
|
||
"""A pure Tkinter vertically scrollable frame.
|
||
|
||
* Use the 'interior' attribute to place widgets inside the scrollable frame
|
||
* Construct and pack/place/grid normally
|
||
* This frame only allows vertical scrolling
|
||
"""
|
||
|
||
def __init__(self, parent, *args, **kw):
|
||
tkinter.Frame.__init__(self, parent, *args, **kw)
|
||
|
||
# Create a canvas object and a vertical scrollbar for scrolling it.
|
||
vscrollbar = tkinter.Scrollbar(self, orient=tkinter.VERTICAL)
|
||
vscrollbar.pack(fill=tkinter.Y, side=tkinter.RIGHT, expand=tkinter.FALSE)
|
||
canvas = tkinter.Canvas(
|
||
self,
|
||
borderwidth=0,
|
||
highlightthickness=0,
|
||
yscrollcommand=vscrollbar.set,
|
||
width=240,
|
||
)
|
||
canvas.pack(side=tkinter.LEFT, fill=tkinter.BOTH, expand=tkinter.TRUE)
|
||
vscrollbar.config(command=canvas.yview)
|
||
|
||
# Reset the view.
|
||
canvas.xview_moveto(0)
|
||
canvas.yview_moveto(0)
|
||
|
||
# Create a frame inside the canvas which will be scrolled with it.
|
||
self.interior = interior = tkinter.Frame(canvas)
|
||
interior_id = canvas.create_window(0, 0, window=interior, anchor=tkinter.NW)
|
||
|
||
# Track changes to the canvas and frame width and sync them,
|
||
# also updating the scrollbar.
|
||
def _configure_interior(event):
|
||
# Update the scrollbars to match the size of the inner frame.
|
||
size = (interior.winfo_reqwidth(), interior.winfo_reqheight())
|
||
canvas.config(scrollregion="0 0 %s %s" % size)
|
||
|
||
interior.bind("<Configure>", _configure_interior)
|
||
|
||
def _configure_canvas(event):
|
||
if interior.winfo_reqwidth() != canvas.winfo_width():
|
||
# Update the inner frame's width to fill the canvas.
|
||
canvas.itemconfigure(interior_id, width=canvas.winfo_width())
|
||
|
||
canvas.bind("<Configure>", _configure_canvas)
|
||
|
||
return
|
||
|
||
|
||
# From Python 3.7 Lib/tkinter/__init__.py
|
||
# Copyright 2000 Fredrik Lundh
|
||
# Python License
|
||
#
|
||
# add support for 'state' and 'name' kwargs
|
||
class OptionMenu(tkinter.Menubutton):
|
||
"""OptionMenu which allows the user to select a value from a menu."""
|
||
|
||
def __init__(self, master, variable, value, *values, **kwargs):
|
||
"""Construct an optionmenu widget with the parent MASTER, with
|
||
the resource textvariable set to VARIABLE, the initially selected
|
||
value VALUE, the other menu values VALUES and an additional
|
||
keyword argument command."""
|
||
kw = {
|
||
"borderwidth": 2,
|
||
"textvariable": variable,
|
||
"indicatoron": 1,
|
||
"relief": tkinter.RAISED,
|
||
"anchor": "c",
|
||
"highlightthickness": 2,
|
||
}
|
||
if "state" in kwargs:
|
||
kw["state"] = kwargs["state"]
|
||
del kwargs["state"]
|
||
if "name" in kwargs:
|
||
kw["name"] = kwargs["name"]
|
||
del kwargs["name"]
|
||
tkinter.Widget.__init__(self, master, "menubutton", kw)
|
||
self.widgetName = "tk_optionMenu"
|
||
menu = self.__menu = tkinter.Menu(self, name="menu", tearoff=0)
|
||
self.menuname = menu._w
|
||
# 'command' is the only supported keyword
|
||
callback = kwargs.get("command")
|
||
if "command" in kwargs:
|
||
del kwargs["command"]
|
||
if kwargs:
|
||
raise tkinter.TclError("unknown option -" + list(kwargs.keys())[0])
|
||
menu.add_command(label=value, command=tkinter._setit(variable, value, callback))
|
||
for v in values:
|
||
menu.add_command(label=v, command=tkinter._setit(variable, v, callback))
|
||
self["menu"] = menu
|
||
|
||
def __getitem__(self, name):
|
||
if name == "menu":
|
||
return self.__menu
|
||
return tkinter.Widget.__getitem__(self, name)
|
||
|
||
def destroy(self):
|
||
"""Destroy this widget and the associated menu."""
|
||
tkinter.Menubutton.destroy(self)
|
||
self.__menu = None
|
||
|
||
|
||
class Application(tkinter.Frame):
|
||
def __init__(self, master=None, plakativ=None):
|
||
super().__init__(master)
|
||
self.master = master
|
||
self.master.title("plakativ")
|
||
|
||
self.pack(fill=tkinter.BOTH, expand=tkinter.TRUE)
|
||
|
||
if plakativ is None:
|
||
self.plakativ = Plakativ()
|
||
else:
|
||
self.plakativ = plakativ
|
||
|
||
self.border_left = tkinter.DoubleVar(value=20.0)
|
||
self.border_right = tkinter.DoubleVar(value=20.0)
|
||
self.border_top = tkinter.DoubleVar(value=20.0)
|
||
self.border_bottom = tkinter.DoubleVar(value=20.0)
|
||
|
||
self.canvas = tkinter.Canvas(self, bg="black")
|
||
self.canvas.pack(fill=tkinter.BOTH, side=tkinter.LEFT, expand=tkinter.TRUE)
|
||
self.canvas_size = self.canvas.winfo_width(), self.canvas.winfo_height()
|
||
self.canvas.bind("<Configure>", self.on_resize)
|
||
|
||
# tkinter does not allow scrollbars for frames
|
||
frame1 = VerticalScrolledFrame(self)
|
||
frame1.pack(side=tkinter.TOP, expand=tkinter.TRUE, fill=tkinter.Y)
|
||
|
||
top_frame = tkinter.Frame(frame1.interior)
|
||
top_frame.pack(fill=tkinter.X)
|
||
|
||
open_button = tkinter.Button(
|
||
top_frame, text="Open PDF", command=self.on_open_button
|
||
)
|
||
open_button.pack(side=tkinter.LEFT, expand=tkinter.TRUE, fill=tkinter.X)
|
||
help_button = tkinter.Button(top_frame, text="Help", state=tkinter.DISABLED)
|
||
help_button.pack(side=tkinter.RIGHT, expand=tkinter.TRUE, fill=tkinter.X)
|
||
|
||
input_group = tkinter.LabelFrame(frame1.interior, text="Input properties")
|
||
input_group.pack(fill=tkinter.X)
|
||
|
||
label_input_width = tkinter.Label(input_group, text="Width:")
|
||
label_input_width.grid(row=0, column=0, sticky=tkinter.W)
|
||
label_input_height = tkinter.Label(input_group, text="Height:")
|
||
label_input_height.grid(row=1, column=0, sticky=tkinter.W)
|
||
label_input_npages = tkinter.Label(input_group, text="# of pages:")
|
||
label_input_npages.grid(row=2, column=0, sticky=tkinter.W)
|
||
label_input_range = tkinter.Label(input_group, text="Page range:")
|
||
label_input_range.grid(row=3, column=0, sticky=tkinter.W)
|
||
self.input_range = tkinter.StringVar()
|
||
self.input_range.set("1")
|
||
input_range_entry = tkinter.Entry(
|
||
input_group, textvariable=self.input_range, width=6, state=tkinter.DISABLED
|
||
)
|
||
input_range_entry.grid(row=3, column=1, sticky=tkinter.W)
|
||
|
||
pagesize_group = tkinter.LabelFrame(
|
||
frame1.interior, text="Size of output pages"
|
||
)
|
||
pagesize_group.pack(fill=tkinter.X)
|
||
|
||
pagesize_fixed = tkinter.StringVar()
|
||
if self.plakativ.doc is None:
|
||
pagesize_fixed.set("")
|
||
else:
|
||
pagesize_fixed.set(
|
||
dict(zip(PAGE_SIZES.values(), PAGE_SIZES.keys()))[
|
||
self.plakativ.pagesize
|
||
]
|
||
)
|
||
pagesize_options = OptionMenu(
|
||
pagesize_group,
|
||
pagesize_fixed,
|
||
*PAGE_SIZES.keys(),
|
||
command=self.on_select_pagesize,
|
||
state=tkinter.DISABLED if self.plakativ.doc is None else tkinter.NORMAL
|
||
)
|
||
pagesize_options.grid(row=1, column=0, columnspan=3, sticky=tkinter.W)
|
||
|
||
label_pagesize_width = tkinter.Label(
|
||
pagesize_group, text="Width:", state=tkinter.DISABLED
|
||
)
|
||
label_pagesize_width.grid(row=2, column=0, sticky=tkinter.W)
|
||
pagesize_width = tkinter.Spinbox(
|
||
pagesize_group,
|
||
format="%.2f",
|
||
increment=0.01,
|
||
from_=0,
|
||
to=100,
|
||
width=5,
|
||
state=tkinter.DISABLED,
|
||
)
|
||
pagesize_width.grid(row=2, column=1, sticky=tkinter.W)
|
||
label_pagesize_width_mm = tkinter.Label(
|
||
pagesize_group, text="mm", state=tkinter.DISABLED
|
||
)
|
||
label_pagesize_width_mm.grid(row=2, column=2, sticky=tkinter.W)
|
||
|
||
label_pagesize_height = tkinter.Label(
|
||
pagesize_group, text="Height:", state=tkinter.DISABLED
|
||
)
|
||
label_pagesize_height.grid(row=3, column=0, sticky=tkinter.W)
|
||
pagesize_height = tkinter.Spinbox(
|
||
pagesize_group,
|
||
format="%.2f",
|
||
increment=0.01,
|
||
from_=0,
|
||
to=100,
|
||
width=5,
|
||
state=tkinter.DISABLED,
|
||
)
|
||
pagesize_height.grid(row=3, column=1, sticky=tkinter.W)
|
||
label_pagesize_height_mm = tkinter.Label(
|
||
pagesize_group, text="mm", state=tkinter.DISABLED
|
||
)
|
||
label_pagesize_height_mm.grid(row=3, column=2, sticky=tkinter.W)
|
||
|
||
border_group = tkinter.LabelFrame(
|
||
frame1.interior, text="Output Borders/Overlap"
|
||
)
|
||
border_group.pack(fill=tkinter.X)
|
||
|
||
label_left = tkinter.Label(border_group, text="Left:")
|
||
label_left.grid(row=0, column=0, sticky=tkinter.W)
|
||
border_left = tkinter.Spinbox(
|
||
border_group,
|
||
format="%.2f",
|
||
increment=0.01,
|
||
from_=0,
|
||
to=100,
|
||
width=5,
|
||
textvariable=self.border_left,
|
||
command=self.on_border,
|
||
)
|
||
border_left.grid(row=0, column=1)
|
||
label_left_mm = tkinter.Label(border_group, text="mm")
|
||
label_left_mm.grid(row=0, column=2)
|
||
label_right = tkinter.Label(border_group, text="Right:")
|
||
label_right.grid(row=1, column=0, sticky=tkinter.W)
|
||
border_right = tkinter.Spinbox(
|
||
border_group,
|
||
format="%.2f",
|
||
increment=0.01,
|
||
from_=0,
|
||
to=100,
|
||
width=5,
|
||
textvariable=self.border_right,
|
||
command=self.on_border,
|
||
)
|
||
border_right.grid(row=1, column=1)
|
||
label_right_mm = tkinter.Label(border_group, text="mm")
|
||
label_right_mm.grid(row=1, column=2)
|
||
label_top = tkinter.Label(border_group, text="Top:")
|
||
label_top.grid(row=2, column=0, sticky=tkinter.W)
|
||
border_top = tkinter.Spinbox(
|
||
border_group,
|
||
format="%.2f",
|
||
increment=0.01,
|
||
from_=0,
|
||
to=100,
|
||
width=5,
|
||
textvariable=self.border_top,
|
||
command=self.on_border,
|
||
)
|
||
border_top.grid(row=2, column=1)
|
||
label_top_mm = tkinter.Label(border_group, text="mm")
|
||
label_top_mm.grid(row=2, column=2)
|
||
label_bottom = tkinter.Label(border_group, text="Bottom:")
|
||
label_bottom.grid(row=3, column=0, sticky=tkinter.W)
|
||
border_bottom = tkinter.Spinbox(
|
||
border_group,
|
||
format="%.2f",
|
||
increment=0.01,
|
||
from_=0,
|
||
to=100,
|
||
width=5,
|
||
textvariable=self.border_bottom,
|
||
command=self.on_border,
|
||
)
|
||
border_bottom.grid(row=3, column=1)
|
||
label_bottom_mm = tkinter.Label(border_group, text="mm")
|
||
label_bottom_mm.grid(row=3, column=2)
|
||
|
||
self.postersize = PostersizeWidget(frame1.interior)
|
||
self.postersize.pack(fill=tkinter.X)
|
||
self.postersize.set("size", (False, (594, 841)), 1.0, 1)
|
||
if self.plakativ.doc is not None:
|
||
self.postersize.callback = self.on_postersize
|
||
|
||
layouter_group = tkinter.LabelFrame(frame1.interior, text="Layouter")
|
||
layouter_group.pack(fill=tkinter.X)
|
||
|
||
self.layouter = tkinter.IntVar()
|
||
self.layouter.set(1)
|
||
layouter1 = tkinter.Radiobutton(
|
||
layouter_group, text="Simple", variable=self.layouter, value=1
|
||
)
|
||
layouter1.pack(anchor=tkinter.W)
|
||
layouter2 = tkinter.Radiobutton(
|
||
layouter_group,
|
||
text="Advanced",
|
||
variable=self.layouter,
|
||
value=2,
|
||
state=tkinter.DISABLED,
|
||
)
|
||
layouter2.pack(anchor=tkinter.W)
|
||
layouter3 = tkinter.Radiobutton(
|
||
layouter_group,
|
||
text="Complex",
|
||
variable=self.layouter,
|
||
value=3,
|
||
state=tkinter.DISABLED,
|
||
)
|
||
layouter3.pack(anchor=tkinter.W)
|
||
|
||
output_group = tkinter.LabelFrame(frame1.interior, text="Output options")
|
||
output_group.pack(fill=tkinter.X)
|
||
|
||
tkinter.Checkbutton(
|
||
output_group, text="Print cutting guides", state=tkinter.DISABLED
|
||
).pack(anchor=tkinter.W)
|
||
tkinter.Checkbutton(
|
||
output_group, text="Print poster border", state=tkinter.DISABLED
|
||
).pack(anchor=tkinter.W)
|
||
|
||
bottom_frame = tkinter.Frame(frame1.interior)
|
||
bottom_frame.pack(fill=tkinter.X)
|
||
|
||
self.save_button = tkinter.Button(
|
||
bottom_frame,
|
||
text="Save PDF",
|
||
command=self.on_save_button,
|
||
state=tkinter.DISABLED,
|
||
)
|
||
self.save_button.pack(side=tkinter.LEFT, expand=tkinter.TRUE, fill=tkinter.X)
|
||
|
||
quit_button = tkinter.Button(
|
||
bottom_frame, text="Exit", command=self.master.destroy
|
||
)
|
||
quit_button.pack(side=tkinter.RIGHT, expand=tkinter.TRUE, fill=tkinter.X)
|
||
|
||
def on_postersize(self, value):
|
||
mode, (custom_size, size), mult, npages = value
|
||
size, mult, npages = self.plakativ.compute_layout(mode, size, mult, npages)
|
||
self.draw()
|
||
return (
|
||
mode,
|
||
(custom_size, size),
|
||
mult,
|
||
npages,
|
||
)
|
||
|
||
def on_border(self):
|
||
self.posterizer.border_left = self.border_left.get()
|
||
self.posterizer.border_right = self.border_right.get()
|
||
self.posterizer.border_top = self.border_top.get()
|
||
self.posterizer.border_bottom = self.border_bottom.get()
|
||
self.posterizer.compute_layout()
|
||
self.draw()
|
||
|
||
def on_select_pagesize(self, value):
|
||
self.posterizer.pagesize = PAGE_SIZES[value]
|
||
self.posterizer.compute_layout()
|
||
self.draw()
|
||
|
||
def on_resize(self, event):
|
||
self.canvas_size = (event.width, event.height)
|
||
self.draw()
|
||
|
||
def draw(self):
|
||
# clean canvas
|
||
self.canvas.delete(tkinter.ALL)
|
||
|
||
if self.plakativ.doc is None:
|
||
return
|
||
|
||
canvas_padding = 10
|
||
|
||
r = self.plakativ.dlist.rect
|
||
zoom_0 = min(
|
||
self.canvas_size[0]
|
||
/ r.width
|
||
* self.plakativ.layout["postersize"][0]
|
||
/ (self.plakativ.layout["overallsize"][0] + canvas_padding),
|
||
self.canvas_size[1]
|
||
/ r.height
|
||
* self.plakativ.layout["postersize"][1]
|
||
/ (self.plakativ.layout["overallsize"][1] + canvas_padding),
|
||
)
|
||
|
||
zoom_1 = min(
|
||
self.canvas_size[0]
|
||
/ (self.plakativ.layout["overallsize"][0] + canvas_padding),
|
||
self.canvas_size[1]
|
||
/ (self.plakativ.layout["overallsize"][1] + canvas_padding),
|
||
)
|
||
|
||
mat_0 = fitz.Matrix(zoom_0, zoom_0)
|
||
pix = self.plakativ.dlist.getPixmap(matrix=mat_0, alpha=False)
|
||
img = pix.getImageData("ppm")
|
||
tkimg = tkinter.PhotoImage(data=img)
|
||
|
||
# draw image
|
||
self.canvas.create_image(
|
||
(self.canvas_size[0] - zoom_0 * r.width) / 2,
|
||
(self.canvas_size[1] - zoom_0 * r.height) / 2,
|
||
anchor=tkinter.NW,
|
||
image=tkimg,
|
||
)
|
||
self.canvas.image = tkimg
|
||
|
||
# draw rectangles
|
||
for (x, y, portrait) in self.plakativ.layout["positions"]:
|
||
x0 = (
|
||
x * zoom_1
|
||
+ self.canvas_size[0] / 2
|
||
- zoom_1 * self.plakativ.layout["overallsize"][0] / 2
|
||
)
|
||
y0 = (
|
||
y * zoom_1
|
||
+ self.canvas_size[1] / 2
|
||
- zoom_1 * self.plakativ.layout["overallsize"][1] / 2
|
||
)
|
||
if portrait:
|
||
x1 = x0 + self.plakativ.layout["pagesize"][0] * zoom_1
|
||
y1 = y0 + self.plakativ.layout["pagesize"][1] * zoom_1
|
||
else:
|
||
x1 = x0 + self.plakativ.layout["pagesize"][1] * zoom_1
|
||
y1 = y0 + self.plakativ.layout["pagesize"][0] * zoom_1
|
||
self.canvas.create_rectangle(x0, y0, x1, y1, outline="red")
|
||
self.canvas.create_rectangle(
|
||
x0 + zoom_1 * self.border_left.get(),
|
||
y0 + zoom_1 * self.border_top.get(),
|
||
x1 - zoom_1 * self.border_right.get(),
|
||
y1 - zoom_1 * self.border_bottom.get(),
|
||
outline="blue",
|
||
)
|
||
|
||
def on_open_button(self):
|
||
filename = tkinter.filedialog.askopenfilename(
|
||
parent=self.master,
|
||
title="foobar",
|
||
filetypes=[("pdf documents", "*.pdf"), ("all files", "*")],
|
||
initialdir="/home/josch/git/plakativ",
|
||
initialfile="test.pdf",
|
||
)
|
||
if filename == ():
|
||
return
|
||
self.filename = filename
|
||
self.plakativ.open(self.filename)
|
||
# compute the splitting with the current values
|
||
mode, (_, size), mult, npages = self.postersize.value
|
||
size, mult, npages = self.plakativ.compute_layout(mode, size, mult, npages)
|
||
# copy computed values to postersize widget
|
||
mode, (custom_size, _), _, _ = self.postersize.value
|
||
self.postersize.value = (
|
||
mode,
|
||
(custom_size, size),
|
||
mult,
|
||
npages,
|
||
)
|
||
# update postersize widget
|
||
self.postersize.set(*self.postersize.value)
|
||
# draw preview in canvas
|
||
self.draw()
|
||
# enable save button
|
||
self.save_button.configure(state=tkinter.NORMAL)
|
||
# set callback function
|
||
self.postersize.callback = self.on_postersize
|
||
|
||
def on_save_button(self):
|
||
base, ext = os.path.splitext(os.path.basename(self.filename))
|
||
filename = tkinter.filedialog.asksaveasfilename(
|
||
parent=self.master,
|
||
title="foobar",
|
||
defaultextension=".pdf",
|
||
filetypes=[("pdf documents", "*.pdf"), ("all files", "*")],
|
||
initialdir="/home/josch/git/plakativ",
|
||
initialfile=base + "_poster" + ext,
|
||
)
|
||
if filename == "":
|
||
return
|
||
self.plakativ.render(filename)
|
||
|
||
|
||
class PostersizeWidget(tkinter.LabelFrame):
|
||
def __init__(self, parent, *args, **kw):
|
||
tkinter.LabelFrame.__init__(self, parent, text="Poster Size", *args, **kw)
|
||
|
||
self.callback = None
|
||
|
||
self.variables = {
|
||
"radio": tkinter.StringVar(),
|
||
"dropdown": tkinter.StringVar(),
|
||
"width": tkinter.DoubleVar(),
|
||
"height": tkinter.DoubleVar(),
|
||
"multiplier": tkinter.DoubleVar(),
|
||
"pages": tkinter.IntVar(),
|
||
}
|
||
|
||
for k, v in self.variables.items():
|
||
# need to pass k and v as function arguments so that their value
|
||
# does not get overwritten each loop iteration
|
||
def callback(varname, idx, op, k_copy=k, v_copy=v):
|
||
assert op == "w"
|
||
getattr(self, "on_" + k_copy)(v_copy.get())
|
||
|
||
v.trace("w", callback)
|
||
|
||
tkinter.Radiobutton(
|
||
self,
|
||
text="Fit into width/height",
|
||
variable=self.variables["radio"],
|
||
value="size",
|
||
state=tkinter.DISABLED,
|
||
name="size_radio",
|
||
).grid(row=0, column=0, columnspan=3, sticky=tkinter.W)
|
||
|
||
OptionMenu(
|
||
self,
|
||
self.variables["dropdown"],
|
||
*PAGE_SIZES.keys(),
|
||
# state=tkinter.DISABLED,
|
||
name="size_dropdown"
|
||
).grid(row=1, column=0, columnspan=3, sticky=tkinter.W, padx=(27, 0))
|
||
|
||
tkinter.Label(
|
||
self, text="Width:", state=tkinter.DISABLED, name="size_label_width"
|
||
).grid(row=2, column=0, sticky=tkinter.W, padx=(27, 0))
|
||
tkinter.Spinbox(
|
||
self,
|
||
format="%.2f",
|
||
increment=0.1,
|
||
from_=0,
|
||
to=10000,
|
||
width=5,
|
||
textvariable=self.variables["width"],
|
||
state=tkinter.DISABLED,
|
||
name="size_spinbox_width",
|
||
).grid(row=2, column=1, sticky=tkinter.W)
|
||
tkinter.Label(
|
||
self, text="mm", state=tkinter.DISABLED, name="size_label_width_mm"
|
||
).grid(row=2, column=2, sticky=tkinter.W)
|
||
|
||
tkinter.Label(
|
||
self, text="Height:", state=tkinter.DISABLED, name="size_label_height"
|
||
).grid(row=3, column=0, sticky=tkinter.W, padx=(27, 0))
|
||
tkinter.Spinbox(
|
||
self,
|
||
format="%.2f",
|
||
increment=0.1,
|
||
from_=0,
|
||
to=10000,
|
||
width=5,
|
||
textvariable=self.variables["height"],
|
||
state=tkinter.DISABLED,
|
||
name="size_spinbox_height",
|
||
).grid(row=3, column=1, sticky=tkinter.W)
|
||
tkinter.Label(
|
||
self, text="mm", state=tkinter.DISABLED, name="size_label_height_mm"
|
||
).grid(row=3, column=2, sticky=tkinter.W)
|
||
|
||
tkinter.Radiobutton(
|
||
self,
|
||
text="Factor of input page size",
|
||
variable=self.variables["radio"],
|
||
value="mult",
|
||
state=tkinter.DISABLED,
|
||
name="mult_radio",
|
||
).grid(row=4, column=0, columnspan=3, sticky=tkinter.W)
|
||
tkinter.Label(
|
||
self,
|
||
text="Multipler:",
|
||
state=tkinter.DISABLED,
|
||
name="mult_label_multiplier",
|
||
).grid(row=5, column=0, sticky=tkinter.W, padx=(27, 0))
|
||
tkinter.Spinbox(
|
||
self,
|
||
format="%.2f",
|
||
increment=0.01,
|
||
from_=0,
|
||
to=10000,
|
||
width=6,
|
||
textvariable=self.variables["multiplier"],
|
||
state=tkinter.DISABLED,
|
||
name="mult_spinbox_multiplier",
|
||
).grid(row=5, column=1, sticky=tkinter.W)
|
||
tkinter.Label(
|
||
self, text="%", state=tkinter.DISABLED, name="mult_label_perc"
|
||
).grid(row=5, column=2, sticky=tkinter.W)
|
||
|
||
tkinter.Radiobutton(
|
||
self,
|
||
text="Fit into X output pages",
|
||
variable=self.variables["radio"],
|
||
value="npages",
|
||
state=tkinter.DISABLED,
|
||
name="npages_radio",
|
||
).grid(row=6, column=0, columnspan=3, sticky=tkinter.W)
|
||
tkinter.Label(
|
||
self, text="# of pages:", state=tkinter.DISABLED, name="npages_label"
|
||
).grid(row=7, column=0, sticky=tkinter.W, padx=(27, 0))
|
||
tkinter.Spinbox(
|
||
self,
|
||
increment=1,
|
||
from_=1,
|
||
to=10000,
|
||
width=6,
|
||
textvariable=self.variables["pages"],
|
||
state=tkinter.DISABLED,
|
||
name="npages_spinbox",
|
||
).grid(row=7, column=1, sticky=tkinter.W)
|
||
|
||
def on_radio(self, value):
|
||
_, size, mult, npages = self.value
|
||
self.set(value, size, mult, npages)
|
||
|
||
def on_dropdown(self, value):
|
||
mode, (custom_size, size), mult, npages = self.value
|
||
if value == "custom":
|
||
custom_size = True
|
||
else:
|
||
custom_size = False
|
||
size = PAGE_SIZES[value]
|
||
self.set(mode, (custom_size, size), mult, npages)
|
||
|
||
def on_width(self, value):
|
||
if getattr(self, "value", None) is None:
|
||
return
|
||
mode, (custom_size, (_, height)), mult, npages = self.value
|
||
self.set(mode, (custom_size, (value, height)), mult, npages)
|
||
|
||
def on_height(self, value):
|
||
if getattr(self, "value", None) is None:
|
||
return
|
||
mode, (custom_size, (width, _)), mult, npages = self.value
|
||
self.set(mode, (custom_size, (width, value)), mult, npages)
|
||
|
||
def on_multiplier(self, value):
|
||
if getattr(self, "value", None) is None:
|
||
return
|
||
mode, size, _, npages = self.value
|
||
self.set(mode, size, value, npages)
|
||
|
||
def on_pages(self, value):
|
||
if getattr(self, "value", None) is None:
|
||
return
|
||
mode, size, mult, _ = self.value
|
||
self.set(mode, size, mult, value)
|
||
|
||
def set(self, mode, size, mult, npages):
|
||
# before setting self.value, check if the effective value is different
|
||
# from before or otherwise we do not need to execute the callback in
|
||
# the end
|
||
state_changed = True
|
||
if getattr(self, "value", None) is not None:
|
||
if mode == self.value[0] == "size":
|
||
state_changed = self.value[1][1] != size[1]
|
||
elif mode == self.value[0] == "mult":
|
||
state_changed = self.value[2] != mult
|
||
elif mode == self.value[0] == "npages":
|
||
state_changed = self.value[3] != npages
|
||
# execute callback if necessary
|
||
if state_changed and self.callback is not None:
|
||
mode, size, mult, npages = self.callback((mode, size, mult, npages))
|
||
self.value = (mode, size, mult, npages)
|
||
custom_size, (width, height) = size
|
||
# cycle through all widgets and set the state accordingly
|
||
for k, v in self.children.items():
|
||
if k.endswith("_radio"):
|
||
v.configure(state=tkinter.NORMAL)
|
||
continue
|
||
if not k.startswith(mode + "_"):
|
||
v.configure(state=tkinter.DISABLED)
|
||
continue
|
||
if k in ["size_dropdown", "size_radio"]:
|
||
v.configure(state=tkinter.NORMAL)
|
||
continue
|
||
if mode != "size":
|
||
v.configure(state=tkinter.NORMAL)
|
||
continue
|
||
if custom_size:
|
||
v.configure(state=tkinter.NORMAL)
|
||
continue
|
||
v.configure(state=tkinter.DISABLED)
|
||
# only set variables that changed to not trigger multiple variable tracers
|
||
if custom_size or mode != "size":
|
||
if self.variables["dropdown"].get() != "custom":
|
||
self.variables["dropdown"].set("custom")
|
||
else:
|
||
val = dict(zip(PAGE_SIZES.values(), PAGE_SIZES.keys()))[(width, height)]
|
||
if self.variables["dropdown"].get() != val:
|
||
self.variables["dropdown"].set(val)
|
||
if self.variables["radio"].get() != mode:
|
||
self.variables["radio"].set(mode)
|
||
if self.variables["width"].get() != width:
|
||
self.variables["width"].set(width)
|
||
if self.variables["height"].get() != height:
|
||
self.variables["height"].set(height)
|
||
if self.variables["multiplier"].get() != mult:
|
||
self.variables["multiplier"].set(mult)
|
||
if self.variables["pages"].get() != npages:
|
||
self.variables["pages"].set(npages)
|
||
|
||
|
||
def compute_layout(infile, outfile, mode, size=None, mult=None, npages=None):
|
||
plakativ = Plakativ(infile)
|
||
plakativ.compute_layout(mode, size, mult, npages)
|
||
plakativ.render(outfile)
|
||
|
||
|
||
def gui():
|
||
root = tkinter.Tk()
|
||
app = Application(master=root)
|
||
app.mainloop()
|
||
|
||
|
||
def main():
|
||
parser = argparse.ArgumentParser()
|
||
gui_group = parser.add_mutually_exclusive_group(required=False)
|
||
gui_group.add_argument(
|
||
"--gui",
|
||
dest="gui",
|
||
action="store_true",
|
||
help="run tkinter gui (default on Windows)",
|
||
)
|
||
gui_group.add_argument(
|
||
"--nogui",
|
||
dest="gui",
|
||
action="store_false",
|
||
help="don't run tkinter gui (default elsewhere)",
|
||
)
|
||
if platform.system() == "Windows":
|
||
parser.set_defaults(gui=True)
|
||
else:
|
||
parser.set_defaults(gui=False)
|
||
|
||
parser.add_argument("-o", "--output", help="output file")
|
||
|
||
parser.add_argument("input", nargs="?", help="input file")
|
||
|
||
args = parser.parse_args()
|
||
|
||
if args.gui:
|
||
gui()
|
||
exit(0)
|
||
|
||
compute_layout(args.input, args.output)
|
||
|
||
if __name__ == "__main__":
|
||
main()
|
||
|
||
__all__ = ["Plakativ", "compute_layout"]
|