/*
* PaperJam -- Commands
*
- * (c) 2018 Martin Mares <mj@ucw.cz>
+ * (c) 2018--2022 Martin Mares <mj@ucw.cz>
*/
#include <cassert>
};
static const arg_def no_args[] = {
- { NULL, 0 }
+ { NULL, 0, NULL }
};
/*** Generic routines ***/
-// Transformed page
-
-class xform_page : public page {
- page *orig_page;
- pdf_matrix xform;
-public:
- void render(out_context *out, pdf_matrix xform) override;
- xform_page(page *p, pdf_matrix xf);
-};
-
-xform_page::xform_page(page *p, pdf_matrix xf)
-{
- orig_page = p;
- index = p->index;
- xform = xf;
-
- BBox media(p->width, p->height);
- media.transform(xf);
- width = media.width();
- height = media.height();
-
- image_box = p->image_box;
- image_box.transform(xf);
-}
-
-void xform_page::render(out_context *out, pdf_matrix parent_xform)
-{
- orig_page->render(out, xform * parent_xform);
-}
-
// Commands acting on individual pages
class cmd_exec_simple : public cmd_exec {
};
#define PAPER_ARGS \
- { "paper", AT_STRING | AT_POSITIONAL }, \
- { "w", AT_DIMEN }, \
- { "h", AT_DIMEN }
+ { "paper", AT_STRING | AT_POSITIONAL, "Paper format name (e.g., a4)" }, \
+ { "w", AT_DIMEN, "Paper width" }, \
+ { "h", AT_DIMEN, "Paper height" }
// Position specification
};
#define POS_ARGS \
- { "pos", AT_STRING }
+ { "pos", AT_STRING, "Position on the page: (t|c|b)(l|c|r)" }
// Margins
{
bb->x_min += l;
bb->x_max -= r;
- bb->y_min += b;
- bb->y_max -= t;
+ bb->y_min += t;
+ bb->y_max -= b;
if (bb->x_min >= bb->x_max || bb->y_min >= bb->y_max)
err("Margins cannot be larger than the whole page");
}
{
bb->x_min -= l;
bb->x_max += r;
- bb->y_min -= b;
- bb->y_max += t;
+ bb->y_min -= t;
+ bb->y_max += b;
}
};
-#define MARGIN_ARGS1_NAMED(name) \
- { name, AT_DIMEN }
+#define MARGIN_ARGS1_NAMED(name) \
+ { name, AT_DIMEN, "Size of all margins (default: 0)" }
-#define MARGIN_ARGS1_POSNL(name) \
- { name, AT_DIMEN | AT_POSITIONAL }
+#define MARGIN_ARGS1_POSNL(name) \
+ { name, AT_DIMEN | AT_POSITIONAL, "Size of all margins (default: 0)" }
-#define MARGIN_ARGS2(sx) \
- { "h" sx, AT_DIMEN }, \
- { "v" sx, AT_DIMEN }, \
- { "l" sx, AT_DIMEN }, \
- { "r" sx, AT_DIMEN }, \
- { "t" sx, AT_DIMEN }, \
- { "b" sx, AT_DIMEN }
+#define MARGIN_ARGS2(sx) \
+ { "h" sx, AT_DIMEN, "Size of horizontal margins" }, \
+ { "v" sx, AT_DIMEN, "Size of vertical margins" }, \
+ { "l" sx, AT_DIMEN, "Size of left margin" }, \
+ { "r" sx, AT_DIMEN, "Size of right margin" }, \
+ { "t" sx, AT_DIMEN, "Size of top margin" }, \
+ { "b" sx, AT_DIMEN, "Size of bottom margin" }
// Colors
return s;
}
-#define CROPMARK_ARGS(px) \
- { px "mark", AT_STRING }, \
- { px "pen", AT_DIMEN }, \
- { px "len", AT_DIMEN }, \
- { px "offset",AT_DIMEN }, \
- { px "color", AT_STRING }
+#define CROPMARK_ARGS(px) \
+ { px "mark", AT_STRING, "Cropmark style: box/cross/in/out/bg" }, \
+ { px "pen", AT_DIMEN, "Cropmark pen width (default: 0.2pt)" }, \
+ { px "len", AT_DIMEN, "Cropmark arm length (default: 5mm)" }, \
+ { px "offset",AT_DIMEN, "Cropmark offset outside the box (default: 0)" }, \
+ { px "color", AT_STRING, "Cropmark color (RRGGBB, default: 000000)" }
// Scaling preserving aspect ratio
{
pdf_matrix m;
m.shift(x, y);
- return new xform_page(p, m);
+ return new xform_page(p, "move", m);
}
};
static const arg_def move_args[] = {
- { "x", AT_DIMEN | AT_MANDATORY | AT_POSITIONAL },
- { "y", AT_DIMEN | AT_MANDATORY | AT_POSITIONAL },
- { NULL, 0 }
+ { "x", AT_DIMEN | AT_MANDATORY | AT_POSITIONAL, "Move right by this distance" },
+ { "y", AT_DIMEN | AT_MANDATORY | AT_POSITIONAL, "Move up by this distance" },
+ { NULL, 0, NULL }
};
/*** scale ***/
{
pdf_matrix m;
m.scale(x_factor, y_factor);
- return new xform_page(p, m);
+ return new xform_page(p, "scale", m);
}
};
static const arg_def scale_args[] = {
- { "x", AT_DOUBLE | AT_MANDATORY | AT_POSITIONAL },
- { "y", AT_DOUBLE | AT_POSITIONAL },
- { NULL, 0 }
+ { "x", AT_DOUBLE | AT_MANDATORY | AT_POSITIONAL, "Scale horizontally by this fraction" },
+ { "y", AT_DOUBLE | AT_POSITIONAL, "Scale vertically by this fraction (default: x)" },
+ { NULL, 0, NULL }
};
/*** rotate ***/
public:
rotate_cmd(cmd *c)
{
- deg = c->arg("deg")->as_int(0) % 360;
+ deg = c->arg("angle")->as_int(0) % 360;
if (deg < 0)
deg += 360;
if (deg % 90)
}
page *process_page(page *p) override
{
- pdf_matrix m;
- switch (deg)
- {
- case 0:
- break;
- case 90:
- m.rotate_deg(-90);
- m.shift(0, p->width);
- break;
- case 180:
- m.rotate_deg(180);
- m.shift(p->width, p->height);
- break;
- case 270:
- m.rotate_deg(90);
- m.shift(p->height, 0);
- break;
- default:
- abort();
- }
- return new xform_page(p, m);
+ return new xform_page(p, "rotate", pdf_rotation_matrix(deg, p->width, p->height));
}
};
static const arg_def rotate_args[] = {
- { "angle", AT_INT | AT_MANDATORY | AT_POSITIONAL },
- { NULL, 0 }
+ { "angle", AT_INT | AT_MANDATORY | AT_POSITIONAL, "Rotate clockwise by this angle" },
+ { NULL, 0, NULL }
};
/*** flip ***/
m.scale(-1, 1);
m.shift(p->width, 0);
}
- return new xform_page(p, m);
+ return new xform_page(p, "flip", m);
}
};
static const arg_def flip_args[] = {
- { "h", AT_SWITCH },
- { "v", AT_SWITCH },
- { NULL, 0 }
+ { "h", AT_SWITCH, "Flip horizontally" },
+ { "v", AT_SWITCH, "Flip vertically" },
+ { NULL, 0, NULL }
};
/*** select ***/
int f = validate_page_index(pages, ps.from);
int t = validate_page_index(pages, ps.to);
int step = (f <= t) ? 1 : -1;
- for (int i=f; f<=t; f += step)
+ for (int i=f; i != t + step; i += step)
selected.push_back(pages[i]);
}
auto processed = run_command_list(pb->commands, selected);
}
static const arg_def modulo_args[] = {
- { "n", AT_INT | AT_MANDATORY | AT_POSITIONAL },
- { "half", AT_SWITCH },
- { NULL, 0 }
+ { "n", AT_INT | AT_MANDATORY | AT_POSITIONAL, "Number of pages in a single tuple" },
+ { "half", AT_SWITCH, "Process only the first half of n-tuples" },
+ { NULL, 0, NULL }
};
/*** debug ***/
out->contents += page_cm->pdf_stream(out, page_bbox, xform);
out->contents += image_cm->pdf_stream(out, image_box, xform);
}
+ void debug_dump() override
+ {
+ debug("Draw debugging boxes");
+ orig_page->debug_dump();
+ }
};
class debug_cmd : public cmd_exec_simple {
for (auto p: orig_pages)
p->render(out, xform);
}
+ void debug_dump() override
+ {
+ debug("Merge pages");
+ debug_indent += 4;
+ for (auto p: orig_pages)
+ p->debug_dump();
+ debug_indent -= 4;
+ }
};
vector<page *> merge_cmd::process(vector<page *> &pages)
{
BBox paper_box = BBox(paper.w, paper.h);
pdf_matrix xf = pos.place(p->image_box, paper_box);
- page *q = new xform_page(p, xf);
+ page *q = new xform_page(p, "paper", xf);
q->width = paper.w;
q->height = paper.h;
return q;
static const arg_def paper_args[] = {
PAPER_ARGS,
POS_ARGS,
- { NULL, 0 }
+ { NULL, 0, NULL }
};
/*** scaleto ***/
xf.scale(scale_to_fit(orig_box, paper_box));
orig_box.transform(xf);
xf.concat(pos.place(orig_box, paper_box));
- page *q = new xform_page(p, xf);
+ page *q = new xform_page(p, "scaleto", xf);
q->width = paper.w;
q->height = paper.h;
return q;
static const arg_def scaleto_args[] = {
PAPER_ARGS,
POS_ARGS,
- { NULL, 0 }
+ { NULL, 0, NULL }
};
/*** fit ***/
xf.scale(scale_to_fit(orig_box, paper_box));
orig_box.transform(xf);
xf.concat(pos.place(orig_box, paper_box));
- q = new xform_page(p, xf);
+ q = new xform_page(p, "fit", xf);
q->width = paper.w;
q->height = paper.h;
}
// No paper given: adjust paper to fit image
xf.shift(-p->image_box.x_min, -p->image_box.y_min);
xf.shift(marg.l, marg.b);
- q = new xform_page(p, xf);
+ q = new xform_page(p, "fit", xf);
q->width = p->image_box.width() + marg.l + marg.r;
q->height = p->image_box.height() + marg.t + marg.b;
}
POS_ARGS,
MARGIN_ARGS1_NAMED("margin"),
MARGIN_ARGS2("margin"),
- { NULL, 0 }
+ { NULL, 0, NULL }
};
/*** expand ***/
{
pdf_matrix xf;
xf.shift(marg.l, marg.b);
- page *q = new xform_page(p, xf);
+ page *q = new xform_page(p, "expand", xf);
q->width = p->width + marg.l + marg.r;
q->height = p->height + marg.t + marg.b;
if (q->width < 0.001 || q->height < 0.001)
static const arg_def expand_args[] = {
MARGIN_ARGS1_POSNL("by"),
MARGIN_ARGS2(""),
- { NULL, 0 }
+ { NULL, 0, NULL }
};
/*** margins ***/
margins_cmd(cmd *c) : marg(c, "size", "") { }
page *process_page(page *p) override
{
- pdf_matrix xf;
- xf.shift(-p->image_box.x_min, -p->image_box.y_min);
- xf.shift(marg.l, marg.b);
- page *q = new xform_page(p, xf);
- q->width = p->image_box.width() + marg.l + marg.r;
- q->height = p->image_box.height() + marg.t + marg.b;
- if (q->width < 0.001 || q->height < 0.001)
- err("Margins must result in positive page dimensions");
+ page *q = new xform_page(p, "margins", pdf_matrix());
+ q->image_box = BBox(marg.l, marg.t, p->width - marg.r, p->height - marg.b);
+ if (q->image_box.width() < 0.001 || q->image_box.height() < 0.001)
+ err("Margins must result in positive image dimensions");
return q;
}
};
static const arg_def margins_args[] = {
MARGIN_ARGS1_POSNL("size"),
MARGIN_ARGS2(""),
- { NULL, 0 }
+ { NULL, 0, NULL }
};
/*** add-blank ***/
}
static const arg_def add_blank_args[] = {
- { "n", AT_INT | AT_POSITIONAL },
+ { "n", AT_INT | AT_POSITIONAL, "Number of blank pages to add (default: 1)" },
PAPER_ARGS,
- { NULL, 0 }
+ { NULL, 0, NULL }
};
/*** book ***/
}
static const arg_def book_args[] = {
- { "n", AT_INT | AT_POSITIONAL },
- { NULL, 0 }
+ { "n", AT_INT | AT_POSITIONAL, "Number of pages in a single booklet" },
+ { NULL, 0, NULL }
};
/*** nup ***/
else if (by == "tile" || by == "t")
fill_by = BY_TILE;
else
- err("Parameter \"by\" must be rows/cols/tile");
+ err("Argument \"by\" must be rows/cols/tile");
crop = c->arg("crop")->as_int(0);
mixed = c->arg("mixed")->as_int(0);
cropmark_spec *cmarks;
void render(out_context *out, pdf_matrix xform) override;
nup_page(nup_state &st) : page(st.paper_w, st.paper_h) { }
+ void debug_dump() override
+ {
+ debug("N-up printing");
+ debug_indent += 4;
+ for (auto p: orig_pages)
+ p->debug_dump();
+ debug_indent -= 4;
+ }
};
void nup_page::render(out_context *out, pdf_matrix parent_xform)
}
static const arg_def nup_args[] = {
- { "n", AT_INT | AT_POSITIONAL | AT_MANDATORY },
- { "m", AT_INT | AT_POSITIONAL },
- { "by", AT_STRING },
- { "crop", AT_SWITCH },
- { "mixed", AT_SWITCH },
- { "rotate", AT_SWITCH },
- { "scale", AT_DOUBLE },
+ { "n", AT_INT | AT_POSITIONAL | AT_MANDATORY, "Number of tiles on a page" },
+ { "m", AT_INT | AT_POSITIONAL, "If both n and m are given, produce n x m tiles on a page" },
+ { "by", AT_STRING, "Tile filling order: rows/cols/tile (default: rows)" },
+ { "crop", AT_SWITCH, "Crop input pages to their image box" },
+ { "mixed", AT_SWITCH, "Allow input pages of mixed sizes" },
+ { "rotate", AT_SWITCH, "Force (non-)rotation" },
+ { "scale", AT_DOUBLE, "Force specific scaling factor" },
PAPER_ARGS,
MARGIN_ARGS1_NAMED("margin"),
MARGIN_ARGS2("margin"),
POS_ARGS,
CROPMARK_ARGS("c"),
- { "tpos", AT_STRING },
- { "space", AT_DIMEN },
- { "hspace", AT_DIMEN },
- { "vspace", AT_DIMEN },
- { NULL, 0 }
+ { "tpos", AT_STRING, "Position of images inside tiles (default: tl)" },
+ { "space", AT_DIMEN, "Space between tiles (default: 0)" },
+ { "hspace", AT_DIMEN, "Horizontal space between tiles (default: space)" },
+ { "vspace", AT_DIMEN, "Vertical space between tiles (default: space)" },
+ { NULL, 0, NULL }
};
/*** cropmarks ***/
orig_page->render(out, xform);
out->contents += cm->pdf_stream(out, image_box, xform);
}
+ void debug_dump() override
+ {
+ debug("Add cropmarks");
+ orig_page->debug_dump();
+ }
cropmarks_page(page *p, cropmark_spec *cms) : page(p), orig_page(p), cm(cms) { }
};
static const arg_def cropmarks_args[] = {
CROPMARK_ARGS(""),
- { NULL, 0 }
+ { NULL, 0, NULL }
};
/*** clip ***/
orig_page->render(out, xform);
out->contents += "Q ";
}
+ void debug_dump() override
+ {
+ debug("Clip [%.3f %.3f %.3f %.3f]", clip_to.x_min, clip_to.y_min, clip_to.x_max, clip_to.y_max);
+ orig_page->debug_dump();
+ }
clip_page(page *p, BBox &to) : page(p), orig_page(p), clip_to(to) { }
};
};
static const arg_def clip_args[] = {
- { "bleed", AT_DIMEN },
- { NULL, 0 }
+ { "bleed", AT_DIMEN, "Allow bleeding of image outside its box" },
+ { NULL, 0, NULL }
+};
+
+/*** common ***/
+
+class common_cmd : public cmd_exec {
+ vector<page *> process(vector<page *> &pages) override
+ {
+ if (!pages.size())
+ return pages;
+
+ const page *first = pages[0];
+ BBox pbox(first->width, first->height);
+ BBox ibox = first->image_box;
+ for (auto p: pages)
+ {
+ BBox pg(p->width, p->height);
+ pbox.join(pg);
+ ibox.join(p->image_box);
+ }
+
+ vector<page *> out;
+ for (auto p: pages)
+ {
+ page *q = new xform_page(p, "common", pdf_matrix());
+ q->width = pbox.width();
+ q->height = pbox.height();
+ q->image_box = ibox;
+ out.push_back(q);
+ }
+
+ return out;
+ }
+public:
+ common_cmd(cmd *c UNUSED) { }
+};
+
+/*** slice ***/
+
+class slice_cmd : public cmd_exec {
+ paper_spec paper;
+ pos_spec pos;
+ margin_spec margin;
+ double bleed;
+public:
+ slice_cmd(cmd *c) : paper(c), pos(c), margin(c, "margin", "margin")
+ {
+ if (is_zero(paper.w) || is_zero(paper.h))
+ err("Paper format must be given");
+ bleed = c->arg("bleed")->as_double(0);
+ }
+ vector<page *> process(vector<page *> &pages) override;
+};
+
+vector<page *> slice_cmd::process(vector<page *> &pages)
+{
+ vector<page *> out;
+
+ for (auto p: pages)
+ {
+ double pw = paper.w - margin.l - margin.r;
+ double ph = paper.h - margin.t - margin.b;
+ if (pw < 0 || ph < 0)
+ err("Margins larger than paper");
+
+ int cols = (int) ceil((p->image_box.width() - 2*mm) / pw);
+ int rows = (int) ceil((p->image_box.height() - 2*mm) / ph);
+ BBox big_box(cols*pw, rows*ph);
+ pdf_matrix placement = pos.place(p->image_box, big_box);
+
+ debug("Slicing [%.3f,%.3f] to %dx%d [%.3f,%.3f]", p->image_box.width(), p->image_box.height(), rows, cols, pw, ph);
+ for (int r=0; r<rows; r++)
+ for (int c=0; c<cols; c++)
+ {
+ pdf_matrix xf = placement;
+ xf.shift(-c*pw, -(rows-1-r)*ph);
+ xf.shift(margin.l, margin.t);
+ page *q = new xform_page(p, "slice", xf);
+ q->width = paper.w;
+ q->height = paper.h;
+ BBox slice_box = BBox(margin.l, margin.t, paper.w - margin.r, paper.h - margin.b);
+ q->image_box = p->image_box.transformed(xf);
+ q->image_box.intersect(slice_box);
+ BBox bleeding_slice = slice_box.enlarged(bleed);
+ out.push_back(new clip_page(q, bleeding_slice));
+ }
+ }
+
+ return out;
+}
+
+static const arg_def slice_args[] = {
+ PAPER_ARGS,
+ POS_ARGS,
+ MARGIN_ARGS1_NAMED("margin"),
+ MARGIN_ARGS2("margin"),
+ { "bleed", AT_DIMEN, "Allow bleeding of image outside its box" },
+ { NULL, 0, NULL }
};
/*** Command table ***/
template<typename T> cmd_exec *ctor(cmd *c) { return new T(c); }
const cmd_def cmd_table[] = {
- { "add-blank",add_blank_args, 0, &ctor<add_blank_cmd> },
- { "apply", no_args, 1, &ctor<apply_cmd> },
- { "book", book_args, 0, &ctor<book_cmd> },
- { "clip", clip_args, 0, &ctor<clip_cmd> },
- { "cropmarks",cropmarks_args, 0, &ctor<cropmarks_cmd> },
- { "debug", no_args, 0, &ctor<debug_cmd> },
- { "expand", expand_args, 0, &ctor<expand_cmd> },
- { "fit", fit_args, 0, &ctor<fit_cmd> },
- { "flip", flip_args, 0, &ctor<flip_cmd> },
- { "margins", margins_args, 0, &ctor<margins_cmd> },
- { "merge", no_args, 0, &ctor<merge_cmd> },
- { "modulo", modulo_args, 1, &ctor<modulo_cmd> },
- { "move", move_args, 0, &ctor<move_cmd> },
- { "null", no_args, 0, &ctor<null_cmd> },
- { "nup", nup_args, 0, &ctor<nup_cmd> },
- { "paper", paper_args, 0, &ctor<paper_cmd> },
- { "rotate", rotate_args, 0, &ctor<rotate_cmd> },
- { "scale", scale_args, 0, &ctor<scale_cmd> },
- { "scaleto", scaleto_args, 0, &ctor<scaleto_cmd> },
- { "select", no_args, 1, &ctor<select_cmd> },
- { NULL, NULL, 0, NULL }
+ { "add-blank",add_blank_args, 0, &ctor<add_blank_cmd>,
+ "Add blank page(s) after each page" },
+ { "apply", no_args, 1, &ctor<apply_cmd>,
+ "Apply commands to selected pages" },
+ { "book", book_args, 0, &ctor<book_cmd>,
+ "Prepare booklets for book binding" },
+ { "clip", clip_args, 0, &ctor<clip_cmd>,
+ "Suppress page contents drawn outside the image box" },
+ { "common", no_args, 0, &ctor<common_cmd>,
+ "Use a common page size and image box for all pages" },
+ { "cropmarks",cropmarks_args, 0, &ctor<cropmarks_cmd>,
+ "Draw cropping marks around the image box" },
+ { "debug", no_args, 0, &ctor<debug_cmd>,
+ "Draw debugging information on the page)" },
+ { "expand", expand_args, 0, &ctor<expand_cmd>,
+ "Expand paper around the image" },
+ { "fit", fit_args, 0, &ctor<fit_cmd>,
+ "Fit image to a given paper" },
+ { "flip", flip_args, 0, &ctor<flip_cmd>,
+ "Flip page horizontally and/or vertically" },
+ { "margins", margins_args, 0, &ctor<margins_cmd>,
+ "Define image box by dimensions of margins around it" },
+ { "merge", no_args, 0, &ctor<merge_cmd>,
+ "Merge all pages to one by placing them one over another" },
+ { "modulo", modulo_args, 1, &ctor<modulo_cmd>,
+ "Act on n-tuples of pages" },
+ { "move", move_args, 0, &ctor<move_cmd>,
+ "Shift contents on the page" },
+ { "null", no_args, 0, &ctor<null_cmd>,
+ "Do nothing" },
+ { "nup", nup_args, 0, &ctor<nup_cmd>,
+ "Combine multiple pages to one (n-up printing)" },
+ { "paper", paper_args, 0, &ctor<paper_cmd>,
+ "Place image on a given paper" },
+ { "rotate", rotate_args, 0, &ctor<rotate_cmd>,
+ "Rotate the page by multiples of 90 degrees" },
+ { "scale", scale_args, 0, &ctor<scale_cmd>,
+ "Scale the page by a given factor" },
+ { "scaleto", scaleto_args, 0, &ctor<scaleto_cmd>,
+ "Scale the page to a given size" },
+ { "select", no_args, 1, &ctor<select_cmd>,
+ "Select a subset of pages" },
+ { "slice", slice_args, 0, &ctor<slice_cmd>,
+ "Slice to smaller pages" },
+ { NULL, NULL, 0, NULL,
+ NULL, }
};