cmds.cc

   1 #include <cassert>
   2 #include <cstdlib>
   3 #include <cstdio>
   4
   5 #include "jam.h"
   6
   7 /*** null ***/
   8
   9 class null_cmd : public cmd_exec {
  10   vector<page *> process(vector<page *> &pages) { return pages; }
  11 };
  12
  13 static const arg_def no_args[] = {
  14   { NULL,       0 }
  15 };
  16
  17 static cmd_exec *null_ctor(cmd *c UNUSED)
  18 {
  19   return new null_cmd;
  20 }
  21
  22 /*** move ***/
  23
  24 class move_cmd : public cmd_exec {
  25 public:
  26   double x, y;
  27   vector<page *> process(vector<page *> &pages);
  28 };
  29
  30 class xform_page : public page {
  31   page *orig_page;
  32 public:
  33   pdf_matrix xform;
  34   void render(page_out *out, pdf_matrix xform);
  35   xform_page(page *_orig, double _w, double _h) : page(_w, _h), orig_page(_orig) { }
  36 };
  37
  38 void xform_page::render(page_out *out, pdf_matrix parent_xform)
  39 {
  40   orig_page->render(out, xform * parent_xform);
  41 }
  42
  43 vector<page *> move_cmd::process(vector<page *> &pages)
  44 {
  45   vector<page *> out;
  46   for (auto p: pages)
  47     {
  48       xform_page *q = new xform_page(p, p->width, p->height);
  49       q->xform.shift(x, y);
  50       out.push_back(q);
  51     }
  52   return out;
  53 }
  54
  55 static const arg_def move_args[] = {
  56   { "x",        AT_DIMEN | AT_MANDATORY | AT_POSITIONAL },
  57   { "y",        AT_DIMEN | AT_MANDATORY | AT_POSITIONAL },
  58   { NULL,       0 }
  59 };
  60
  61 static cmd_exec *move_ctor(cmd *c)
  62 {
  63   move_cmd *m = new move_cmd;
  64   m->x = c->args.at(0)->as_double(0);
  65   m->y = c->args.at(1)->as_double(0);
  66   return m;
  67 }
  68
  69 /*** scale ***/
  70
  71 class scale_cmd : public cmd_exec {
  72 public:
  73   double x_factor, y_factor;
  74   vector<page *> process(vector<page *> &pages);
  75 };
  76
  77 vector<page *> scale_cmd::process(vector<page *> &pages)
  78 {
  79   vector<page *> out;
  80   for (auto p: pages)
  81     {
  82       xform_page *q = new xform_page(p, x_factor*p->width, y_factor*p->height);
  83       q->xform.scale(x_factor, y_factor);
  84       out.push_back(q);
  85     }
  86   return out;
  87 }
  88
  89 static const arg_def scale_args[] = {
  90   { "x",        AT_DOUBLE | AT_MANDATORY | AT_POSITIONAL },
  91   { "y",        AT_DOUBLE | AT_POSITIONAL },
  92   { NULL,       0 }
  93 };
  94
  95 static cmd_exec *scale_ctor(cmd *c)
  96 {
  97   scale_cmd *s = new scale_cmd;
  98   s->x_factor = c->args.at(0)->as_double(1);
  99   s->y_factor = c->args.at(1)->as_double(s->x_factor);
 100   return s;
 101 }
 102
 103 /*** rotate ***/
 104
 105 class rotate_cmd : public cmd_exec {
 106 public:
 107   int deg;
 108   vector<page *> process(vector<page *> &pages);
 109 };
 110
 111 vector<page *> rotate_cmd::process(vector<page *> &pages)
 112 {
 113   vector<page *> out;
 114   for (auto p: pages)
 115     {
 116       xform_page *q = new xform_page(p, p->width, p->height);
 117       switch (deg)
 118         {
 119         case 0:
 120           break;
 121         case 90:
 122           q->xform.rotate_deg(-90);
 123           q->xform.shift(0, p->width);
 124           swap(q->width, q->height);
 125           break;
 126         case 180:
 127           q->xform.rotate_deg(180);
 128           q->xform.shift(p->width, p->height);
 129           break;
 130         case 270:
 131           q->xform.rotate_deg(90);
 132           q->xform.shift(p->height, 0);
 133           swap(q->width, q->height);
 134           break;
 135         default:
 136           abort();
 137         }
 138       out.push_back(q);
 139     }
 140   return out;
 141 }
 142
 143 static const arg_def rotate_args[] = {
 144   { "angle",    AT_INT | AT_MANDATORY | AT_POSITIONAL },
 145   { NULL,       0 }
 146 };
 147
 148 static cmd_exec *rotate_ctor(cmd *c)
 149 {
 150   rotate_cmd *r = new rotate_cmd;
 151   r->deg = c->args.at(0)->as_int(0) % 360;
 152   if (r->deg < 0)
 153     r->deg += 360;
 154   if (r->deg % 90)
 155     die("Rotate requires a multiple of 90 degrees");
 156   return r;
 157 }
 158
 159 /*** select ***/
 160
 161 class select_cmd : public cmd_exec {
 162 public:
 163   pipeline *pipe;
 164   vector<page *> process(vector<page *> &pages);
 165 };
 166
 167 static int validate_page_index(vector<page *> &pages, int idx)
 168 {
 169   if (idx >= 1 && idx <= (int) pages.size())
 170     return idx - 1;
 171   if (idx <= -1 && idx >= (int) -pages.size())
 172     return idx + pages.size();
 173   die("Page index %d out of range", idx);
 174 }
 175
 176 vector<page *> select_cmd::process(vector<page *> &pages)
 177 {
 178   vector<page *> out;
 179   for (auto pb: pipe->branches)
 180     {
 181       vector<page *> selected;
 182       for (auto ps: pb->selectors)
 183         {
 184           int f = validate_page_index(pages, ps.from);
 185           int t = validate_page_index(pages, ps.to);
 186           int step = (f <= t) ? 1 : -1;
 187           for (int i=f; f<=t; f += step)
 188             selected.push_back(pages[i]);
 189         }
 190       auto processed = run_command_list(pb->commands, selected);
 191       for (auto p: processed)
 192         out.push_back(p);
 193     }
 194   return out;
 195 }
 196
 197 static cmd_exec *select_ctor(cmd *c)
 198 {
 199   select_cmd *r = new select_cmd;
 200   r->pipe = c->pipe;
 201   return r;
 202 }
 203
 204 /*** apply ***/
 205
 206 class apply_cmd : public cmd_exec {
 207 public:
 208   pipeline *pipe;
 209   vector<page *> process(vector<page *> &pages);
 210 };
 211
 212 static pipeline_branch *find_branch(pipeline *pipe, vector <page *> &pages, int idx)
 213 {
 214   for (auto pb: pipe->branches)
 215     for (auto ps: pb->selectors)
 216       {
 217         int f = validate_page_index(pages, ps.from);
 218         int t = validate_page_index(pages, ps.to);
 219         if (f <= idx && idx <= t || t <= idx && idx <= f)
 220           return pb;
 221       }
 222   return NULL;
 223 }
 224
 225 vector<page *> apply_cmd::process(vector<page *> &pages)
 226 {
 227   vector<page *> out;
 228
 229   int cnt = 0;
 230   for (auto p: pages)
 231     {
 232       pipeline_branch *pb = find_branch(pipe, pages, cnt);
 233       if (pb)
 234         {
 235           vector<page *> tmp;
 236           tmp.push_back(p);
 237           auto processed = run_command_list(pb->commands, tmp);
 238           for (auto q: processed)
 239             out.push_back(q);
 240         }
 241       else
 242         out.push_back(p);
 243       cnt++;
 244     }
 245
 246   return out;
 247 }
 248
 249 static cmd_exec *apply_ctor(cmd *c)
 250 {
 251   apply_cmd *r = new apply_cmd;
 252   r->pipe = c->pipe;
 253   return r;
 254 }
 255
 256 /*** modulo ***/
 257
 258 class modulo_cmd : public cmd_exec {
 259 public:
 260   pipeline *pipe;
 261   int n;
 262   vector<page *> process(vector<page *> &pages);
 263 };
 264
 265 vector<page *> modulo_cmd::process(vector<page *> &pages)
 266 {
 267   vector<page *> out;
 268   int tuples = ((int) pages.size() + n - 1) / n;
 269
 270   for (int tuple=0; tuple < tuples; tuple++)
 271     {
 272       debug("# Tuple %d", tuple);
 273       debug_indent += 4;
 274       for (auto pb: pipe->branches)
 275         {
 276           vector<page *> tmp;
 277           for (auto ps: pb->selectors)
 278             {
 279               int f = ps.from;
 280               int t = ps.to;
 281               int step = (f <= t) ? 1 : -1;
 282               for (int i=f; i<=t; i += step)
 283                 {
 284                   int j;
 285                   if (i > 0 && i <= n)
 286                     j = tuple*n + i - 1;
 287                   else if (i < 0 && i >= -n)
 288                     j = (tuples-1-tuple)*n + (-i) - 1;
 289                   else
 290                     die("Modulo: invalid index %d", i);
 291                   if (j < (int) pages.size())
 292                     tmp.push_back(pages[j]);
 293                   else
 294                     {
 295                       page *ref_page = pages[tuple*n];
 296                       tmp.push_back(new empty_page(ref_page->width, ref_page->height));
 297                     }
 298                 }
 299             }
 300           auto processed = run_command_list(pb->commands, tmp);
 301           for (auto q: processed)
 302             out.push_back(q);
 303         }
 304       debug_indent -= 4;
 305     }
 306
 307   return out;
 308 }
 309
 310 static const arg_def modulo_args[] = {
 311   { "n",        AT_INT | AT_MANDATORY | AT_POSITIONAL },
 312   { NULL,       0 }
 313 };
 314
 315 static cmd_exec *modulo_ctor(cmd *c)
 316 {
 317   modulo_cmd *m = new modulo_cmd;
 318   m->n = c->args.at(0)->as_int(0);
 319   if (m->n <= 0)
 320     die("Modulo must have n > 0");
 321   m->pipe = c->pipe;
 322   return m;
 323 }
 324
 325 /*** Command table ***/
 326
 327 const cmd_def cmd_table[] = {
 328   { "null",     no_args,        0,      null_ctor       },
 329   { "move",     move_args,      0,      move_ctor       },
 330   { "scale",    scale_args,     0,      scale_ctor      },
 331   { "rotate",   rotate_args,    0,      rotate_ctor     },
 332   { "select",   no_args,        1,      select_ctor     },
 333   { "apply",    no_args,        1,      apply_ctor      },
 334   { "modulo",   modulo_args,    1,      modulo_ctor     },
 335   { NULL,       NULL,           0,      NULL    }
 336 };