contrib/groff/src/preproc/pic/troff.cc

   1 // -*- C++ -*-
   2 /* Copyright (C) 1989, 1990, 1991, 1992, 2000, 2001, 2002
   3    Free Software Foundation, Inc.
   4      Written by James Clark (jjc@jclark.com)
   5
   6 This file is part of groff.
   7
   8 groff is free software; you can redistribute it and/or modify it under
   9 the terms of the GNU General Public License as published by the Free
  10 Software Foundation; either version 2, or (at your option) any later
  11 version.
  12
  13 groff is distributed in the hope that it will be useful, but WITHOUT ANY
  14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  15 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  16 for more details.
  17
  18 You should have received a copy of the GNU General Public License along
  19 with groff; see the file COPYING.  If not, write to the Free Software
  20 Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
  21
  22 #include "pic.h"
  23 #include "common.h"
  24
  25
  26 const double RELATIVE_THICKNESS = -1.0;
  27 const double BAD_THICKNESS = -2.0;
  28
  29 class simple_output : public common_output {
  30   virtual void simple_line(const position &, const position &) = 0;
  31   virtual void simple_spline(const position &, const position *, int n) = 0;
  32   virtual void simple_arc(const position &, const position &,
  33                           const position &) = 0;
  34   virtual void simple_circle(int, const position &, double rad) = 0;
  35   virtual void simple_ellipse(int, const position &, const distance &) = 0;
  36   virtual void simple_polygon(int, const position *, int) = 0;
  37   virtual void line_thickness(double) = 0;
  38   virtual void set_fill(double) = 0;
  39   virtual void set_color(char *, char *) = 0;
  40   virtual void reset_color() = 0;
  41   virtual char *get_last_filled() = 0;
  42   void dot(const position &, const line_type &) = 0;
  43 public:
  44   void start_picture(double sc, const position &ll, const position &ur) = 0;
  45   void finish_picture() = 0;
  46   void text(const position &, text_piece *, int, double) = 0;
  47   void line(const position &, const position *, int n,
  48             const line_type &);
  49   void polygon(const position *, int n,
  50                const line_type &, double);
  51   void spline(const position &, const position *, int n,
  52               const line_type &);
  53   void arc(const position &, const position &, const position &,
  54            const line_type &);
  55   void circle(const position &, double rad, const line_type &, double);
  56   void ellipse(const position &, const distance &, const line_type &, double);
  57   int supports_filled_polygons();
  58 };
  59
  60 int simple_output::supports_filled_polygons()
  61 {
  62   return driver_extension_flag != 0;
  63 }
  64
  65 void simple_output::arc(const position &start, const position &cent,
  66                         const position &end, const line_type &lt)
  67 {
  68   switch (lt.type) {
  69   case line_type::solid:
  70     line_thickness(lt.thickness);
  71     simple_arc(start, cent, end);
  72     break;
  73   case line_type::invisible:
  74     break;
  75   case line_type::dashed:
  76     dashed_arc(start, cent, end, lt);
  77     break;
  78   case line_type::dotted:
  79     dotted_arc(start, cent, end, lt);
  80     break;
  81   }
  82 }
  83
  84 void simple_output::line(const position &start, const position *v, int n,
  85                          const line_type &lt)
  86 {
  87   position pos = start;
  88   line_thickness(lt.thickness);
  89   for (int i = 0; i < n; i++) {
  90     switch (lt.type) {
  91     case line_type::solid:
  92       simple_line(pos, v[i]);
  93       break;
  94     case line_type::dotted:
  95       {
  96         distance vec(v[i] - pos);
  97         double dist = hypot(vec);
  98         int ndots = int(dist/lt.dash_width + .5);
  99         if (ndots == 0)
 100           dot(pos, lt);
 101         else {
 102           vec /= double(ndots);
 103           for (int j = 0; j <= ndots; j++)
 104             dot(pos + vec*j, lt);
 105         }
 106       }
 107       break;
 108     case line_type::dashed:
 109       {
 110         distance vec(v[i] - pos);
 111         double dist = hypot(vec);
 112         if (dist <= lt.dash_width*2.0)
 113           simple_line(pos, v[i]);
 114         else {
 115           int ndashes = int((dist - lt.dash_width)/(lt.dash_width*2.0) + .5);
 116           distance dash_vec = vec*(lt.dash_width/dist);
 117           double dash_gap = (dist - lt.dash_width)/ndashes;
 118           distance dash_gap_vec = vec*(dash_gap/dist);
 119           for (int j = 0; j <= ndashes; j++) {
 120             position s(pos + dash_gap_vec*j);
 121             simple_line(s, s + dash_vec);
 122           }
 123         }
 124       }
 125       break;
 126     case line_type::invisible:
 127       break;
 128     default:
 129       assert(0);
 130     }
 131     pos = v[i];
 132   }
 133 }
 134
 135 void simple_output::spline(const position &start, const position *v, int n,
 136                            const line_type &lt)
 137 {
 138   line_thickness(lt.thickness);
 139   simple_spline(start, v, n);
 140 }
 141
 142 void simple_output::polygon(const position *v, int n,
 143                             const line_type &lt, double fill)
 144 {
 145   if (driver_extension_flag && ((fill >= 0.0) || (get_last_filled() != 0))) {
 146     if (get_last_filled() == 0)
 147       set_fill(fill);
 148     simple_polygon(1, v, n);
 149   }
 150   if (lt.type == line_type::solid && driver_extension_flag) {
 151     line_thickness(lt.thickness);
 152     simple_polygon(0, v, n);
 153   }
 154   else if (lt.type != line_type::invisible) {
 155     line_thickness(lt.thickness);
 156     line(v[n - 1], v, n, lt);
 157   }
 158 }
 159
 160 void simple_output::circle(const position &cent, double rad,
 161                            const line_type &lt, double fill)
 162 {
 163   if (driver_extension_flag && ((fill >= 0.0) || (get_last_filled() != 0))) {
 164     if (get_last_filled() == 0)
 165       set_fill(fill);
 166     simple_circle(1, cent, rad);
 167   }
 168   line_thickness(lt.thickness);
 169   switch (lt.type) {
 170   case line_type::invisible:
 171     break;
 172   case line_type::dashed:
 173     dashed_circle(cent, rad, lt);
 174     break;
 175   case line_type::dotted:
 176     dotted_circle(cent, rad, lt);
 177     break;
 178   case line_type::solid:
 179     simple_circle(0, cent, rad);
 180     break;
 181   default:
 182     assert(0);
 183   }
 184 }
 185
 186 void simple_output::ellipse(const position &cent, const distance &dim,
 187                             const line_type &lt, double fill)
 188 {
 189   if (driver_extension_flag && ((fill >= 0.0) || (get_last_filled() != 0))) {
 190     if (get_last_filled() == 0)
 191       set_fill(fill);
 192     simple_ellipse(1, cent, dim);
 193   }
 194   if (lt.type != line_type::invisible)
 195     line_thickness(lt.thickness);
 196   switch (lt.type) {
 197   case line_type::invisible:
 198     break;
 199   case line_type::dotted:
 200   case line_type::dashed:
 201   case line_type::solid:
 202     simple_ellipse(0, cent, dim);
 203     break;
 204   default:
 205     assert(0);
 206   }
 207 }
 208
 209 #define FILL_MAX 1000
 210
 211 class troff_output : public simple_output {
 212   const char *last_filename;
 213   position upper_left;
 214   double height;
 215   double scale;
 216   double last_line_thickness;
 217   double last_fill;
 218   char *last_filled;            // color
 219   char *last_outlined;          // color
 220 public:
 221   troff_output();
 222   ~troff_output();
 223   void start_picture(double, const position &ll, const position &ur);
 224   void finish_picture();
 225   void text(const position &, text_piece *, int, double);
 226   void dot(const position &, const line_type &);
 227   void command(const char *, const char *, int);
 228   void set_location(const char *, int);
 229   void simple_line(const position &, const position &);
 230   void simple_spline(const position &, const position *, int n);
 231   void simple_arc(const position &, const position &, const position &);
 232   void simple_circle(int, const position &, double rad);
 233   void simple_ellipse(int, const position &, const distance &);
 234   void simple_polygon(int, const position *, int);
 235   void line_thickness(double p);
 236   void set_fill(double);
 237   void set_color(char *, char *);
 238   void reset_color();
 239   char *get_last_filled();
 240   char *get_outline_color();
 241   position transform(const position &);
 242 };
 243
 244 output *make_troff_output()
 245 {
 246   return new troff_output;
 247 }
 248
 249 troff_output::troff_output()
 250 : last_filename(0), last_line_thickness(BAD_THICKNESS),
 251   last_fill(-1.0), last_filled(0), last_outlined(0)
 252 {
 253 }
 254
 255 troff_output::~troff_output()
 256 {
 257 }
 258
 259 inline position troff_output::transform(const position &pos)
 260 {
 261   return position((pos.x - upper_left.x)/scale,
 262                   (upper_left.y - pos.y)/scale);
 263 }
 264
 265 #define FILL_REG "00"
 266
 267 // If this register > 0, then pic will generate \X'ps: ...' commands
 268 // if the aligned attribute is used.
 269 #define GROPS_REG "0p"
 270
 271 // If this register is defined, geqn won't produce `\x's.
 272 #define EQN_NO_EXTRA_SPACE_REG "0x"
 273
 274 void troff_output::start_picture(double sc,
 275                                  const position &ll, const position &ur)
 276 {
 277   upper_left.x = ll.x;
 278   upper_left.y = ur.y;
 279   scale = compute_scale(sc, ll, ur);
 280   height = (ur.y - ll.y)/scale;
 281   double width = (ur.x - ll.x)/scale;
 282   printf(".PS %.3fi %.3fi", height, width);
 283   if (args)
 284     printf(" %s\n", args);
 285   else
 286     putchar('\n');
 287   printf(".\\\" %g %g %g %g\n", ll.x, ll.y, ur.x, ur.y);
 288   printf(".\\\" %.3fi %.3fi %.3fi %.3fi\n", 0.0, height, width, 0.0);
 289   printf(".nr " FILL_REG " \\n(.u\n.nf\n");
 290   printf(".nr " EQN_NO_EXTRA_SPACE_REG " 1\n");
 291   // This guarantees that if the picture is used in a diversion it will
 292   // have the right width.
 293   printf("\\h'%.3fi'\n.sp -1\n", width);
 294 }
 295
 296 void troff_output::finish_picture()
 297 {
 298   line_thickness(BAD_THICKNESS);
 299   last_fill = -1.0;             // force it to be reset for each picture
 300   reset_color();
 301   if (!flyback_flag)
 302     printf(".sp %.3fi+1\n", height);
 303   printf(".if \\n(" FILL_REG " .fi\n");
 304   printf(".br\n");
 305   printf(".nr " EQN_NO_EXTRA_SPACE_REG " 0\n");
 306   // this is a little gross
 307   set_location(current_filename, current_lineno);
 308   fputs(flyback_flag ? ".PF\n" : ".PE\n", stdout);
 309 }
 310
 311 void troff_output::command(const char *s,
 312                            const char *filename, int lineno)
 313 {
 314   if (filename != 0)
 315     set_location(filename, lineno);
 316   fputs(s, stdout);
 317   putchar('\n');
 318 }
 319
 320 void troff_output::simple_circle(int filled, const position &cent, double rad)
 321 {
 322   position c = transform(cent);
 323   printf("\\h'%.3fi'"
 324          "\\v'%.3fi'"
 325          "\\D'%c%.3fi'"
 326          "\n.sp -1\n",
 327          c.x - rad/scale,
 328          c.y,
 329          (filled ? 'C' : 'c'),
 330          rad*2.0/scale);
 331 }
 332
 333 void troff_output::simple_ellipse(int filled, const position &cent,
 334                                   const distance &dim)
 335 {
 336   position c = transform(cent);
 337   printf("\\h'%.3fi'"
 338          "\\v'%.3fi'"
 339          "\\D'%c%.3fi %.3fi'"
 340          "\n.sp -1\n",
 341          c.x - dim.x/(2.0*scale),
 342          c.y,
 343          (filled ? 'E' : 'e'),
 344          dim.x/scale, dim.y/scale);
 345 }
 346
 347 void troff_output::simple_arc(const position &start, const distance &cent,
 348                               const distance &end)
 349 {
 350   position s = transform(start);
 351   position c = transform(cent);
 352   distance cv = c - s;
 353   distance ev = transform(end) - c;
 354   printf("\\h'%.3fi'"
 355          "\\v'%.3fi'"
 356          "\\D'a%.3fi %.3fi %.3fi %.3fi'"
 357          "\n.sp -1\n",
 358          s.x, s.y, cv.x, cv.y, ev.x, ev.y);
 359 }
 360
 361 void troff_output::simple_line(const position &start, const position &end)
 362 {
 363   position s = transform(start);
 364   distance ev = transform(end) - s;
 365   printf("\\h'%.3fi'"
 366          "\\v'%.3fi'"
 367          "\\D'l%.3fi %.3fi'"
 368          "\n.sp -1\n",
 369          s.x, s.y, ev.x, ev.y);
 370 }
 371
 372 void troff_output::simple_spline(const position &start,
 373                                  const position *v, int n)
 374 {
 375   position pos = transform(start);
 376   printf("\\h'%.3fi'"
 377          "\\v'%.3fi'",
 378          pos.x, pos.y);
 379   fputs("\\D'~", stdout);
 380   for (int i = 0; i < n; i++) {
 381     position temp = transform(v[i]);
 382     distance d = temp - pos;
 383     pos = temp;
 384     if (i != 0)
 385       putchar(' ');
 386     printf("%.3fi %.3fi", d.x, d.y);
 387   }
 388   printf("'\n.sp -1\n");
 389 }
 390
 391 // a solid polygon
 392
 393 void troff_output::simple_polygon(int filled, const position *v, int n)
 394 {
 395   position pos = transform(v[0]);
 396   printf("\\h'%.3fi'"
 397          "\\v'%.3fi'",
 398          pos.x, pos.y);
 399   printf("\\D'%c", (filled ? 'P' : 'p'));
 400   for (int i = 1; i < n; i++) {
 401     position temp = transform(v[i]);
 402     distance d = temp - pos;
 403     pos = temp;
 404     if (i != 1)
 405       putchar(' ');
 406     printf("%.3fi %.3fi", d.x, d.y);
 407   }
 408   printf("'\n.sp -1\n");
 409 }
 410
 411 const double TEXT_AXIS = 0.22;  // in ems
 412
 413 static const char *choose_delimiter(const char *text)
 414 {
 415   if (strchr(text, '\'') == 0)
 416     return "'";
 417   else
 418     return "\\(ts";
 419 }
 420
 421 void troff_output::text(const position &center, text_piece *v, int n,
 422                         double ang)
 423 {
 424   line_thickness(BAD_THICKNESS); // the text might use lines (eg in equations)
 425   int rotate_flag = 0;
 426   if (driver_extension_flag && ang != 0.0) {
 427     rotate_flag = 1;
 428     position c = transform(center);
 429     printf(".if \\n(" GROPS_REG " \\{\\\n"
 430            "\\h'%.3fi'"
 431            "\\v'%.3fi'"
 432            "\\X'ps: exec gsave currentpoint 2 copy translate %.4f rotate neg exch neg exch translate'"
 433            "\n.sp -1\n"
 434            ".\\}\n",
 435            c.x, c.y, -ang*180.0/M_PI);
 436   }
 437   for (int i = 0; i < n; i++)
 438     if (v[i].text != 0 && *v[i].text != '\0') {
 439       position c = transform(center);
 440       if (v[i].filename != 0)
 441         set_location(v[i].filename, v[i].lineno);
 442       printf("\\h'%.3fi", c.x);
 443       const char *delim = choose_delimiter(v[i].text);
 444       if (v[i].adj.h == RIGHT_ADJUST)
 445         printf("-\\w%s%s%su", delim, v[i].text, delim);
 446       else if (v[i].adj.h != LEFT_ADJUST)
 447         printf("-(\\w%s%s%su/2u)", delim, v[i].text, delim);
 448       putchar('\'');
 449       printf("\\v'%.3fi-(%dv/2u)+%dv+%.2fm",
 450              c.y,
 451              n - 1,
 452              i,
 453              TEXT_AXIS);
 454       if (v[i].adj.v == ABOVE_ADJUST)
 455         printf("-.5v");
 456       else if (v[i].adj.v == BELOW_ADJUST)
 457         printf("+.5v");
 458       putchar('\'');
 459       fputs(v[i].text, stdout);
 460       fputs("\n.sp -1\n", stdout);
 461     }
 462   if (rotate_flag)
 463     printf(".if '\\*(.T'ps' \\{\\\n"
 464            "\\X'ps: exec grestore'\n.sp -1\n"
 465            ".\\}\n");
 466 }
 467
 468 void troff_output::line_thickness(double p)
 469 {
 470   if (p < 0.0)
 471     p = RELATIVE_THICKNESS;
 472   if (driver_extension_flag && p != last_line_thickness) {
 473     printf("\\D't %.3fp'\\h'%.3fp'\n.sp -1\n", p, -p);
 474     last_line_thickness = p;
 475   }
 476 }
 477
 478 void troff_output::set_fill(double f)
 479 {
 480   if (driver_extension_flag && f != last_fill) {
 481     printf("\\D'f %du'\\h'%du'\n.sp -1\n", int(f*FILL_MAX), -int(f*FILL_MAX));
 482     last_fill = f;
 483   }
 484   if (last_filled) {
 485     free(last_filled);
 486     last_filled = 0;
 487     printf("\\M[]\n.sp -1\n");
 488   }
 489 }
 490
 491 void troff_output::set_color(char *color_fill, char *color_outlined)
 492 {
 493   if (driver_extension_flag) {
 494     if (last_filled || last_outlined) {
 495       reset_color();
 496     }
 497     if (color_fill) {
 498       printf("\\M[%s]\n.sp -1\n", color_fill);
 499       last_filled = strdup(color_fill);
 500     }
 501     if (color_outlined) {
 502       printf("\\m[%s]\n.sp -1\n", color_outlined);
 503       last_outlined = strdup(color_outlined);
 504     }
 505   }
 506 }
 507
 508 void troff_output::reset_color()
 509 {
 510   if (driver_extension_flag) {
 511     if (last_filled) {
 512       printf("\\M[]\n.sp -1\n");
 513       free(last_filled);
 514       last_filled = 0;
 515     }
 516     if (last_outlined) {
 517       printf("\\m[]\n.sp -1\n");
 518       free(last_outlined);
 519       last_outlined = 0;
 520     }
 521   }
 522 }
 523
 524 char *troff_output::get_last_filled()
 525 {
 526   return last_filled;
 527 }
 528
 529 char *troff_output::get_outline_color()
 530 {
 531   return last_outlined;
 532 }
 533
 534 const double DOT_AXIS = .044;
 535
 536 void troff_output::dot(const position &cent, const line_type &lt)
 537 {
 538   if (driver_extension_flag) {
 539     line_thickness(lt.thickness);
 540     simple_line(cent, cent);
 541   }
 542   else {
 543     position c = transform(cent);
 544     printf("\\h'%.3fi-(\\w'.'u/2u)'"
 545            "\\v'%.3fi+%.2fm'"
 546            ".\n.sp -1\n",
 547            c.x,
 548            c.y,
 549            DOT_AXIS);
 550   }
 551 }
 552
 553 void troff_output::set_location(const char *s, int n)
 554 {
 555   if (last_filename != 0 && strcmp(s, last_filename) == 0)
 556     printf(".lf %d\n", n);
 557   else {
 558     printf(".lf %d %s\n", n, s);
 559     last_filename = s;
 560   }
 561 }