4 * (c) 2018 Martin Mares <mj@ucw.cz>
16 class null_cmd : public cmd_exec {
18 null_cmd(cmd *c UNUSED) { }
19 vector<page *> process(vector<page *> &pages) override { return pages; }
22 static const arg_def no_args[] = {
26 /*** Generic routines ***/
30 class xform_page : public page {
34 void render(out_context *out, pdf_matrix xform) override;
35 xform_page(page *p, pdf_matrix xf);
38 xform_page::xform_page(page *p, pdf_matrix xf)
44 BBox media(p->width, p->height);
46 width = media.width();
47 height = media.height();
49 image_box = p->image_box;
50 image_box.transform(xf);
53 void xform_page::render(out_context *out, pdf_matrix parent_xform)
55 orig_page->render(out, xform * parent_xform);
58 // Commands acting on individual pages
60 class cmd_exec_simple : public cmd_exec {
61 virtual page *process_page(page *p) = 0;
62 vector<page *> process(vector<page *> &pages) override;
65 vector<page *> cmd_exec_simple::process(vector<page *> &pages)
69 out.push_back(process_page(p));
73 // Paper specifications
78 paper_spec(cmd *c, bool maybe=true)
80 arg_val *aname = c->arg("paper");
81 arg_val *aw = c->arg("w");
82 arg_val *ah = c->arg("h");
83 if (!aname->given() && !aw->given() && !ah->given() && maybe)
88 if (aw->given() != ah->given() || aname->given() == aw->given())
89 die("Either paper format name or width and height must be given");
92 const char *name = aname->as_string("").c_str();
93 const paper *pap = paperinfo(name);
95 die("No paper called %s is known", name);
96 w = paperpswidth(pap);
97 h = paperpsheight(pap);
101 w = aw->as_double(0);
102 h = ah->as_double(0);
108 { "paper", AT_STRING | AT_POSITIONAL }, \
112 // Position specification
117 pos_spec() { v = h = 0; }
121 die("Value of pos must have two characters");
124 else if (s[0] == 'c')
126 else if (s[0] == 'b')
129 die("First character of pos must be t/c/b");
132 else if (s[1] == 'c')
134 else if (s[1] == 'r')
137 die("Second character of pos must be l/c/r");
139 pos_spec(cmd *c) : pos_spec(c->arg("pos")->as_string("cc")) { }
140 pdf_matrix place(BBox &inner, BBox &outer)
143 m.shift(-inner.x_min, -inner.y_min);
149 m.shift((outer.width() - inner.width()) / 2, 0);
152 m.shift(outer.width() - inner.width(), 0);
162 m.shift(0, (outer.height() - inner.height()) / 2);
165 m.shift(0, outer.height() - inner.height());
170 m.shift(outer.x_min, outer.y_min);
183 margin_spec(cmd *c, string basic, string sx)
186 m = c->arg(basic)->as_double(0);
187 h = c->arg("h" + sx)->as_double(m);
188 v = c->arg("v" + sx)->as_double(m);
189 l = c->arg("l" + sx)->as_double(h);
190 r = c->arg("r" + sx)->as_double(h);
191 t = c->arg("t" + sx)->as_double(v);
192 b = c->arg("b" + sx)->as_double(v);
194 bool may_shrink(BBox *bb)
196 return (bb->width() > l+r && bb->height() > t+b);
198 void shrink_box(BBox *bb)
204 if (bb->x_min >= bb->x_max || bb->y_min >= bb->y_max)
205 die("Margins cannot be larger than the whole page");
207 void expand_box(BBox *bb)
216 #define MARGIN_ARGS1_NAMED(name) \
219 #define MARGIN_ARGS1_POSNL(name) \
220 { name, AT_DIMEN | AT_POSITIONAL }
222 #define MARGIN_ARGS2(sx) \
223 { "h" sx, AT_DIMEN }, \
224 { "v" sx, AT_DIMEN }, \
225 { "l" sx, AT_DIMEN }, \
226 { "r" sx, AT_DIMEN }, \
227 { "t" sx, AT_DIMEN }, \
238 die("Invalid color specification \"%s\": expecting 6 hex digits", s.c_str());
239 for (int i=0; i<3; i++)
242 for (int j=0; j<2; j++)
245 if (c >= '0' && c <= '9')
246 x = (x << 4) | (c - '0');
247 else if (c >= 'a' && c <= 'f')
248 x = (x << 4) | (c - 'a' + 10);
249 else if (c >= 'A' && c <= 'F')
250 x = (x << 4) | (c - 'A' + 10);
257 return pdf_coord(rgb[0]) + " " + pdf_coord(rgb[1]) + " " + pdf_coord(rgb[2]);
263 class cropmark_spec {
274 string crop_cross(double x, double y, uint mask);
275 QPDFObjectHandle egstate;
278 cropmark_spec(cmd *c, const string prefix="", const string def_type="cross") : color(c->arg(prefix + "color")->as_string("000000"))
280 string t = c->arg(prefix + "mark")->as_string(def_type);
285 else if (t == "cross")
292 die("Invalid cropmark type %s", t.c_str());
294 pen_width = c->arg(prefix + "pen")->as_double(0.2);
295 arm_length = c->arg(prefix + "len")->as_double(5*mm);
296 offset = c->arg(prefix + "offset")->as_double(0);
297 egstate = QPDFObjectHandle::newNull();
299 string pdf_stream(out_context *out, BBox &box, pdf_matrix &xform);
302 string cropmark_spec::crop_cross(double x, double y, uint mask)
306 for (uint i=0; i<4; i++)
307 if (mask & (1U << i))
309 double x2 = x, y2 = y;
312 case 3: x2 -= arm_length; break;
313 case 2: x2 += arm_length; break;
314 case 1: y2 += arm_length; break;
315 case 0: y2 -= arm_length; break;
317 s += pdf_coord(x) + " " + pdf_coord(y) + " m " + pdf_coord(x2) + " " + pdf_coord(y2) + " l S ";
323 string cropmark_spec::pdf_stream(out_context *out, BBox &box, pdf_matrix &xform)
325 if (type == MARK_NONE)
329 s += color.to_string() + " RG ";
330 s += xform.to_string() + " cm ";
332 if (egstate.isNull())
334 auto egs = QPDFObjectHandle::newDictionary();
335 egs.replaceKey("/Type", QPDFObjectHandle::newName("/ExtGState"));
336 egs.replaceKey("/LW", QPDFObjectHandle::newReal(pen_width, 1));
337 egs.replaceKey("/LC", QPDFObjectHandle::newInteger(2));
338 egs.replaceKey("/LJ", QPDFObjectHandle::newInteger(0));
339 egstate = out->pdf->makeIndirectObject(egs);
342 string egs_res = out->new_resource("GS");
343 out->egstates.replaceKey(egs_res, egstate);
344 s += egs_res + " gs ";
357 s += b.to_rect() + " re S ";
360 s += crop_cross(b.x_min, b.y_min, 0b1111);
361 s += crop_cross(b.x_max, b.y_min, 0b1111);
362 s += crop_cross(b.x_max, b.y_max, 0b1111);
363 s += crop_cross(b.x_min, b.y_max, 0b1111);
366 s += crop_cross(b.x_min, b.y_min, 0b0110);
367 s += crop_cross(b.x_max, b.y_min, 0b1010);
368 s += crop_cross(b.x_max, b.y_max, 0b1001);
369 s += crop_cross(b.x_min, b.y_max, 0b0101);
372 s += crop_cross(b.x_min, b.y_min, 0b1001);
373 s += crop_cross(b.x_max, b.y_min, 0b0101);
374 s += crop_cross(b.x_max, b.y_max, 0b0110);
375 s += crop_cross(b.x_min, b.y_max, 0b1010);
383 #define CROPMARK_ARGS(px) \
384 { px "mark", AT_STRING }, \
385 { px "pen", AT_DIMEN }, \
386 { px "len", AT_DIMEN }, \
387 { px "offset",AT_DIMEN }, \
388 { px "color", AT_STRING }
390 // Scaling preserving aspect ratio
392 double scale_to_fit(BBox &from, BBox &to)
394 double fw = from.width(), fh = from.height();
395 double tw = to.width(), th = to.height();
396 if (is_zero(fw) || is_zero(fh) || is_zero(tw) || is_zero(th))
399 return min(tw/fw, th/fh);
404 class move_cmd : public cmd_exec_simple {
409 x = c->arg("x")->as_double(0);
410 y = c->arg("y")->as_double(0);
412 page *process_page(page *p) override
416 return new xform_page(p, m);
420 static const arg_def move_args[] = {
421 { "x", AT_DIMEN | AT_MANDATORY | AT_POSITIONAL },
422 { "y", AT_DIMEN | AT_MANDATORY | AT_POSITIONAL },
428 class scale_cmd : public cmd_exec_simple {
429 double x_factor, y_factor;
433 x_factor = c->arg("x")->as_double(1);
434 y_factor = c->arg("y")->as_double(x_factor);
436 page *process_page(page *p) override
439 m.scale(x_factor, y_factor);
440 return new xform_page(p, m);
444 static const arg_def scale_args[] = {
445 { "x", AT_DOUBLE | AT_MANDATORY | AT_POSITIONAL },
446 { "y", AT_DOUBLE | AT_POSITIONAL },
452 class rotate_cmd : public cmd_exec_simple {
457 deg = c->arg("deg")->as_int(0) % 360;
461 die("Rotate requires a multiple of 90 degrees");
463 page *process_page(page *p) override
472 m.shift(0, p->width);
476 m.shift(p->width, p->height);
480 m.shift(p->height, 0);
485 return new xform_page(p, m);
489 static const arg_def rotate_args[] = {
490 { "angle", AT_INT | AT_MANDATORY | AT_POSITIONAL },
496 class flip_cmd : public cmd_exec_simple {
502 horizontal = c->arg("h")->as_int(0);
503 vertical = c->arg("v")->as_int(0);
504 if (!horizontal && !vertical)
505 die("Flip has no direction specified");
507 page *process_page(page *p) override
513 m.shift(0, p->height);
518 m.shift(p->width, 0);
520 return new xform_page(p, m);
524 static const arg_def flip_args[] = {
532 class select_cmd : public cmd_exec {
539 vector<page *> process(vector<page *> &pages) override;
542 static int validate_page_index(vector<page *> &pages, int idx)
544 if (idx >= 1 && idx <= (int) pages.size())
546 if (idx <= -1 && idx >= (int) -pages.size())
547 return idx + pages.size();
548 die("Page index %d out of range", idx);
551 vector<page *> select_cmd::process(vector<page *> &pages)
554 for (auto pb: pipe->branches)
556 vector<page *> selected;
557 for (auto ps: pb->selectors)
559 int f = validate_page_index(pages, ps.from);
560 int t = validate_page_index(pages, ps.to);
561 int step = (f <= t) ? 1 : -1;
562 for (int i=f; f<=t; f += step)
563 selected.push_back(pages[i]);
565 auto processed = run_command_list(pb->commands, selected);
566 for (auto p: processed)
574 class apply_cmd : public cmd_exec {
581 vector<page *> process(vector<page *> &pages) override;
584 static pipeline_branch *find_branch(pipeline *pipe, vector <page *> &pages, int idx)
586 for (auto pb: pipe->branches)
587 for (auto ps: pb->selectors)
589 int f = validate_page_index(pages, ps.from);
590 int t = validate_page_index(pages, ps.to);
591 if (f <= idx && idx <= t || t <= idx && idx <= f)
597 vector<page *> apply_cmd::process(vector<page *> &pages)
604 pipeline_branch *pb = find_branch(pipe, pages, cnt);
609 auto processed = run_command_list(pb->commands, tmp);
610 for (auto q: processed)
623 class modulo_cmd : public cmd_exec {
630 n = c->arg("n")->as_int(0);
632 die("Modulo must have n > 0");
633 half = c->arg("half")->as_int(0);
636 vector<page *> process(vector<page *> &pages) override;
639 vector<page *> modulo_cmd::process(vector<page *> &pages)
642 int tuples = ((int) pages.size() + n - 1) / n;
643 int use_tuples = half ? tuples/2 : tuples;
645 for (int tuple=0; tuple < use_tuples; tuple++)
647 debug("# Tuple %d", tuple);
649 for (auto pb: pipe->branches)
652 for (auto ps: pb->selectors)
656 int step = (f <= t) ? 1 : -1;
657 for (int i=f; i<=t; i += step)
662 else if (i < 0 && i >= -n)
663 j = (tuples-1-tuple)*n + (-i) - 1;
665 die("Modulo: invalid index %d", i);
666 if (j < (int) pages.size())
667 tmp.push_back(pages[j]);
670 page *ref_page = pages[tuple*n];
671 tmp.push_back(new empty_page(ref_page->width, ref_page->height));
675 auto processed = run_command_list(pb->commands, tmp);
676 for (auto q: processed)
685 static const arg_def modulo_args[] = {
686 { "n", AT_INT | AT_MANDATORY | AT_POSITIONAL },
687 { "half", AT_SWITCH },
693 class draw_bbox_page : public page {
696 void render(out_context *out, pdf_matrix xform) override;
697 draw_bbox_page(page *p) : page(p) { orig_page = p; }
700 class draw_bbox_cmd : public cmd_exec_simple {
702 draw_bbox_cmd(cmd *c UNUSED) { }
703 page *process_page(page *p) override
705 return new draw_bbox_page(p);
709 void draw_bbox_page::render(out_context *out, pdf_matrix xform)
711 orig_page->render(out, xform);
714 xform.to_string() + " cm " +
716 image_box.to_rect() + " re S " +
722 class merge_cmd : public cmd_exec {
724 merge_cmd(cmd *c UNUSED) { }
725 vector<page *> process(vector<page *> &pages) override;
728 class merge_page : public page {
729 vector<page *> orig_pages;
731 merge_page(vector<page *> &orig) : page(0, 0)
741 image_box = p->image_box;
746 if (!is_equal(width, p->width) || !is_equal(height, p->height))
747 die("All pages participating in a merge must have the same dimensions");
748 image_box.join(p->image_box);
752 void render(out_context *out, pdf_matrix xform) override
754 for (auto p: orig_pages)
755 p->render(out, xform);
759 vector<page *> merge_cmd::process(vector<page *> &pages)
763 out.push_back(new merge_page(pages));
769 class paper_cmd : public cmd_exec_simple {
773 paper_cmd(cmd *c) : paper(c), pos(c) { }
774 page *process_page(page *p) override
776 BBox paper_box = BBox(paper.w, paper.h);
777 pdf_matrix xf = pos.place(p->image_box, paper_box);
778 page *q = new xform_page(p, xf);
785 static const arg_def paper_args[] = {
793 class scaleto_cmd : public cmd_exec_simple {
797 scaleto_cmd(cmd *c) : paper(c), pos(c) { }
798 page *process_page(page *p) override
800 BBox orig_box = BBox(p->width, p->height);
801 BBox paper_box = BBox(paper.w, paper.h);
803 xf.scale(scale_to_fit(orig_box, paper_box));
804 orig_box.transform(xf);
805 xf.concat(pos.place(orig_box, paper_box));
806 page *q = new xform_page(p, xf);
813 static const arg_def scaleto_args[] = {
821 class fit_cmd : public cmd_exec_simple {
826 fit_cmd(cmd *c) : paper(c, true), pos(c), marg(c, "margin", "margin") { }
827 page *process_page(page *p) override
832 if (!is_zero(paper.w) && !is_zero(paper.h))
834 // Paper given: scale image to fit paper
835 BBox orig_box = p->image_box;
836 BBox paper_box = BBox(paper.w, paper.h);
837 marg.shrink_box(&paper_box);
838 xf.scale(scale_to_fit(orig_box, paper_box));
839 orig_box.transform(xf);
840 xf.concat(pos.place(orig_box, paper_box));
841 q = new xform_page(p, xf);
847 // No paper given: adjust paper to fit image
848 xf.shift(-p->image_box.x_min, -p->image_box.y_min);
849 xf.shift(marg.l, marg.b);
850 q = new xform_page(p, xf);
851 q->width = p->image_box.width() + marg.l + marg.r;
852 q->height = p->image_box.height() + marg.t + marg.b;
858 static const arg_def fit_args[] = {
861 MARGIN_ARGS1_NAMED("margin"),
862 MARGIN_ARGS2("margin"),
868 class expand_cmd : public cmd_exec_simple {
871 expand_cmd(cmd *c) : marg(c, "by", "") { }
872 page *process_page(page *p) override
875 xf.shift(marg.l, marg.b);
876 page *q = new xform_page(p, xf);
877 q->width = p->width + marg.l + marg.r;
878 q->height = p->height + marg.t + marg.b;
879 if (q->width < 0.001 || q->height < 0.001)
880 die("Expansion must result in positive page dimensions");
885 static const arg_def expand_args[] = {
886 MARGIN_ARGS1_POSNL("by"),
893 class margins_cmd : public cmd_exec_simple {
896 margins_cmd(cmd *c) : marg(c, "size", "") { }
897 page *process_page(page *p) override
900 xf.shift(-p->image_box.x_min, -p->image_box.y_min);
901 xf.shift(marg.l, marg.b);
902 page *q = new xform_page(p, xf);
903 q->width = p->image_box.width() + marg.l + marg.r;
904 q->height = p->image_box.height() + marg.t + marg.b;
905 if (q->width < 0.001 || q->height < 0.001)
906 die("Margins must result in positive page dimensions");
911 static const arg_def margins_args[] = {
912 MARGIN_ARGS1_POSNL("size"),
919 class add_blank_cmd : public cmd_exec {
923 add_blank_cmd(cmd *c) : paper(c, true)
925 n = c->arg("n")->as_int(1);
927 vector<page *> process(vector<page *> &pages) override;
930 vector<page *> add_blank_cmd::process(vector<page *> &pages)
937 for (int i=0; i<n; i++)
939 double w = paper.w, h = paper.h;
940 if (is_zero(w) || is_zero(h))
941 w = p->width, h = p->height;
942 out.push_back(new empty_page(w, h));
949 static const arg_def add_blank_args[] = {
950 { "n", AT_INT | AT_POSITIONAL },
957 class book_cmd : public cmd_exec {
962 n = c->arg("n")->as_int(0);
964 die("Number of pages per signature must be divisible by 4");
966 vector<page *> process(vector<page *> &pages) override;
969 vector<page *> book_cmd::process(vector<page *> &pages)
971 vector<page *> in, out;
974 while (in.size() % 4)
975 in.push_back(new empty_page(in[0]->width, in[0]->height));
978 while (i < (int) in.size())
980 int sig = in.size() - i;
983 for (int j=0; j<sig/2; j+=2)
985 out.push_back(in[i + sig-1-j]);
986 out.push_back(in[i + j]);
987 out.push_back(in[i + j+1]);
988 out.push_back(in[i + sig-2-j]);
996 static const arg_def book_args[] = {
997 { "n", AT_INT | AT_POSITIONAL },
1005 double tile_w, tile_h;
1006 double paper_w, paper_h;
1011 class nup_cmd : public cmd_exec {
1013 int grid_n, grid_m, num_tiles;
1027 double hspace, vspace;
1028 cropmark_spec cmarks;
1031 page *process_single(vector<page *> &in);
1032 void find_config(vector<page *> &in, BBox *page_boxes);
1033 void try_config(nup_state &st);
1035 bool found_solution;
1036 BBox common_page_box;
1039 nup_cmd(cmd *c) : paper(c), marg(c, "margin", "margin"), pos(c), tpos(c->arg("tpos")->as_string("tl")), cmarks(c, "c", "none")
1041 grid_n = c->arg("n")->as_int(0);
1042 grid_m = c->arg("m")->as_int(0);
1043 if (grid_n > 0 && grid_m > 0)
1044 num_tiles = grid_n * grid_m;
1045 else if (grid_n > 0 && !grid_m)
1048 die("Grid size must be at least 1x1");
1050 const string by = c->arg("by")->as_string("rows");
1051 if (by == "rows" || by == "row" || by == "r")
1053 else if (by == "cols" || by == "cols" || by == "c")
1055 else if (by == "tile" || by == "t")
1058 die("Parameter \"by\" must be rows/cols/tile");
1060 crop = c->arg("crop")->as_int(0);
1061 mixed = c->arg("mixed")->as_int(0);
1062 rotate = c->arg("rotate")->as_int(-1);
1063 scale = c->arg("scale")->as_double(0);
1065 double space = c->arg("space")->as_double(0);
1066 hspace = c->arg("hspace")->as_double(space);
1067 vspace = c->arg("vspace")->as_double(space);
1069 if (!is_zero(scale) && (!is_zero(paper.w) || rotate >= 0))
1070 die("When nup is used with explicit scaling, paper size nor rotation may be given");
1071 if (!is_zero(scale) && !grid_m)
1072 die("When nup is used with explicit scaling, both grid sizes must be given");
1075 vector<page *> process(vector<page *> &pages) override;
1078 vector<page *> nup_cmd::process(vector<page *> &pages)
1082 // Unless mixed is given, find the common page size
1085 for (int i=0; i < (int) pages.size(); i++)
1088 BBox pb = crop ? p->image_box : BBox(p->width, p->height);
1090 common_page_box = pb;
1092 common_page_box.join(pb);
1094 debug("NUP: Common page box [%.3f %.3f]-[%.3f %.3f]",
1095 common_page_box.x_min, common_page_box.y_min, common_page_box.x_max, common_page_box.y_max);
1098 // Process one tile set after another
1100 while (i < (int) pages.size())
1103 if (fill_by == BY_TILE)
1105 for (int j=0; j<num_tiles; j++)
1106 in.push_back(pages[i]);
1111 for (int j=0; j<num_tiles; j++)
1113 if (i < (int) pages.size())
1114 in.push_back(pages[i]);
1116 in.push_back(new empty_page(in[0]->width, in[0]->height));
1120 out.push_back(process_single(in));
1126 void nup_cmd::try_config(nup_state &st)
1128 BBox window(st.paper_w, st.paper_h);
1129 if (!marg.may_shrink(&window))
1131 marg.shrink_box(&window);
1132 window.x_max -= (st.cols - 1) * hspace;
1133 window.y_max -= (st.rows - 1) * vspace;
1134 if (window.width() < 0 || window.height() < 0)
1137 BBox image(st.cols * st.tile_w, st.rows * st.tile_h);
1138 st.scale = scale_to_fit(image, window);
1139 st.fill_factor = (st.scale*image.width() * st.scale*image.height()) / (st.paper_w * st.paper_h);
1141 debug("Try: %dx%d on %.3f x %.3f => scale %.3f, fill %.6f",
1143 st.paper_w, st.paper_h,
1144 st.scale, st.fill_factor);
1146 if (!found_solution || best.fill_factor < st.fill_factor)
1148 found_solution = true;
1153 void nup_cmd::find_config(vector<page *> &in, BBox *page_boxes)
1157 // Determine tile size
1158 st.tile_w = st.tile_h = 0;
1159 for (int i=0; i<num_tiles; i++)
1162 page_boxes[i] = common_page_box;
1164 page_boxes[i] = in[i]->image_box;
1166 page_boxes[i] = BBox(in[i]->width, in[i]->height);
1167 st.tile_w = max(st.tile_w, page_boxes[i].width());
1168 st.tile_h = max(st.tile_h, page_boxes[i].height());
1170 debug("NUP: %d tiles of size [%.3f,%.3f]", num_tiles, st.tile_w, st.tile_h);
1173 // Try all possible configurations of tiles
1174 found_solution = false;
1175 if (!is_zero(scale))
1177 // If explicit scaling is requested, we choose page size ourselves,
1178 // so there is just one configuration.
1181 st.paper_w = marg.l + st.cols*st.tile_w + (st.cols-1)*hspace + marg.r;
1182 st.paper_h = marg.t + st.rows*st.tile_h + (st.rows-1)*vspace + marg.b;
1187 // Page size is fixed (either given or copied from the source pages),
1188 // but we can have freedom to rotate and/or to choose grid size.
1189 for (int rot=0; rot<=1; rot++)
1191 if (rotate >= 0 && rot != rotate)
1194 // Establish paper size
1195 if (!is_zero(paper.w))
1197 st.paper_w = paper.w;
1198 st.paper_h = paper.h;
1202 st.paper_w = in[0]->width;
1203 st.paper_h = in[0]->height;
1206 swap(st.paper_w, st.paper_h);
1217 for (int r=1; r<=grid_n; r++)
1221 st.cols = grid_n / r;
1228 if (!found_solution)
1229 die("Nup did not find a feasible solution");
1230 debug("Best: %dx%d on %.3f x %.3f", best.cols, best.rows, best.paper_w, best.paper_h);
1234 class nup_page : public page {
1236 vector<page *> orig_pages;
1237 vector<pdf_matrix> xforms;
1238 vector<BBox> tile_boxes;
1239 cropmark_spec *cmarks;
1240 void render(out_context *out, pdf_matrix xform) override;
1241 nup_page(nup_state &st) : page(st.paper_w, st.paper_h) { }
1244 void nup_page::render(out_context *out, pdf_matrix parent_xform)
1246 for (int i=0; i < (int) orig_pages.size(); i++)
1248 orig_pages[i]->render(out, xforms[i] * parent_xform);
1249 out->contents += cmarks->pdf_stream(out, tile_boxes[i], parent_xform);
1253 page *nup_cmd::process_single(vector<page *> &in)
1255 BBox page_boxes[num_tiles];
1256 find_config(in, page_boxes);
1257 double tw = best.scale * best.tile_w;
1258 double th = best.scale * best.tile_h;
1260 // Construct transform from paper to grid of tiles
1261 BBox paper_box(best.paper_w, best.paper_h);
1262 marg.shrink_box(&paper_box);
1263 BBox grid_box(best.cols * tw + (best.cols-1) * hspace,
1264 best.rows * th + (best.rows-1) * vspace);
1265 pdf_matrix place_xform = pos.place(grid_box, paper_box);
1267 nup_page *p = new nup_page(best);
1268 p->image_box = grid_box;
1269 p->image_box.transform(place_xform);
1271 for (int i=0; i<num_tiles; i++)
1274 if (fill_by == BY_ROWS || fill_by == BY_TILE)
1286 BBox &page_box = page_boxes[i];
1287 m.shift(-page_box.x_min, -page_box.y_min);
1288 m.scale(best.scale);
1289 page_box.transform(m);
1291 double x = c * (tw + hspace);
1292 double y = (best.rows-1-r) * (th + vspace);
1293 BBox tile_box = BBox(x, y, x+tw, y+th);
1294 m.concat(tpos.place(page_box, tile_box));
1296 p->orig_pages.push_back(in[i]);
1297 p->xforms.push_back(m * place_xform);
1298 p->tile_boxes.push_back(tile_box.transformed(place_xform));
1299 p->cmarks = &cmarks;
1305 static const arg_def nup_args[] = {
1306 { "n", AT_INT | AT_POSITIONAL | AT_MANDATORY },
1307 { "m", AT_INT | AT_POSITIONAL },
1308 { "by", AT_STRING },
1309 { "crop", AT_SWITCH },
1310 { "mixed", AT_SWITCH },
1311 { "rotate", AT_SWITCH },
1312 { "scale", AT_DOUBLE },
1314 MARGIN_ARGS1_NAMED("margin"),
1315 MARGIN_ARGS2("margin"),
1318 { "tpos", AT_STRING },
1319 { "space", AT_DIMEN },
1320 { "hspace", AT_DIMEN },
1321 { "vspace", AT_DIMEN },
1327 class cropmarks_page : public page {
1331 void render(out_context *out, pdf_matrix xform) override
1333 orig_page->render(out, xform);
1334 out->contents += cm->pdf_stream(out, image_box, xform);
1336 cropmarks_page(page *p, cropmark_spec *cms) : page(p), orig_page(p), cm(cms) { }
1339 class cropmarks_cmd : public cmd_exec_simple {
1341 page *process_page(page *p) override
1343 return new cropmarks_page(p, &cm);
1347 cropmarks_cmd(cmd *c) : cm(c) { }
1350 static const arg_def cropmarks_args[] = {
1355 /*** Command table ***/
1357 template<typename T> cmd_exec *ctor(cmd *c) { return new T(c); }
1359 const cmd_def cmd_table[] = {
1360 { "null", no_args, 0, &ctor<null_cmd> },
1361 { "move", move_args, 0, &ctor<move_cmd> },
1362 { "scale", scale_args, 0, &ctor<scale_cmd> },
1363 { "rotate", rotate_args, 0, &ctor<rotate_cmd> },
1364 { "flip", flip_args, 0, &ctor<flip_cmd> },
1365 { "select", no_args, 1, &ctor<select_cmd> },
1366 { "apply", no_args, 1, &ctor<apply_cmd> },
1367 { "modulo", modulo_args, 1, &ctor<modulo_cmd> },
1368 { "draw-bbox",no_args, 0, &ctor<draw_bbox_cmd> },
1369 { "merge", no_args, 0, &ctor<merge_cmd> },
1370 { "paper", paper_args, 0, &ctor<paper_cmd> },
1371 { "scaleto", scaleto_args, 0, &ctor<scaleto_cmd> },
1372 { "fit", fit_args, 0, &ctor<fit_cmd> },
1373 { "expand", expand_args, 0, &ctor<expand_cmd> },
1374 { "margins", margins_args, 0, &ctor<margins_cmd> },
1375 { "add-blank",add_blank_args, 0, &ctor<add_blank_cmd> },
1376 { "book", book_args, 0, &ctor<book_cmd> },
1377 { "nup", nup_args, 0, &ctor<nup_cmd> },
1378 { "cropmarks",cropmarks_args, 0, &ctor<cropmarks_cmd> },
1379 { NULL, NULL, 0, NULL }