home *** CD-ROM | disk | FTP | other *** search
/ Source Code 1994 March / Source_Code_CD-ROM_Walnut_Creek_March_1994.iso / compsrcs / x / volume17 / xdvi / patch14 < prev    next >
Encoding:
Text File  |  1992-06-28  |  56.7 KB  |  2,021 lines
  1. Newsgroups: comp.sources.x
  2. Path: uunet!darwin.sura.net!mips!msi!dcmartin
  3. From: vojta%math.Berkeley.EDU@ucbvax.Berkeley.EDU (Paul Vojta)
  4. Subject: v17i106: xdvi, Patch14, Part01/01, Patch14, Part01/01
  5. Message-ID: <1992Jun29.160850.9316@msi.com>
  6. Originator: dcmartin@fascet
  7. Sender: dcmartin@msi.com (David C. Martin - Moderator)
  8. Organization: Molecular Simulations, Inc.
  9. References: <csx-17i106-xdvi@uunet.UU.NET>
  10. Date: Mon, 29 Jun 1992 16:08:50 GMT
  11. Approved: dcmartin@msi.com
  12. Lines: 2007
  13.  
  14. Submitted-by: vojta%math.Berkeley.EDU@ucbvax.Berkeley.EDU (Paul Vojta)
  15. Posting-number: Volume 17, Issue 106
  16. Archive-name: xdvi/patch14
  17. Patch-To: xdvi: Volume 17, Issues 23, 24, 25, 40, 41, 27, 53
  18.  
  19. This patch implements some greyscale anti-aliasing patches which have been
  20. requested by many people.  It also fixes the usual round of bugs.
  21.  
  22. Thanks go to Till Brychcy, Scott Allendorf, and many others for work
  23. on the greyscale patches.
  24.  
  25. --Paul Vojta, vojta@math.berkeley.edu
  26.  
  27. -- cut here --
  28. diff -cr xdvi_old/MAKE_VMS.COM xdvi_new/MAKE_VMS.COM
  29. *** xdvi_old/MAKE_VMS.COM    Sat Feb  8 14:07:52 1992
  30. --- xdvi_new/MAKE_VMS.COM    Sun Jun  7 11:30:44 1992
  31. ***************
  32. *** 1,16 ****
  33.   $ DEFINE X11 DECW$INCLUDE 
  34.   $ DEFINE SYS SYS$LIBRARY
  35. ! $ CC /DEFINE = (BMLONG, NOTOOL, USE_PK, USE_GF, USE_PXL) DVI_INIT
  36. ! $ CC /DEFINE = (BMLONG, NOTOOL, USE_PK, USE_GF, USE_PXL) DVI_DRAW
  37. ! $ CC /DEFINE = (BMLONG, NOTOOL, USE_PK, USE_GF, USE_PXL) FONTFMTS
  38. ! $ CC /DEFINE = (BMLONG, NOTOOL, USE_PK, USE_GF, USE_PXL) VF
  39. ! $ CC /DEFINE = (BMLONG, NOTOOL, USE_PK, USE_GF, USE_PXL) UTIL
  40. ! $ CC /DEFINE = (BMLONG, NOTOOL, USE_PK, USE_GF, USE_PXL, -
  41. !      "DEFAULT_FONT_PATH=""TEX_FONTS""", -
  42.        "DEFAULT_VF_PATH=""TEX_FONTS""", -
  43. !      "DEFAULT_FONT_SIZES=""300/328.6/360/432/518.4/622/746.4""") FONT_OPEN
  44. ! $ CC /DEFINE = (BMLONG, NOTOOL, USE_PK, USE_GF, USE_PXL) TPIC
  45. ! $ CC /DEFINE = (BMLONG, NOTOOL, USE_PK, USE_GF, USE_PXL) XDVI
  46. ! $ LINK XDVI, DVI_INIT, DVI_DRAW, FONTFMTS, VF, UTIL, FONT_OPEN, TPIC, -
  47. !      VMS_C.OPT /OPTION
  48.   $ EXIT
  49. --- 1,16 ----
  50.   $ DEFINE X11 DECW$INCLUDE 
  51.   $ DEFINE SYS SYS$LIBRARY
  52. ! $ DEFS = "BMLONG, NOTOOL, USE_PK, USE_GF, USE_PXL, TEXXET, GREY"
  53. ! $ CC /DEFINE = ('DEFS') DVI_INIT.C
  54. ! $ CC /DEFINE = ('DEFS') DVI_DRAW.C
  55. ! $ CC /DEFINE = ('DEFS') FONTFMTS.C
  56. ! $ CC /DEFINE = ('DEFS') VF.C
  57. ! $ CC /DEFINE = ('DEFS') UTIL.C
  58. ! $ CC /DEFINE = ('DEFS', "DEFAULT_FONT_PATH=""TEX_FONTS""", -
  59.        "DEFAULT_VF_PATH=""TEX_FONTS""", -
  60. !      "DEFAULT_FONT_SIZES=""300/328.6/360/432/518.4/622/746.4""") FONT_OPEN.C
  61. ! $ CC /DEFINE = ('DEFS') TPIC.C
  62. ! $ CC /DEFINE = ('DEFS') XDVI.C
  63. ! $ LINK XDVI.OBJ, DVI_INIT.OBJ, DVI_DRAW.OBJ, FONTFMTS.OBJ, VF.OBJ, UTIL.OBJ, -
  64. !      FONT_OPEN.OBJ, TPIC.OBJ, VMS_C.OPT /OPTION
  65.   $ EXIT
  66. diff -cr xdvi_old/README xdvi_new/README
  67. *** xdvi_old/README    Fri Mar 27 21:03:14 1992
  68. --- xdvi_new/README    Mon Jun  1 16:25:55 1992
  69. ***************
  70. *** 79,84 ****
  71. --- 79,86 ----
  72.               definition of drawingWidgetClass.
  73.       TEXXET        (everything)  Enables op-codes 250 and 251 (used for
  74.               right-to-left languages).
  75. +     GREY        (everything)  Use greyscale anti-aliasing for
  76. +             displaying shrunken bitmaps.
  77.   
  78.   All flags should be set in the appropriate Makefile via the variable ``DEFS''.
  79.   
  80. ***************
  81. *** 244,248 ****
  82. --- 246,252 ----
  83.      30.    X11R5 support, and numerous bug fixes.
  84.   --  Patchlevel 13: --
  85.      31.  Added support for TeXXeT.
  86. + --  Patchlevel 14: --
  87. +    32.  Added support for greyscale anti-aliasing.
  88.   
  89.   Paul Vojta, vojta@math.berkeley.edu
  90. diff -cr xdvi_old/README.VMS xdvi_new/README.VMS
  91. *** xdvi_old/README.VMS    Mon Feb  4 13:08:20 1991
  92. --- xdvi_new/README.VMS    Sun Jun  7 22:47:16 1992
  93. ***************
  94. *** 8,15 ****
  95.   
  96.      XDVI [+[page]] [-s shrink] [-density density] [-p pixels] [-l] [-rv]
  97.           [-bw width] [-fg color] [-bg color] [-hl color] [-bd color] [-cr color]
  98. !         [-margins dimen] [-sidemargin dimen] [-topmargin dimen]
  99. !         [-offsets dimen] [-xoffset dimen] [-yoffset dimen] [-keep]
  100.           [-hushspecials] [-hushchars] [-hush] [-paper papertype] [-mgs[n] size]
  101.           [-altfont font] [-thorough] [-copy] [-geometry geometry]
  102.           [-icongeometry geometry] [-iconic] [-display display] dvi_file
  103. --- 8,15 ----
  104.   
  105.      XDVI [+[page]] [-s shrink] [-density density] [-p pixels] [-l] [-rv]
  106.           [-bw width] [-fg color] [-bg color] [-hl color] [-bd color] [-cr color]
  107. !         [-margins dimen] [-sidemargin dimen] [-topmargin dimen] [-version]
  108. !         [-offsets dimen] [-xoffset dimen] [-yoffset dimen] [-keep] [-nogrey]
  109.           [-hushspecials] [-hushchars] [-hush] [-paper papertype] [-mgs[n] size]
  110.           [-altfont font] [-thorough] [-copy] [-geometry geometry]
  111.           [-icongeometry geometry] [-iconic] [-display display] dvi_file
  112. ***************
  113. *** 107,112 ****
  114. --- 107,114 ----
  115.      -topmargin <dimen>    (.topMargin)  Specifies the top and bottom margins (see
  116.                            above).
  117.   
  118. +    -version              Print information on the version of XDVI.
  119. + 
  120.      -offsets <dimen>      (.Offset)  Specifies the size of both the horizontal
  121.                            and vertical offsets of the output on the page.  This
  122.                            should be a decimal number optionally followed by "cm",
  123. ***************
  124. *** 127,132 ****
  125. --- 129,140 ----
  126.                            should not move to the home position when moving to a
  127.                            new page.  See also the `k' keystroke.
  128.   
  129. +    -nogrey               (.grey)  Turns off the use greyscale anti-aliasing
  130. +                          when printing shrunken bitmaps.  In this case, the
  131. +                          logic of the corresponding resource is the reverse;
  132. +                          -nogrey corresponds to grey:off; +nogrey to grey:on.
  133. +                          See also the 'G' keystroke.
  134. + 
  135.      -hushspecials         (.hushSpecials)  Causes XDVI to suppress warnings about
  136.                            \special strings which it cannot process.
  137.   
  138. ***************
  139. *** 258,263 ****
  140. --- 266,275 ----
  141.           will keep the same position when moving between pages.  Also `0k' and
  142.           `1k' clear and set this flag, respectively.  See also the -keep option.
  143.   
  144. +    G   This key toggles the use of greyscale anti-aliasing for displaying
  145. +        shrunken bitmaps.  In addition, the key sequences `0G' and `1G' clear and
  146. +        set this flag, respectively.  See also the -nogrey option.
  147. + 
  148.   MOUSE ACTIONS
  149.   -------------
  150.   
  151. ***************
  152. *** 301,310 ****
  153.   
  154.      For compatibilty with some versions of TeX, you may also use the logical name
  155.      "TEXFONTS" in place of "XDVIFONTS", although in that case the string should
  156. !    not include any "%" specifiers.
  157.   
  158.      The logical name "XDVISIZES" must be set to indicate which sizes of fonts are
  159. !    available.  It should consists of a list of numbers separated by slashes.  If
  160.      the list begins with a slash, the system default sizes are used, as well.
  161.      Sizes are expressed in dots per inch; decimals may be used for "pxl" files:
  162.      for example, a 300 dots per inch file magnified by half a step comes out to
  163. --- 313,337 ----
  164.   
  165.      For compatibilty with some versions of TeX, you may also use the logical name
  166.      "TEXFONTS" in place of "XDVIFONTS", although in that case the string should
  167. !    not include any "%" specifiers.  The reason for recognizing "TEXFONTS" is
  168. !    that certain version of TeX also support the convention regarding an extra
  169. !    slash in the font path; therefore, users who create their own fonts can put
  170. !    both their .TFM and raster files in the same directory and do
  171.   
  172. +         $ DEFINE TEXFONTS "/MFDIR"
  173. + 
  174. +    or
  175. + 
  176. +         $ DEFINE TEXFONTS "MFDIR/"
  177. + 
  178. +    in order to get both TeX and XDVI to search their directory in addition to
  179. +    the system standard directories.  The "XDVIFONTS" logical name overrides the
  180. +    "TEXFONTS" logical name, so that on those sites where "TEXFONTS" must be set
  181. +    explicitly, and therefore this feature is not useful, the "XDVIFONTS" logical
  182. +    name be set to an empty string to cause XDVI to ignore "TEXFONTS".
  183. + 
  184.      The logical name "XDVISIZES" must be set to indicate which sizes of fonts are
  185. !    available.  It should consist of a list of numbers separated by slashes.  If
  186.      the list begins with a slash, the system default sizes are used, as well.
  187.      Sizes are expressed in dots per inch; decimals may be used for "pxl" files:
  188.      for example, a 300 dots per inch file magnified by half a step comes out to
  189. ***************
  190. *** 312,317 ****
  191. --- 339,350 ----
  192.      default set of sizes is 300/328.6/360/432/518.4/622/746.4.  XDVI will also
  193.      try the actual size of the font before trying any of the given sizes.
  194.   
  195. +    Virtual fonts are also supported, although XDVI does not have any built-in
  196. +    fonts to which they can refer.  The search path for .VF files can be
  197. +    specified with the "XDVIVFS" logical name in a similar manner to that for the
  198. +    "XDVIFONTS" logical name.  Virtual fonts are searched for immediately after
  199. +    looking for the font as a normal font in the exact size specified.
  200. + 
  201.   FILES
  202.   -----
  203.   
  204. ***************
  205. *** 362,371 ****
  206.            $ LIBRARY /INSERT HELPLIB.HLB XDVI.HLP
  207.   
  208.      4) Modify the command file you use to set up the TEX commands so that it
  209. !       defines the foreign symbol XDVI, and the logical names XDVIFONTS and
  210. !       XDVISIZES.  For more information on the expected contents of the logical
  211. !       names, see the LOGICAL NAMES section of this document.  The following
  212. !       lines are what I use locally:
  213.   
  214.         $ PROC      = F$ENVIRONMENT ("PROCEDURE")
  215.         $ TEXDIR    = F$PARSE (PROC, , , "DEVICE", "NO_CONCEAL") + -
  216. --- 395,404 ----
  217.            $ LIBRARY /INSERT HELPLIB.HLB XDVI.HLP
  218.   
  219.      4) Modify the command file you use to set up the TEX commands so that it
  220. !       defines the foreign symbol XDVI, and the logical names "XDVIFONTS",
  221. !       "XDVIVFS", and "XDVISIZES".  For more information on the expected contents
  222. !       of the logical names, see the LOGICAL NAMES section of this document.  The
  223. !       following lines are what I use locally:
  224.   
  225.         $ PROC      = F$ENVIRONMENT ("PROCEDURE")
  226.         $ TEXDIR    = F$PARSE (PROC, , , "DEVICE", "NO_CONCEAL") + -
  227. ***************
  228. *** 390,395 ****
  229. --- 423,429 ----
  230.         $!
  231.         $ XDVI :== "$TEX_EXE:XDVI"
  232.         $ DEFINE XDVIFONTS "TEX_PIXELS:[DPI%d]%f.%p"
  233. +       $ DEFINE XDVIVFS   XDVIFONTS
  234.         $ DEFINE XDVISIZES -
  235.                 "300/328.6/360/432/518.4/600/622/746.4/895.8/1075/1200/1290/1548"
  236.         $ EXIT
  237. ***************
  238. *** 407,413 ****
  239.                       Iowa City, IA 52242
  240.   
  241.                       Phone: (319) 335-1960
  242. !                     Email: allendorf@iowasp.physics.uiowa.edu
  243.   
  244.   AUTHORS
  245.   -------
  246. --- 441,447 ----
  247.                       Iowa City, IA 52242
  248.   
  249.                       Phone: (319) 335-1960
  250. !                     Email: scott-allendorf@uiowa.edu
  251.   
  252.   AUTHORS
  253.   -------
  254. diff -cr xdvi_old/XDVI.RNH xdvi_new/XDVI.RNH
  255. *** xdvi_old/XDVI.RNH    Mon Feb  4 13:09:35 1991
  256. --- xdvi_new/XDVI.RNH    Sun Jun  7 22:47:17 1992
  257. ***************
  258. *** 9,14 ****
  259. --- 9,15 ----
  260.   .! Merged with patchlevel 8.001 help file for VMS by Scott Allendorf.
  261.   .! Added new switches for patchlevel 10.  Scott Allendorf.
  262.   .! Added new switches for patchlevel 11.  Scott Allendorf.
  263. + .! Added new switches for patchlevel 14.  Scott Allendorf.
  264.   .!
  265.   .NO PAGING
  266.   .NO FLAGS ALL
  267. ***************
  268. *** 227,232 ****
  269. --- 228,244 ----
  270.   .SKIP
  271.   The resource name is ".listFonts".
  272.   .INDENT -1
  273. + 3 -nogrey
  274. + .BREAK
  275. + -nogrey
  276. + .SKIP
  277. + Turns off the use of greyscale anti-aliasing when printing shrunken bitmaps.
  278. + (In this case, the logic of the corresponding resource is the reverse;
  279. + -nogrey corresponds to grey:off; +nogrey to grey:on).
  280. + See also 'G' under the Keystrokes help entry.
  281. + .SKIP
  282. + The resource name is ".grey".
  283. + .INDENT -1
  284.   3 -offsets
  285.   .BREAK
  286.   -offsets <dimen>
  287. ***************
  288. *** 342,347 ****
  289. --- 354,365 ----
  290.   .SKIP
  291.   The resource name is ".topMargin".
  292.   .INDENT -1
  293. + 3 -version
  294. + .BREAK
  295. + -version
  296. + .SKIP
  297. + Print information on the version of XDVI.
  298. + .INDENT -1
  299.   3 -xoffset
  300.   .BREAK
  301.   -xoffset <dimen>
  302. ***************
  303. *** 457,462 ****
  304. --- 475,486 ----
  305.   well.  The `k' keystroke toggles a `keep-position' flag which, when
  306.   set, will keep the same position when moving between pages.  Also `0k'
  307.   and `1k' clear and set this flag, respectively.  See also the -keep option.
  308. + .INDENT -1
  309. + 3 G
  310. + .BREAK
  311. + The key toggles the use of greyscale anti-aliasing for displaying shrunken 
  312. + bitmaps.  In addition, the key sequences `0G' and `1G' clear and set this flag,
  313. + respectively.  See also the -nogrey option.
  314.   
  315.   .INDENT -1
  316.   2 Mouse_Actions
  317. ***************
  318. *** 528,533 ****
  319. --- 552,566 ----
  320.   inches, which should be encoded as 328.6.  The current default set of
  321.   sizes is 300/328.6/360/432/518.4/622/746.4.  XDVI will also try the actual
  322.   size of the font before trying any of the given sizes.
  323. + 
  324. + .INDENT -1
  325. + 3 XDVIVFS
  326. + .BREAK
  327. + Virtual fonts are supported, although XDVI does not have any built-in fonts to
  328. + which they can refer.  The search path for .VF files can be specified with the
  329. + "XDVIVFS" logical name in a similar manner to that for the "XDVIFONTS" logical
  330. + name.  Virtual fonts are searched for immediately after looking for the font
  331. + as a normal font in the exact size specified.
  332.   
  333.   .INDENT -1
  334.   2 Resource_Names
  335. diff -cr xdvi_old/dvi_draw.c xdvi_new/dvi_draw.c
  336. *** xdvi_old/dvi_draw.c    Sat Mar 28 13:00:26 1992
  337. --- xdvi_new/dvi_draw.c    Mon Jun  1 18:08:40 1992
  338. ***************
  339. *** 14,19 ****
  340. --- 14,20 ----
  341.    * 4/1989    Modified for System V by Donald Richardson, Clarkson Univ.
  342.    * 3/1990    Added VMS support    --Scott Allendorf, U of Iowa
  343.    * 7/1990    Added reflection mode    --Michael Pak, Hebrew U of Jerusalem
  344. +  * 1/1992    Added greyscale code    --Till Brychcy, Techn. Univ. Muenchen
  345.    *
  346.    *    Compilation options:
  347.    *    SYSV    compile for System V
  348. ***************
  349. *** 27,32 ****
  350. --- 28,34 ----
  351.    *    ALTFONT    default for -altfont option
  352.    *    A4    use European size paper
  353.    *    TEXXET    support reflection dvi codes (right-to-left typesetting)
  354. +  *    GREY    use grey levels to shrink fonts
  355.    */
  356.   
  357.   #include <ctype.h>
  358. ***************
  359. *** 37,42 ****
  360. --- 39,54 ----
  361.   #include <stdlib.h>
  362.   #endif
  363.   
  364. + #if    NeedVarargsPrototypes        /* this is for tell_oops */
  365. + #include <stdarg.h>
  366. + #else
  367. + #include <varargs.h>
  368. + #endif
  369. + 
  370. + #ifdef    DOPRNT    /* define this if vfprintf gives you trouble */
  371. + #define    vfprintf(stream, message, args)    _doprnt(message, args, stream)
  372. + #endif
  373. + 
  374.   static    struct frame    frame0;        /* dummy head of list */
  375.   #ifdef    TEXXET
  376.   static    struct frame    *scan_frame;    /* head frame for scanning */
  377. ***************
  378. *** 96,107 ****
  379.   
  380.   extern    char    *xmalloc();
  381.   
  382. ! #ifndef VMS
  383. ! extern    off_t    lseek();
  384. ! #else
  385. ! extern    int    lseek();
  386.   #endif
  387. ! extern    long    tell();
  388.   
  389.   #ifndef    SEEK_SET    /* if <unistd.h> is not provided (or for <X11R5) */
  390.   #define    SEEK_SET    0
  391. --- 108,117 ----
  392.   
  393.   extern    char    *xmalloc();
  394.   
  395. ! #ifdef    VMS
  396. ! #define    off_t    int
  397.   #endif
  398. ! extern    off_t    lseek();
  399.   
  400.   #ifndef    SEEK_SET    /* if <unistd.h> is not provided (or for <X11R5) */
  401.   #define    SEEK_SET    0
  402. ***************
  403. *** 111,117 ****
  404. --- 121,223 ----
  405.   
  406.   static    void    draw_part();
  407.   
  408. + /*
  409. +  *    Byte reading routines for dvi file.
  410. +  */
  411. + 
  412. + #define    xtell(pos)    (lseek(fileno(dvi_file), 0L, SEEK_CUR) - \
  413. +                 (currinf.end - (pos)))
  414. + 
  415. + static    ubyte
  416. + xxone()
  417. + {
  418. +     if (currinf.virtual) {
  419. +         ++currinf.pos;
  420. +         return EOP;
  421. +     }
  422. +     currinf.end = dvi_buffer +
  423. +         read(fileno(dvi_file), (char *) (currinf.pos = dvi_buffer),
  424. +         DVI_BUFFER_LEN);
  425. +     return currinf.end > dvi_buffer ? *(currinf.pos)++ : EOF;
  426. + }
  427. + 
  428. + #define    xone()  (currinf.pos < currinf.end ? *(currinf.pos)++ : xxone())
  429. + 
  430. + static    unsigned long
  431. + xnum(size)
  432. +     register ubyte size;
  433. + {
  434. +     register long x = 0;
  435. + 
  436. +     while (size--) x = (x << 8) | xone();
  437. +     return x;
  438. + }
  439. + 
  440. + static    long
  441. + xsnum(size)
  442. +     register ubyte size;
  443. + {
  444. +     register long x;
  445. + 
  446. + #ifdef    __STDC__
  447. +     x = (signed char) xone();
  448. + #else
  449. +     x = xone();
  450. +     if (x & 0x80) x -= 0x100;
  451. + #endif
  452. +     while (--size) x = (x << 8) | xone();
  453. +     return x;
  454. + }
  455. + 
  456. + #define    xsfour()    xsnum(4)
  457. + 
  458.   static    void
  459. + xskip(offset)
  460. +     long    offset;
  461. + {
  462. +     currinf.pos += offset;
  463. +     if (!currinf.virtual && currinf.pos > currinf.end)
  464. +         (void) lseek(fileno(dvi_file), (long) (currinf.pos - currinf.end),
  465. +         SEEK_CUR);
  466. + }
  467. + 
  468. + #if    NeedVarargsPrototypes
  469. + static    volatile void
  470. + tell_oops(_Xconst char *message, ...)
  471. + #else
  472. + /* VARARGS */
  473. + static    volatile void
  474. + tell_oops(va_alist)
  475. +     va_dcl
  476. + #endif
  477. + {
  478. + #if    !NeedVarargsPrototypes
  479. +     _Xconst char *message;
  480. + #endif
  481. +     va_list    args;
  482. + 
  483. +     Fprintf(stderr, "%s: ", prog);
  484. + #if    NeedVarargsPrototypes
  485. +     va_start(args, message);
  486. + #else
  487. +     va_start(args);
  488. +     message = va_arg(args, _Xconst char *);
  489. + #endif
  490. +     (void) vfprintf(stderr, message, args);
  491. +     va_end(args);
  492. +     if (currinf.virtual)
  493. +         Fprintf(stderr, " in virtual font %s\n", currinf.virtual->fontname);
  494. +     else
  495. +         Fprintf(stderr, ", offset %d\n", xtell(currinf.pos - 1));
  496. +     exit(1);
  497. + }
  498. + 
  499. + 
  500. + /*
  501. +  *    Code for debugging options.
  502. +  */
  503. + 
  504. + static    void
  505.   print_bitmap(bitmap)
  506.       register struct bitmap *bitmap;
  507.   {
  508. ***************
  509. *** 183,253 ****
  510.       else s = dvi_table2[ch - (FNTNUM0 + 64)];
  511.       if (s) puts(s);
  512.       else
  513. !         if (currinf.virtual)
  514. !         oops("Unknown op-code %d in virtual font", ch);
  515. !         else
  516. !         oops("Unknown op-code %d, offset %d", ch,
  517. !             tell(fileno(dvi_file)) - (currinf.end - currinf.pos + 1));
  518.   }
  519.   
  520. - /*
  521. -  *    Byte reading routines for dvi file.
  522. -  */
  523.   
  524. - static    ubyte
  525. - xxone()
  526. - {
  527. -     if (currinf.virtual) {
  528. -         ++currinf.pos;
  529. -         return EOP;
  530. -     }
  531. -     currinf.end = dvi_buffer +
  532. -         read(fileno(dvi_file), (char *) (currinf.pos = dvi_buffer),
  533. -         DVI_BUFFER_LEN);
  534. -     return currinf.end > dvi_buffer ? *(currinf.pos)++ : EOF;
  535. - }
  536. - 
  537. - #define    xone()  (currinf.pos < currinf.end ? *(currinf.pos)++ : xxone())
  538. - 
  539. - static    unsigned long
  540. - xnum(size)
  541. -     register ubyte size;
  542. - {
  543. -     register long x = 0;
  544. - 
  545. -     while (size--) x = (x << 8) | xone();
  546. -     return x;
  547. - }
  548. - 
  549. - static    long
  550. - xsnum(size)
  551. -     register ubyte size;
  552. - {
  553. -     register long x;
  554. - 
  555. - #ifdef    __STDC__
  556. -     x = (signed char) xone();
  557. - #else
  558. -     x = xone();
  559. -     if (x & 0x80) x -= 0x100;
  560. - #endif
  561. -     while (--size) x = (x << 8) | xone();
  562. -     return x;
  563. - }
  564. - 
  565. - #define    xsfour()    xsnum(4)
  566. - 
  567. - static    void
  568. - xskip(offset)
  569. -     long    offset;
  570. - {
  571. -     currinf.pos += offset;
  572. -     if (!currinf.virtual && currinf.pos > currinf.end)
  573. -         (void) lseek(fileno(dvi_file), (long) (currinf.pos - currinf.end),
  574. -         SEEK_CUR);
  575. - }
  576. - 
  577. - 
  578.   /*
  579.    *    Count the number of set bits in a given region of the bitmap
  580.    */
  581. --- 289,298 ----
  582.       else s = dvi_table2[ch - (FNTNUM0 + 64)];
  583.       if (s) puts(s);
  584.       else
  585. !         tell_oops("unknown op-code %d", ch);
  586.   }
  587.   
  588.   
  589.   /*
  590.    *    Count the number of set bits in a given region of the bitmap
  591.    */
  592. ***************
  593. *** 303,309 ****
  594. --- 348,468 ----
  595.       return n;
  596.   }
  597.   
  598. + #ifdef    GREY
  599.   static    void
  600. + shrink_glyph_grey(g)
  601. +     register struct glyph *g;
  602. + {
  603. +     int    shrunk_bytes_wide, shrunk_height;
  604. +     int    rows_left, rows, init_cols, cols_left;
  605. +     register int    cols;
  606. +     int    x, y;
  607. +     long    thesample;
  608. +     BMUNIT    *old_ptr, *new_ptr;
  609. +     register BMUNIT    m, *cp;
  610. +     int    min_sample = shrink_factor * shrink_factor * density / 100;
  611. + 
  612. +     /* These machinations ensure that the character is shrunk according to
  613. +        its hot point, rather than its upper left-hand corner. */
  614. +     g->x2 = g->x / shrink_factor;
  615. +     init_cols = g->x - g->x2 * shrink_factor;
  616. +     if (init_cols <= 0) init_cols += shrink_factor;
  617. +     else ++g->x2;
  618. +     g->bitmap2.w = g->x2 + ROUNDUP(g->bitmap.w - g->x, shrink_factor);
  619. +     /* include row zero with the positively numbered rows */
  620. +     cols = g->y + 1; /* spare register variable */
  621. +     g->y2 = cols / shrink_factor;
  622. +     rows = cols - g->y2 * shrink_factor;
  623. +     if (rows <= 0) {
  624. +         rows += shrink_factor;
  625. +         --g->y2;
  626. +     }
  627. +     g->bitmap2.h = shrunk_height = g->y2 +
  628. +         ROUNDUP(g->bitmap.h - cols, shrink_factor) + 1;
  629. +     if (g->bitmap2.bits) free(g->bitmap2.bits);
  630. +     alloc_bitmap(&g->bitmap2);
  631. + 
  632. +     if (g->pixmap2)
  633. +         XDestroyImage(g->image2);
  634. + 
  635. +     g->pixmap2 = xmalloc((unsigned) (g->bitmap2.bytes_wide * g->bitmap2.h *
  636. +                    DefaultDepthOfScreen(SCRN)), "character pixmap");
  637. +     g->image2 = XCreateImage(DISP,DefaultVisualOfScreen(SCRN),
  638. +                  DefaultDepthOfScreen(SCRN),
  639. +                  XYPixmap, 0, g->pixmap2,
  640. +                  g->bitmap2.w, g->bitmap2.h,
  641. +                  BITS_PER_BMUNIT, 0);
  642. + 
  643. +     old_ptr = (BMUNIT *) g->bitmap.bits;
  644. +     new_ptr = (BMUNIT *) g->bitmap2.bits;
  645. +     shrunk_bytes_wide = g->bitmap2.bytes_wide;
  646. +     rows_left = g->bitmap.h;
  647. +     bzero((char *) new_ptr, shrunk_bytes_wide * shrunk_height);
  648. +     y = 0;
  649. +     while (rows_left) {
  650. +         x = 0;
  651. +         if (rows > rows_left) rows = rows_left;
  652. +         cols_left = g->bitmap.w;
  653. + #ifndef    MSBITFIRST
  654. +         m = (1 << 0);
  655. + #else
  656. +         m = (1 << (BITS_PER_BMUNIT-1));
  657. + #endif
  658. +         cp = new_ptr;
  659. +         cols = init_cols;
  660. +         while (cols_left) {
  661. +         if (cols > cols_left) cols = cols_left;
  662. +         if ((thesample = sample(old_ptr, g->bitmap.bytes_wide,
  663. +             g->bitmap.w - cols_left, cols, rows)) >= min_sample)
  664. +             *cp |= m;
  665. + #ifndef    MSBITFIRST
  666. +         if (m == (BMUNIT)(1 << (BITS_PER_BMUNIT-1))) {
  667. +             m = (1 << 0);
  668. +             ++cp;
  669. +         }
  670. +         else m <<= 1;
  671. + #else
  672. +         if (m == (1 << 0)) {
  673. +             m = (1 << (BITS_PER_BMUNIT-1));
  674. +             ++cp;
  675. +         }
  676. +         else m >>= 1;
  677. + #endif
  678. +         cols_left -= cols;
  679. +         cols = shrink_factor;
  680. + 
  681. +         if (shrink_factor == 2)
  682. +             XPutPixel(g->image2, x, y, pixel2[thesample]);
  683. +         else if (shrink_factor == 3)
  684. +             XPutPixel(g->image2, x, y, pixel3[thesample]);
  685. +         else if (shrink_factor == 4)
  686. +             XPutPixel(g->image2, x, y, pixel4[thesample]);
  687. +         else
  688. +             XPutPixel(g->image2, x, y,
  689. +             pixel4[thesample * 16 / shrink_factor / shrink_factor]);
  690. + 
  691. +         x++;
  692. +         }
  693. +         *((char **) &new_ptr) += shrunk_bytes_wide;
  694. +         *((char **) &old_ptr) += rows * g->bitmap.bytes_wide;
  695. +         rows_left -= rows;
  696. +         rows = shrink_factor;
  697. +         y++;
  698. +     }
  699. + 
  700. +     while (y < g->bitmap2.h) {
  701. +         for (x = 0; x < g->bitmap2.w; x++)
  702. +         XPutPixel(g->image2, x, y, pixel2[0]);
  703. +         y++;
  704. +     }
  705. + 
  706. +     g->y2 = g->y / shrink_factor;
  707. +     if (debug & DBG_BITMAP)
  708. +         print_bitmap(&g->bitmap2);
  709. + }
  710. + #endif    /* GREY */
  711. + 
  712. + static    void
  713.   shrink_glyph(g)
  714.       register struct glyph *g;
  715.   {
  716. ***************
  717. *** 397,403 ****
  718.               load_font(currinf.fontp);
  719.           break;
  720.           }
  721. !     if (currinf.fontp == NULL) oops("Non-existent font #%d", n);
  722.       maxchar = currinf.fontp->maxchar;
  723.       currinf.set_char_p = currinf.fontp->set_char_p;
  724.   }
  725. --- 556,562 ----
  726.               load_font(currinf.fontp);
  727.           break;
  728.           }
  729. !     if (currinf.fontp == NULL) tell_oops("non-existent font #%d", n);
  730.       maxchar = currinf.fontp->maxchar;
  731.       currinf.set_char_p = currinf.fontp->set_char_p;
  732.   }
  733. ***************
  734. *** 470,479 ****
  735. --- 629,652 ----
  736.           if (shrink_factor == 1)
  737.           put_bitmap(&g->bitmap, PXL_H - g->x, PXL_V - g->y);
  738.           else {
  739. + #ifdef    GREY
  740. +         if (use_grey) {
  741. +             if (g->pixmap2 == NULL) {
  742. +             shrink_glyph_grey(g);
  743. +             }
  744. +             put_image(g->image2, PXL_H - g->x2, PXL_V - g->y2);
  745. +         } else {
  746. +             if (g->bitmap2.bits == NULL) {
  747. +             shrink_glyph(g);
  748. +             }
  749. +             put_bitmap(&g->bitmap2, PXL_H - g->x2, PXL_V - g->y2);
  750. +         }
  751. + #else
  752.           if (g->bitmap2.bits == NULL) {
  753.               shrink_glyph(g);
  754.           }
  755.           put_bitmap(&g->bitmap2, PXL_H - g->x2, PXL_V - g->y2);
  756. + #endif
  757.           }
  758.   #ifndef    TEXXET
  759.       return g->dvi_adv;
  760. ***************
  761. *** 524,533 ****
  762.           currinf.tn_head = currinf.fontp->vf_chain;
  763.           currinf.pos = m->pos;
  764.           currinf.end = m->end;
  765. !         currinf.virtual = True;
  766.           draw_part(current_frame, currinf.fontp->dimconv);
  767.           if (currinf.pos != currinf.end + 1)
  768. !         oops("Virtual character macro does not end correctly.");
  769.           currinf = oldinfo;
  770.           maxchar = oldmaxchar;
  771.   #ifndef    TEXXET
  772. --- 697,706 ----
  773.           currinf.tn_head = currinf.fontp->vf_chain;
  774.           currinf.pos = m->pos;
  775.           currinf.end = m->end;
  776. !         currinf.virtual = currinf.fontp;
  777.           draw_part(current_frame, currinf.fontp->dimconv);
  778.           if (currinf.pos != currinf.end + 1)
  779. !         tell_oops("virtual character macro does not end correctly");
  780.           currinf = oldinfo;
  781.           maxchar = oldmaxchar;
  782.   #ifndef    TEXXET
  783. ***************
  784. *** 553,559 ****
  785.       ubyte    ch;
  786.   {
  787.       if (currinf.virtual) {
  788. !         currinf.fontp = currinf.fontp->first_font;
  789.           if (currinf.fontp != NULL) {
  790.           if (!(currinf.fontp->flags & FONT_LOADED))
  791.               load_font(currinf.fontp);
  792. --- 726,732 ----
  793.       ubyte    ch;
  794.   {
  795.       if (currinf.virtual) {
  796. !         currinf.fontp = currinf.virtual->first_font;
  797.           if (currinf.fontp != NULL) {
  798.           if (!(currinf.fontp->flags & FONT_LOADED))
  799.               load_font(currinf.fontp);
  800. ***************
  801. *** 567,573 ****
  802.   #endif
  803.           }
  804.       }
  805. !     oops("Dvi file or vf macro sets character of unknown font.");
  806.       /* NOTREACHED */
  807.   }
  808.   
  809. --- 740,746 ----
  810.   #endif
  811.           }
  812.       }
  813. !     tell_oops("attempt to set character of unknown font");
  814.       /* NOTREACHED */
  815.   }
  816.   
  817. ***************
  818. *** 639,645 ****
  819.   #ifdef    TEXXET
  820.       struct drawinf    oldinfo;
  821.       ubyte    oldmaxchar;
  822. !     long    file_pos;
  823.       int    refl_count;
  824.   #endif
  825.   
  826. --- 812,818 ----
  827.   #ifdef    TEXXET
  828.       struct drawinf    oldinfo;
  829.       ubyte    oldmaxchar;
  830. !     off_t    file_pos;
  831.       int    refl_count;
  832.   #endif
  833.   
  834. ***************
  835. *** 715,721 ****
  836.   
  837.               case EOP:
  838.               if (current_frame != minframe)
  839. !                 oops("Stack not empty at EOP");
  840.               return;
  841.   
  842.               case PUSH:
  843. --- 888,894 ----
  844.   
  845.               case EOP:
  846.               if (current_frame != minframe)
  847. !                 tell_oops("stack not empty at EOP");
  848.               return;
  849.   
  850.               case PUSH:
  851. ***************
  852. *** 732,738 ****
  853.   
  854.               case POP:
  855.               if (current_frame == minframe)
  856. !                 oops("More POPs than PUSHes");
  857.               currinf.data = current_frame->data;
  858.               current_frame = current_frame->prev;
  859.               break;
  860. --- 905,911 ----
  861.   
  862.               case POP:
  863.               if (current_frame == minframe)
  864. !                 tell_oops("more POPs than PUSHes");
  865.               currinf.data = current_frame->data;
  866.               current_frame = current_frame->prev;
  867.               break;
  868. ***************
  869. *** 744,751 ****
  870.                   oldinfo = currinf;
  871.                   oldmaxchar = maxchar;
  872.                   if (!currinf.virtual)
  873. !                 file_pos = tell(fileno(dvi_file)) -
  874. !                     (currinf.end - currinf.pos);
  875.                   scan_frame = current_frame; /* now we're scanning */
  876.                   refl_count = 0;
  877.                   break;
  878. --- 917,923 ----
  879.                   oldinfo = currinf;
  880.                   oldmaxchar = maxchar;
  881.                   if (!currinf.virtual)
  882. !                 file_pos = xtell(currinf.pos);
  883.                   scan_frame = current_frame; /* now we're scanning */
  884.                   refl_count = 0;
  885.                   break;
  886. ***************
  887. *** 773,780 ****
  888.                   current_frame->data = currinf.data;
  889.                   /* next:  restore old file position, XX, etc. */
  890.                   if (!currinf.virtual) {
  891. !                     long bgn_pos = tell(fileno(dvi_file))
  892. !                      - (currinf.end - dvi_buffer);
  893.                       if (file_pos >= bgn_pos) {
  894.                       oldinfo.pos = dvi_buffer
  895.                           + (file_pos - bgn_pos);
  896. --- 945,952 ----
  897.                   current_frame->data = currinf.data;
  898.                   /* next:  restore old file position, XX, etc. */
  899.                   if (!currinf.virtual) {
  900. !                     off_t bgn_pos = xtell(dvi_buffer);
  901. ! 
  902.                       if (file_pos >= bgn_pos) {
  903.                       oldinfo.pos = dvi_buffer
  904.                           + (file_pos - bgn_pos);
  905. ***************
  906. *** 882,896 ****
  907.               xskip((long) xone() + (long) xone());
  908.               break;
  909.   
  910.               case PRE:
  911.               case POST:
  912.               case POSTPOST:
  913. !             oops("Shouldn't happen: %s encountered.",
  914.                   dvi_table2[ch - (FNTNUM0 + 64)]);
  915.               break;
  916.   
  917.               default:
  918. !             oops("Unknown op-code %d", ch);
  919.           } /* end switch*/
  920.           } /* end else (ch not a SETCHAR or FNTNUM) */
  921.       } /* end for */
  922. --- 1054,1072 ----
  923.               xskip((long) xone() + (long) xone());
  924.               break;
  925.   
  926. + #ifndef    TEXXET
  927. +             case SREFL:
  928. +             case EREFL:
  929. + #endif
  930.               case PRE:
  931.               case POST:
  932.               case POSTPOST:
  933. !             tell_oops("shouldn't happen: %s encountered",
  934.                   dvi_table2[ch - (FNTNUM0 + 64)]);
  935.               break;
  936.   
  937.               default:
  938. !             tell_oops("unknown op-code %d", ch);
  939.           } /* end switch*/
  940.           } /* end else (ch not a SETCHAR or FNTNUM) */
  941.       } /* end for */
  942. ***************
  943. *** 912,917 ****
  944.       bzero((char *) &currinf.data, sizeof(currinf.data));
  945.       currinf.tn_head = tn_head;
  946.       currinf.pos = currinf.end = dvi_buffer;
  947. !     currinf.virtual = False;
  948.       draw_part(current_frame = &frame0, dimconv);
  949.   }
  950. --- 1088,1093 ----
  951.       bzero((char *) &currinf.data, sizeof(currinf.data));
  952.       currinf.tn_head = tn_head;
  953.       currinf.pos = currinf.end = dvi_buffer;
  954. !     currinf.virtual = NULL;
  955.       draw_part(current_frame = &frame0, dimconv);
  956.   }
  957. diff -cr xdvi_old/dvi_init.c xdvi_new/dvi_init.c
  958. *** xdvi_old/dvi_init.c    Sat Mar 28 12:50:09 1992
  959. --- xdvi_new/dvi_init.c    Mon Jun  1 16:26:40 1992
  960. ***************
  961. *** 14,19 ****
  962. --- 14,20 ----
  963.    * 4/1989    Modified for System V by Donald Richardson, Clarkson Univ.
  964.    * 3/1990    Added VMS support    --Scott Allendorf, U of Iowa
  965.    * 7/1990    Added reflection mode    --Michael Pak, Hebrew U of Jerusalem
  966. +  * 1/1992    Added greyscale code    --Till Brychcy, Techn. Univ. Muenchen
  967.    *
  968.    *    Compilation options:
  969.    *    SYSV    compile for System V
  970. ***************
  971. *** 27,32 ****
  972. --- 28,34 ----
  973.    *    ALTFONT    default for -altfont option
  974.    *    A4    use European size paper
  975.    *    TEXXET    support reflection dvi codes (right-to-left typesetting)
  976. +  *    GREY    use grey levels to shrink fonts
  977.    */
  978.   
  979.   #include "xdvi.h"
  980. ***************
  981. *** 104,114 ****
  982.   
  983.       for (f = font_head; f != NULL; f = f->next)
  984.           if ((f->flags & FONT_LOADED) && !(f->flags & FONT_VIRTUAL))
  985. !         for (g = f->glyph; g <= f->glyph + f->maxchar; ++g)
  986.               if (g->bitmap2.bits) {
  987.               free(g->bitmap2.bits);
  988.               g->bitmap2.bits = NULL;
  989.               }
  990.   }
  991.   
  992.   /*
  993. --- 106,123 ----
  994.   
  995.       for (f = font_head; f != NULL; f = f->next)
  996.           if ((f->flags & FONT_LOADED) && !(f->flags & FONT_VIRTUAL))
  997. !         for (g = f->glyph; g <= f->glyph + f->maxchar; ++g) {
  998.               if (g->bitmap2.bits) {
  999.               free(g->bitmap2.bits);
  1000.               g->bitmap2.bits = NULL;
  1001.               }
  1002. + #ifdef    GREY
  1003. +             if (g->pixmap2) {
  1004. +             XDestroyImage(g->image2);
  1005. +             g->pixmap2 = NULL;
  1006. +             }
  1007. + #endif
  1008. +         }
  1009.   }
  1010.   
  1011.   /*
  1012. ***************
  1013. *** 295,302 ****
  1014.            *    into SPELL units by multiplying by
  1015.            *        (pixels_per_inch * 2**16) / (72.27 * 2**20).
  1016.            */
  1017. !         fsize = (0.001 * 72.27 * (1<<4)) * vfparent->dimconv * scale
  1018. !         / design * magnification;
  1019.           scale_dimconv = vfparent->dimconv;
  1020.       }
  1021.       size = 5 * fsize + 0.5;
  1022. --- 304,310 ----
  1023.            *    into SPELL units by multiplying by
  1024.            *        (pixels_per_inch * 2**16) / (72.27 * 2**20).
  1025.            */
  1026. !         fsize = (72.27 * (1<<4)) * vfparent->dimconv * scale / design;
  1027.           scale_dimconv = vfparent->dimconv;
  1028.       }
  1029.       size = 5 * fsize + 0.5;
  1030. ***************
  1031. *** 466,471 ****
  1032. --- 474,482 ----
  1033.                   g <= fontp->glyph + fontp->maxchar; ++g) {
  1034.                   if (g->bitmap.bits != NULL) free(g->bitmap.bits);
  1035.                   if (g->bitmap2.bits != NULL) free(g->bitmap2.bits);
  1036. + #ifdef    GREY
  1037. +                 if (g->pixmap2 != NULL) XDestroyImage(g->image2);
  1038. + #endif
  1039.               }
  1040.               free((char *) fontp->glyph);
  1041.               }
  1042. diff -cr xdvi_old/font_open.c xdvi_new/font_open.c
  1043. *** xdvi_old/font_open.c    Thu Mar 26 18:05:45 1992
  1044. --- xdvi_new/font_open.c    Tue May 19 15:09:48 1992
  1045. ***************
  1046. *** 74,80 ****
  1047. --- 74,83 ----
  1048.   #endif
  1049.   
  1050.   char    *xmalloc(), *getenv();
  1051. + 
  1052. + #ifndef    atof
  1053.   double    atof();
  1054. + #endif
  1055.   
  1056.   #ifdef    SEARCH_SUBDIRECTORIES
  1057.   /* We will need some system include files to deal with directories.  */
  1058. ***************
  1059. *** 457,463 ****
  1060.           }
  1061.           else *n++ = c;
  1062.       }
  1063. !     if (!p_used && first_try) return NULL;
  1064.       *n = '\0';
  1065.       if (debug & DBG_OPEN) Printf("Trying font file %s\n", nm);
  1066.       f = xfopen(nm);
  1067. --- 460,466 ----
  1068.           }
  1069.           else *n++ = c;
  1070.       }
  1071. !     if (!p_used && !first_try) return NULL;
  1072.       *n = '\0';
  1073.       if (debug & DBG_OPEN) Printf("Trying font file %s\n", nm);
  1074.       f = xfopen(nm);
  1075. ***************
  1076. *** 571,595 ****
  1077.       return NULL;
  1078.   }
  1079.   
  1080.   /*
  1081.    *    Try a given font name
  1082.    */
  1083.   
  1084.   static    FILE *
  1085. ! pre_font_open(font, mag, mag_ret, name)
  1086.       _Xconst char    *font;
  1087. !     float    mag;
  1088.       int    *mag_ret;
  1089.       char    **name;
  1090.   {
  1091.       FILE    *f;
  1092.       int    *p1, *p2;
  1093. !     int    imag    = mag + 0.5;
  1094. !     int    pxlmag    = 5 * mag + 0.5;
  1095.   #ifndef    VMS
  1096.       _Xconst char    *path_to_use;
  1097.       _Xconst char    *vf_path_to_use;
  1098.   #endif
  1099.   
  1100.       /*
  1101.        * Loop over sizes.  Try actual size first, then closest sizes.
  1102. --- 574,665 ----
  1103.       return NULL;
  1104.   }
  1105.   
  1106. + #ifdef    MAKEPKCMD
  1107. + #define    MAKEPK
  1108. + #endif
  1109. + 
  1110. + #ifdef    MAKEPK
  1111. + 
  1112. + #ifndef    MAKEPKCMD
  1113. + #define    MAKEPKCMD    "MakeTeXPK"
  1114. + #endif
  1115. + 
  1116.   /*
  1117. +  *    Create the string for magstep() values.
  1118. +  */
  1119. + 
  1120. + static    char *
  1121. + magstring(mdpi)
  1122. +     int    mdpi;
  1123. + {
  1124. +     int    m;
  1125. +     double    fdpi;
  1126. +     int    tdpi;
  1127. +     static    char    str[24];
  1128. + 
  1129. +     if (mdpi != 0) {
  1130. +         fdpi = pixels_per_inch;
  1131. +         m = 0;
  1132. +         if (mdpi >= pixels_per_inch) {
  1133. +         while ((tdpi = fdpi + 0.5) < mdpi) {
  1134. +             fdpi *= 1.095445115;
  1135. +             ++m;
  1136. +         }
  1137. +         if (tdpi == mdpi) {
  1138. +             Sprintf(str, "magstep\\(%d%s\\)", m / 2, m % 2 ? ".5" : "");
  1139. +             return str;
  1140. +         }
  1141. +         }
  1142. +         else {
  1143. +         do {
  1144. +             fdpi *= 0.9128709292;
  1145. +             ++m;
  1146. +         }
  1147. +         while ((tdpi = fdpi + 0.5) > mdpi);
  1148. +         if (tdpi == mdpi) {
  1149. +             Sprintf(str, "magstep\\(-%d%s\\)", m / 2, m % 2 ? ".5" :"");
  1150. +             return str;
  1151. +         }
  1152. +         }
  1153. +     }
  1154. +     Sprintf(str, "%d+%d/%d", mdpi / pixels_per_inch, mdpi % pixels_per_inch,
  1155. +         pixels_per_inch);
  1156. +     return str;
  1157. + }
  1158. + #endif    /* MAKEPK */
  1159. + 
  1160. + /*
  1161.    *    Try a given font name
  1162.    */
  1163.   
  1164. + #ifndef    MAKEPK
  1165. + #define    PRE_FONT_OPEN(font, fmag, mag_ret, name, ignore) \
  1166. +         pre_font_open(font, fmag, mag_ret, name)
  1167. + #else
  1168. + #define    PRE_FONT_OPEN    pre_font_open
  1169. + #endif
  1170. + 
  1171.   static    FILE *
  1172. ! PRE_FONT_OPEN(font, fmag, mag_ret, name, try_make)
  1173.       _Xconst char    *font;
  1174. !     float    fmag;
  1175.       int    *mag_ret;
  1176.       char    **name;
  1177. + #ifdef    MAKEPK
  1178. +     Boolean    try_make;
  1179. + #endif
  1180.   {
  1181.       FILE    *f;
  1182.       int    *p1, *p2;
  1183. !     int    mag    = 5 * fmag + 0.5;
  1184. !     int    tmag;
  1185.   #ifndef    VMS
  1186.       _Xconst char    *path_to_use;
  1187.       _Xconst char    *vf_path_to_use;
  1188.   #endif
  1189. + #ifdef    MAKEPK
  1190. +     char    mkpk[80];
  1191. + #endif
  1192.   
  1193.       /*
  1194.        * Loop over sizes.  Try actual size first, then closest sizes.
  1195. ***************
  1196. *** 614,646 ****
  1197.   #define    vf_path_to_use    vf_path
  1198.   #endif    /* VMS */
  1199.   
  1200. !     if ((f = try_size(font, *mag_ret = pxlmag, name, path_to_use,
  1201.           default_font_path)) != NULL)
  1202.           return f;
  1203.   
  1204.       /* Try at one away from the size we just tried, to account
  1205.          for rounding error.  */
  1206. !     if (pxlmag < 5 * mag) ++pxlmag; else --pxlmag;
  1207. !     if ((f = try_size(font, *mag_ret = pxlmag, name, path_to_use,
  1208. !         default_font_path)) != NULL)
  1209.           return f;
  1210.   
  1211.       /* Try a virtual font. */
  1212.       if ((f = try_vf(font, name, vf_path_to_use, default_vf_path)) != NULL)
  1213.           return f;
  1214.   
  1215.       /* Now try at all the sizes. */
  1216. !     for (p2 = sizes; p2 < sizend; ++p2) if (*p2 >= pxlmag) break;
  1217.       p1 = p2;
  1218.       for (;;) {
  1219.           /* find another magnification */
  1220.           if (p1 <= sizes)
  1221.           if (p2 >= sizend) return NULL;
  1222. !         else pxlmag = *p2++;
  1223. !         else if (p2 >= sizend || imag * imag <= p1[-1] * *p2)
  1224. !             pxlmag = *--p1;
  1225. !         else pxlmag = *p2++;
  1226. !         if ((f = try_size(font, *mag_ret = pxlmag, name, path_to_use,
  1227.               default_font_path)) != NULL)
  1228.           return f;
  1229.       }
  1230. --- 684,732 ----
  1231.   #define    vf_path_to_use    vf_path
  1232.   #endif    /* VMS */
  1233.   
  1234. !     if ((f = try_size(font, *mag_ret = mag, name, path_to_use,
  1235.           default_font_path)) != NULL)
  1236.           return f;
  1237.   
  1238.       /* Try at one away from the size we just tried, to account
  1239.          for rounding error.  */
  1240. !     tmag = mag + (mag < 5 * fmag ? 1 : -1);
  1241. !     if ((f = try_size(font, tmag, name, path_to_use, default_font_path))
  1242. !         != NULL) {
  1243. !         *mag_ret = tmag;
  1244.           return f;
  1245. +     }
  1246.   
  1247.       /* Try a virtual font. */
  1248.       if ((f = try_vf(font, name, vf_path_to_use, default_vf_path)) != NULL)
  1249.           return f;
  1250.   
  1251. + #ifdef    MAKEPK
  1252. +     /* Try to create the font. */
  1253. +         if (try_make) {
  1254. +         Sprintf(mkpk, "%s %s %d %d %s", MAKEPKCMD, font, mag / 5,
  1255. +         pixels_per_inch, magstring(mag / 5));
  1256. +         Printf("- %s\n", mkpk);
  1257. +         if (system(mkpk) == 0
  1258. +         && (f = try_size(font, mag, name, path_to_use,
  1259. +             default_font_path))
  1260. +             != NULL)
  1261. +         return f;
  1262. +     }
  1263. + #endif
  1264. + 
  1265.       /* Now try at all the sizes. */
  1266. !     for (p2 = sizes; p2 < sizend; ++p2) if (*p2 >= mag) break;
  1267.       p1 = p2;
  1268.       for (;;) {
  1269.           /* find another magnification */
  1270.           if (p1 <= sizes)
  1271.           if (p2 >= sizend) return NULL;
  1272. !         else tmag = *p2++;
  1273. !         else if (p2 >= sizend || (long) mag * mag <= (long) p1[-1] * *p2)
  1274. !             tmag = *--p1;
  1275. !         else tmag = *p2++;
  1276. !         if ((f = try_size(font, *mag_ret = tmag, name, path_to_use,
  1277.               default_font_path)) != NULL)
  1278.           return f;
  1279.       }
  1280. ***************
  1281. *** 658,664 ****
  1282.       int    actual_pt, low_pt, high_pt, trial_pt;
  1283.       char    fn[50], *fnend;
  1284.   
  1285. !     f = pre_font_open(font, mag, mag_ret, name);
  1286.       if (f != NULL) {
  1287.           *font_ret = NULL;
  1288.           return f;
  1289. --- 744,750 ----
  1290.       int    actual_pt, low_pt, high_pt, trial_pt;
  1291.       char    fn[50], *fnend;
  1292.   
  1293. !     f = PRE_FONT_OPEN(font, mag, mag_ret, name, True);
  1294.       if (f != NULL) {
  1295.           *font_ret = NULL;
  1296.           return f;
  1297. ***************
  1298. *** 678,685 ****
  1299.           else if (high_pt > actual_pt + 5) break;
  1300.           else trial_pt = high_pt++;
  1301.           Sprintf(fnend, "%d", trial_pt);
  1302. !         f = pre_font_open(fn, mag * actual_pt / trial_pt, mag_ret,
  1303. !             name);
  1304.           if (f != NULL) {
  1305.               *font_ret = strcpy(xmalloc((unsigned) strlen(fn) + 1,
  1306.               "name of font used"), fn);
  1307. --- 764,771 ----
  1308.           else if (high_pt > actual_pt + 5) break;
  1309.           else trial_pt = high_pt++;
  1310.           Sprintf(fnend, "%d", trial_pt);
  1311. !         f = PRE_FONT_OPEN(fn, mag * actual_pt / trial_pt, mag_ret,
  1312. !             name, False);
  1313.           if (f != NULL) {
  1314.               *font_ret = strcpy(xmalloc((unsigned) strlen(fn) + 1,
  1315.               "name of font used"), fn);
  1316. ***************
  1317. *** 688,694 ****
  1318.           }
  1319.       }
  1320.       if (alt_font != NULL) {
  1321. !         f = pre_font_open(alt_font, mag, mag_ret, name);
  1322.           if (f != NULL)
  1323.           *font_ret = strcpy(xmalloc((unsigned) strlen(alt_font) + 1,
  1324.               "name of font used"), alt_font);
  1325. --- 774,780 ----
  1326.           }
  1327.       }
  1328.       if (alt_font != NULL) {
  1329. !         f = PRE_FONT_OPEN(alt_font, mag, mag_ret, name, False);
  1330.           if (f != NULL)
  1331.           *font_ret = strcpy(xmalloc((unsigned) strlen(alt_font) + 1,
  1332.               "name of font used"), alt_font);
  1333. diff -cr xdvi_old/mksedscript xdvi_new/mksedscript
  1334. *** xdvi_old/mksedscript    Thu Dec  5 17:43:12 1991
  1335. --- xdvi_new/mksedscript    Mon Jun  1 16:26:49 1992
  1336. ***************
  1337. *** 7,12 ****
  1338. --- 7,13 ----
  1339.       if ($x == -DA4)        set a4
  1340.       if ($x == -DSEARCH_SUBDIRECTORIES) set subdir
  1341.       if ($x == -DXDVIFONTS_ONLY) set texfonts
  1342. +     if ($x == -DGREY)    set grey
  1343.   end
  1344.   if ($?x10) then
  1345.       echo    /^\#ifx11/,/^\#/d
  1346. ***************
  1347. *** 18,23 ****
  1348. --- 19,25 ----
  1349.   if (! $?buttons)    echo /^\#ifbuttons/,/^\#/d
  1350.   if (! $?subdir)        echo /^\#ifsubdir/,/^\#/d
  1351.   if ($?texfonts)        echo /^\#iftexfonts/,/^\#/d
  1352. + if (! $?grey)        echo /^\#ifgrey/,/^\#/d
  1353.   echo    /^\#/d
  1354.   if ($?a4) then
  1355.       echo    's/%%defaultpagesize%%/21 x 29.7 cm (A4 size)/'
  1356. diff -cr xdvi_old/patchlevel.h xdvi_new/patchlevel.h
  1357. *** xdvi_old/patchlevel.h    Sat Mar 28 00:22:24 1992
  1358. --- xdvi_new/patchlevel.h    Tue Apr  7 12:44:34 1992
  1359. ***************
  1360. *** 1 ****
  1361. ! #define PATCHLEVEL 13
  1362. --- 1 ----
  1363. ! #define PATCHLEVEL 14
  1364. diff -cr xdvi_old/pk.c xdvi_new/pk.c
  1365. *** xdvi_old/pk.c    Thu Jan 23 12:54:49 1992
  1366. --- xdvi_new/pk.c    Thu Apr  9 12:57:16 1992
  1367. ***************
  1368. *** 135,141 ****
  1369.       /*
  1370.        * now read rest of character preamble
  1371.        */
  1372. !     if (n != 4) fpwidth = snum(fp, 3);
  1373.       else {
  1374.           fpwidth = sfour(fp);
  1375.           (void) four(fp);    /* horizontal escapement */
  1376. --- 135,141 ----
  1377.       /*
  1378.        * now read rest of character preamble
  1379.        */
  1380. !     if (n != 4) fpwidth = num(fp, 3);
  1381.       else {
  1382.           fpwidth = sfour(fp);
  1383.           (void) four(fp);    /* horizontal escapement */
  1384. diff -cr xdvi_old/pxl.c xdvi_new/pxl.c
  1385. *** xdvi_old/pxl.c    Mon Mar 23 19:03:00 1992
  1386. --- xdvi_new/pxl.c    Mon Jun  1 16:26:54 1992
  1387. ***************
  1388. *** 119,124 ****
  1389. --- 119,127 ----
  1390.       for (g = fontp->glyph; g < fontp->glyph + 128; ++g) {
  1391.           g->bitmap.bits = NULL;
  1392.           g->bitmap2.bits = NULL;
  1393. + #ifdef    GREY
  1394. +         g->pixmap2 = NULL;
  1395. + #endif
  1396.           g->bitmap.w = two(fp);
  1397.           g->bitmap.h = two(fp);
  1398.           g->x = stwo(fp);
  1399. diff -cr xdvi_old/util.c xdvi_new/util.c
  1400. *** xdvi_old/util.c    Sat Mar 28 12:50:28 1992
  1401. --- xdvi_new/util.c    Mon Jun  1 17:08:35 1992
  1402. ***************
  1403. *** 52,57 ****
  1404. --- 52,61 ----
  1405.   #include <varargs.h>
  1406.   #endif
  1407.   
  1408. + #ifdef    DOPRNT    /* define this if vfprintf gives you trouble */
  1409. + #define    vfprintf(stream, message, args)    _doprnt(message, args, stream)
  1410. + #endif
  1411. + 
  1412.   /*
  1413.    *    General utility routines.
  1414.    */
  1415. diff -cr xdvi_old/vf.c xdvi_new/vf.c
  1416. *** xdvi_old/vf.c    Mon Mar 23 19:06:49 1992
  1417. --- xdvi_new/vf.c    Wed Apr 15 17:46:25 1992
  1418. ***************
  1419. *** 53,58 ****
  1420. --- 53,59 ----
  1421.   /*
  1422.    *    Read the fonts.
  1423.    */
  1424. +     fontp->vf_chain = NULL;
  1425.       fontp->first_font = NULL;
  1426.       while ((cmnd = one(VF_file)) >= FNTDEF1 && cmnd <= FNTDEF4) {
  1427.           define_font(VF_file, cmnd, fontp, &fontp->vf_chain);
  1428. diff -cr xdvi_old/xdvi.c xdvi_new/xdvi.c
  1429. *** xdvi_old/xdvi.c    Tue Mar 31 12:23:41 1992
  1430. --- xdvi_new/xdvi.c    Sun Jun  7 11:34:21 1992
  1431. ***************
  1432. *** 14,19 ****
  1433. --- 14,20 ----
  1434.    * 4/1989    Modified for System V by Donald Richardson, Clarkson Univ.
  1435.    * 3/1990    Added VMS support    --Scott Allendorf, U of Iowa
  1436.    * 7/1990    Added reflection mode    --Michael Pak, Hebrew U of Jerusalem
  1437. +  * 1/1992    Added greyscale code    --Till Brychcy, Techn. Univ. Muenchen
  1438.    *
  1439.    *    Compilation options:
  1440.    *    SYSV    compile for System V
  1441. ***************
  1442. *** 27,32 ****
  1443. --- 28,34 ----
  1444.    *    ALTFONT    default for -altfont option
  1445.    *    A4    use European size paper
  1446.    *    TEXXET    support reflection dvi codes (right-to-left typesetting)
  1447. +  *    GREY    use grey levels to shrink fonts
  1448.    */
  1449.   
  1450.   #ifndef    ALTFONT
  1451. ***************
  1452. *** 52,58 ****
  1453.   #define    INIT(x)    =x
  1454.   #include "xdvi.h"
  1455.   
  1456. - #ifndef lint
  1457.   #include "patchlevel.h"
  1458.   static    struct {_Xconst char    a[36], b, c, d;}
  1459.   #ifndef X10
  1460. --- 54,59 ----
  1461. ***************
  1462. *** 62,68 ****
  1463.       header = {"$Header: xdvi.c (X10), patchlevel = ", '0' + PATCHLEVEL / 10,
  1464.           '0' + PATCHLEVEL % 10, 0};
  1465.   #endif
  1466. - #endif    /* lint */
  1467.   
  1468.   #ifndef    X_NOT_STDC_ENV
  1469.   #include <stdlib.h>
  1470. --- 63,68 ----
  1471. ***************
  1472. *** 69,76 ****
  1473.   #endif
  1474.   
  1475.   #ifndef X10
  1476. ! /* Xlib is already included */
  1477. ! #include <X11/Xutil.h>
  1478.   #include <X11/cursorfont.h>
  1479.   #include <X11/keysym.h>
  1480.   #include "xdvi.icon"
  1481. --- 69,75 ----
  1482.   #endif
  1483.   
  1484.   #ifndef X10
  1485. ! /* Xlib and Xutil are already included */
  1486.   #include <X11/cursorfont.h>
  1487.   #include <X11/keysym.h>
  1488.   #include "xdvi.icon"
  1489. ***************
  1490. *** 88,93 ****
  1491. --- 87,93 ----
  1492.   #include <X11/Shell.h>    /* needed for def. of XtNiconX */
  1493.   #ifndef    XtSpecificationRelease
  1494.   #define    XtSpecificationRelease    0
  1495. + #define    XtPointer caddr_t
  1496.   #endif
  1497.   #if    XtSpecificationRelease >= 4
  1498.   #include <X11/Xaw/Viewport.h>
  1499. ***************
  1500. *** 119,127 ****
  1501.   #endif
  1502.   
  1503.   #ifndef X10
  1504.   static    Display    *DISP;
  1505. - #define    DPY    DISP,
  1506.   static    Screen    *SCRN;
  1507.   static    Cursor    redraw_cursor, ready_cursor;
  1508.   
  1509.   #ifdef    VMS
  1510. --- 119,129 ----
  1511.   #endif
  1512.   
  1513.   #ifndef X10
  1514. + #ifndef    GREY
  1515.   static    Display    *DISP;
  1516.   static    Screen    *SCRN;
  1517. + #endif
  1518. + #define    DPY    DISP,
  1519.   static    Cursor    redraw_cursor, ready_cursor;
  1520.   
  1521.   #ifdef    VMS
  1522. ***************
  1523. *** 194,199 ****
  1524. --- 196,202 ----
  1525.   
  1526.   static    int    pageno_correct    = 1;
  1527.   static    Boolean    keep_flag    = False;
  1528. + static    Boolean    version        = False;
  1529.   #ifdef    BUTTONS
  1530.   Boolean    expert        = False;
  1531.   #endif
  1532. ***************
  1533. *** 486,496 ****
  1534. --- 489,539 ----
  1535.   #endif    /* X10 */
  1536.   #endif    /* lint */
  1537.   
  1538. + #ifdef    GREY
  1539. + static    void
  1540. + make_one_pixel_map(pixel, hi)
  1541. +     long pixel[];
  1542. +     int hi;
  1543. + {
  1544. +     int i;
  1545. +     int level;
  1546. +     XColor color;
  1547. + 
  1548. +     for (i = 0; i <= hi; i++) {
  1549. +         level = (hi - i) * 65535 / hi;
  1550. +         color.red = color.green = color.blue = level;
  1551. +         color.flags = DoRed | DoGreen | DoBlue;
  1552. +         if (XAllocColor(DISP, DefaultColormapOfScreen(SCRN), &color) == 0)
  1553. +         pixel[i] = (level >= 32768) ? BlackPixelOfScreen(SCRN)
  1554. +                         : WhitePixelOfScreen(SCRN);
  1555. +         else
  1556. +         pixel[i] = color.pixel;
  1557. +     }
  1558. + }
  1559. + 
  1560. + static    void
  1561. + init_pix()
  1562. + {
  1563. +     static    Boolean    pixels_allocated = False;
  1564. + 
  1565. +     if (pixels_allocated)
  1566. +         return;
  1567. + 
  1568. +     make_one_pixel_map(pixel2, 2*2);
  1569. +     make_one_pixel_map(pixel3, 3*3);
  1570. +     make_one_pixel_map(pixel4, 4*4);
  1571. + 
  1572. +     pixels_allocated = True;
  1573. + }
  1574. + #endif    /* GREY */
  1575. + 
  1576.   #ifdef    sun
  1577.   extern    char    *sprintf();
  1578.   #endif
  1579.   
  1580. + #ifndef    atof    /* on the Next it's a macro */
  1581.   extern    double    atof();
  1582. + #endif
  1583.   
  1584.   /********************************
  1585.    *      tpic routines        *
  1586. ***************
  1587. *** 621,626 ****
  1588. --- 664,694 ----
  1589.       }
  1590.   }
  1591.   
  1592. + #ifdef    GREY
  1593. + void
  1594. + put_image(img, x, y)
  1595. +     register XImage *img;
  1596. +     register int x, y;
  1597. + {
  1598. +     if (x < max_x && x + img->width >= min_x &&
  1599. +         y < max_y && y + img->height >= min_y) {
  1600. + 
  1601. +         if (--event_counter == 0) read_events (False);
  1602. + 
  1603. +         XPutImage(DISP, WINDOW(currwin), foreGC, img,
  1604. +                 0, 0,
  1605. +             x - currwin.base_x, y - currwin.base_y,
  1606. +             img->width, img->height);
  1607. + 
  1608. +         if (foreGC2)
  1609. +         XPutImage(DISP, WINDOW(currwin), foreGC2, img,
  1610. +             0, 0,
  1611. +             x - currwin.base_x, y - currwin.base_y,
  1612. +             img->width, img->height);
  1613. +     }
  1614. + }
  1615. + #endif    /* GREY */
  1616. + 
  1617.   /*
  1618.    *    Event-handling routines
  1619.    */
  1620. ***************
  1621. *** 728,734 ****
  1622.   {
  1623.       if (!scrl) XUnmapWindow(DISP, WINDOW(mane));
  1624.       get_xy();
  1625. !     if (page_w > clip_w) {
  1626.           register int coord = (page_w - clip_w) / 2;
  1627.           if (coord > home_x / mane.shrinkfactor)
  1628.           coord = home_x / mane.shrinkfactor;
  1629. --- 796,802 ----
  1630.   {
  1631.       if (!scrl) XUnmapWindow(DISP, WINDOW(mane));
  1632.       get_xy();
  1633. !     if (x_bar != NULL) {
  1634.           register int coord = (page_w - clip_w) / 2;
  1635.           if (coord > home_x / mane.shrinkfactor)
  1636.           coord = home_x / mane.shrinkfactor;
  1637. ***************
  1638. *** 735,741 ****
  1639.           XtCallCallbacks(x_bar, XtNscrollProc,
  1640.           (XtPointer) (window_x + coord));
  1641.       }
  1642. !     if (page_h > clip_h) {
  1643.           register int coord = (page_h - clip_h) / 2;
  1644.           if (coord > home_y / mane.shrinkfactor)
  1645.           coord = home_y / mane.shrinkfactor;
  1646. --- 803,809 ----
  1647.           XtCallCallbacks(x_bar, XtNscrollProc,
  1648.           (XtPointer) (window_x + coord));
  1649.       }
  1650. !     if (y_bar != NULL) {
  1651.           register int coord = (page_h - clip_h) / 2;
  1652.           if (coord > home_y / mane.shrinkfactor)
  1653.           coord = home_y / mane.shrinkfactor;
  1654. ***************
  1655. *** 1212,1219 ****
  1656.       if (windowrec == &alt)
  1657.           if (alt_stat < 0) {    /* destroy upon exposure */
  1658.           alt_stat = 0;
  1659. !         handle_release(widget, (caddr_t) NULL, (XButtonEvent *) event,
  1660. !             (Boolean *) NULL);
  1661.           return;
  1662.           }
  1663.           else
  1664. --- 1280,1286 ----
  1665.       if (windowrec == &alt)
  1666.           if (alt_stat < 0) {    /* destroy upon exposure */
  1667.           alt_stat = 0;
  1668. !         handle_release(widget, (caddr_t) NULL, ev, (Boolean *) NULL);
  1669.           return;
  1670.           }
  1671.           else
  1672. ***************
  1673. *** 1436,1441 ****
  1674. --- 1503,1515 ----
  1675.           reset_fonts();
  1676.           if (mane.shrinkfactor == 1) return;
  1677.           break;
  1678. + #ifdef GREY
  1679. +         case 'G':
  1680. +         use_grey = (arg0 ? number0 : !use_grey);
  1681. +         if (use_grey) init_pix();
  1682. +         reset_fonts();
  1683. +         break;
  1684. + #endif
  1685.           case 'R':
  1686.           /* reread DVI file */
  1687.           --dvi_time;    /* then it will notice a change */
  1688. ***************
  1689. *** 1497,1503 ****
  1690.           if (resized) get_geom();
  1691.           if (event.xany.window == WINDOW(alt) &&
  1692.               event.type == Expose) {
  1693. !         handle_exp((Widget) NULL, &alt, &event.xexpose, (Boolean*)NULL);
  1694.           continue;
  1695.           }
  1696.           if (event.type != KeyPress) {
  1697. --- 1571,1577 ----
  1698.           if (resized) get_geom();
  1699.           if (event.xany.window == WINDOW(alt) &&
  1700.               event.type == Expose) {
  1701. !         handle_exp((Widget) NULL, &alt, &event, (Boolean *) NULL);
  1702.           continue;
  1703.           }
  1704.           if (event.type != KeyPress) {
  1705. ***************
  1706. *** 1837,1843 ****
  1707.       [-expert] [-paper <papertype>] [-mgs[n] <size>] [-altfont <font>]\n\
  1708.       [-margins <dimen>] [-sidemargin <dimen>] [-topmargin <dimen>]\n\
  1709.       [-offsets <dimen>] [-xoffset <dimen>] [-yoffset <dimen>] [-keep]\n\
  1710. !     [-hushspecials] [-hushchars] [-hush]\n\
  1711.       [-fg <color>] [-bg <color>] [-hl <color>] [-bd <color>] \
  1712.   [-cr <color>]\n\
  1713.       [-bw <width>] [-geometry <geometry>] [-icongeometry <geometry>]\n\
  1714. --- 1911,1917 ----
  1715.       [-expert] [-paper <papertype>] [-mgs[n] <size>] [-altfont <font>]\n\
  1716.       [-margins <dimen>] [-sidemargin <dimen>] [-topmargin <dimen>]\n\
  1717.       [-offsets <dimen>] [-xoffset <dimen>] [-yoffset <dimen>] [-keep]\n\
  1718. !     [-hushspecials] [-hushchars] [-hush] [-nogrey] [-version]\n\
  1719.       [-fg <color>] [-bg <color>] [-hl <color>] [-bd <color>] \
  1720.   [-cr <color>]\n\
  1721.       [-bw <width>] [-geometry <geometry>] [-icongeometry <geometry>]\n\
  1722. ***************
  1723. *** 1849,1855 ****
  1724.       [-paper <papertype>] [-mgs[n] <size>] [-altfont <font>]\n\
  1725.       [-margins <dimen>] [-sidemargin <dimen>] [-topmargin <dimen>]\n\
  1726.       [-offsets <dimen>] [-xoffset <dimen>] [-yoffset <dimen>] [-keep]\n\
  1727. !     [-hushspecials] [-hushchars] [-hush]\n\
  1728.       [-fg <color>] [-bg <color>] [-hl <color>] [-bd <color>] \
  1729.   [-cr <color>]\n\
  1730.       [-bw <width>] [-geometry <geometry>] [-icongeometry <geometry>]\n\
  1731. --- 1923,1929 ----
  1732.       [-paper <papertype>] [-mgs[n] <size>] [-altfont <font>]\n\
  1733.       [-margins <dimen>] [-sidemargin <dimen>] [-topmargin <dimen>]\n\
  1734.       [-offsets <dimen>] [-xoffset <dimen>] [-yoffset <dimen>] [-keep]\n\
  1735. !     [-hushspecials] [-hushchars] [-hush] [-nogrey] [-version]\n\
  1736.       [-fg <color>] [-bg <color>] [-hl <color>] [-bd <color>] \
  1737.   [-cr <color>]\n\
  1738.       [-bw <width>] [-geometry <geometry>] [-icongeometry <geometry>]\n\
  1739. ***************
  1740. *** 1864,1870 ****
  1741.   \n", stderr);
  1742.       Fputs("\
  1743.       [-offsets <dimen>] [-xoffset <dimen>] [-yoffset <dimen>] [-keep]\n\
  1744. !     [-hushspecials] [-hushchars] [-hush]\n\
  1745.       [-fg <color>] [-bg <color>] [-hl <color>] [-bd <color>] \
  1746.   [-cr <color>]\n\
  1747.       [-bw <width>] [-geometry <geometry>] [-icongeometry <geometry>]\n\
  1748. --- 1938,1944 ----
  1749.   \n", stderr);
  1750.       Fputs("\
  1751.       [-offsets <dimen>] [-xoffset <dimen>] [-yoffset <dimen>] [-keep]\n\
  1752. !     [-hushspecials] [-hushchars] [-hush] [-nogrey] [-version]\n\
  1753.       [-fg <color>] [-bg <color>] [-hl <color>] [-bd <color>] \
  1754.   [-cr <color>]\n\
  1755.       [-bw <width>] [-geometry <geometry>] [-icongeometry <geometry>]\n\
  1756. ***************
  1757. *** 1945,1950 ****
  1758. --- 2019,2026 ----
  1759.   {"+copy",    ".copy",    XrmoptionNoArg,        (caddr_t) "off"},
  1760.   {"-thorough",    ".thorough",    XrmoptionNoArg,        (caddr_t) "on"},
  1761.   {"+thorough",    ".thorough",    XrmoptionNoArg,        (caddr_t) "off"},
  1762. + {"-version",    ".version",    XrmoptionNoArg,        (caddr_t) "on"},
  1763. + {"+version",    ".version",    XrmoptionNoArg,        (caddr_t) "off"},
  1764.   #ifdef    BUTTONS
  1765.   {"-expert",    ".expert",    XrmoptionNoArg,        (caddr_t) "on"},
  1766.   {"+expert",    ".expert",    XrmoptionNoArg,        (caddr_t) "off"},
  1767. ***************
  1768. *** 1955,1960 ****
  1769. --- 2031,2040 ----
  1770.   {"-mgs3",    ".magnifierSize3",XrmoptionSepArg,    (caddr_t) NULL},
  1771.   {"-mgs4",    ".magnifierSize4",XrmoptionSepArg,    (caddr_t) NULL},
  1772.   {"-mgs5",    ".magnifierSize5",XrmoptionSepArg,    (caddr_t) NULL},
  1773. + #ifdef    GREY
  1774. + {"-nogrey",    ".grey",    XrmoptionNoArg,        (caddr_t) "off"},
  1775. + {"+nogrey",    ".grey",    XrmoptionNoArg,        (caddr_t) "on"},
  1776. + #endif
  1777.   };
  1778.   
  1779.   static    XtResource    resources[] = {
  1780. ***************
  1781. *** 2014,2019 ****
  1782. --- 2094,2101 ----
  1783.     (Cardinal)©, XtRBoolean, (caddr_t) ©},
  1784.   {"thorough", "Thorough", XtRBoolean, sizeof(Boolean),
  1785.     (Cardinal)&thorough, XtRBoolean, (caddr_t) &thorough},
  1786. + {"version", "Version", XtRBoolean, sizeof(Boolean),
  1787. +   (Cardinal)&version, XtRBoolean, (caddr_t) &version},
  1788.   #ifdef    BUTTONS
  1789.   {"expert", "Expert", XtRBoolean, sizeof(Boolean),
  1790.     (Cardinal)&expert, XtRBoolean, (caddr_t) &expert},
  1791. ***************
  1792. *** 2028,2033 ****
  1793. --- 2110,2119 ----
  1794.     (Cardinal) &mg_size[3], XtRInt, (caddr_t) &mg_size[3]},
  1795.   {"magnifierSize5", "MagnifierSize", XtRInt, sizeof(int),
  1796.     (Cardinal) &mg_size[4], XtRInt, (caddr_t) &mg_size[4]},
  1797. + #ifdef    GREY
  1798. + {"grey", "Grey", XtRBoolean, sizeof (Boolean),
  1799. +  (Cardinal) &use_grey, XtRBoolean, (caddr_t) &use_grey},
  1800. + #endif
  1801.   };
  1802.   
  1803.   static    Arg    temp_args1[] = {
  1804. ***************
  1805. *** 2148,2153 ****
  1806. --- 2234,2241 ----
  1807.   {"+copy",    "copy",        FalseArg, BooleanArg, 1,(caddr_t) ©},
  1808.   {"-thorough",    NULL,        TrueArg, BooleanArg, 2,    (caddr_t) &thorough},
  1809.   {"+thorough",    "thorough",    FalseArg, BooleanArg, 1,(caddr_t) &thorough},
  1810. + {"-version",    NULL,        TrueArg, BooleanArg, 2,    (caddr_t) &version},
  1811. + {"+version",    "version",    FalseArg, BooleanArg, 1,(caddr_t) &version},
  1812.   #endif    /* X10 */
  1813.   {"-mgs",    NULL,        SepArg, NumberArg, 2,    (caddr_t) &mg_size[0]},
  1814.   {"-mgs1",    "magnifierSize1",SepArg, NumberArg, 1,    (caddr_t) &mg_size[0]},
  1815. ***************
  1816. *** 2157,2162 ****
  1817. --- 2245,2254 ----
  1818.   {"-mgs4",    "magnifierSize4",SepArg, NumberArg, 1,    (caddr_t) &mg_size[3]},
  1819.   {"-mgs5",    "magnifierSize5",SepArg, NumberArg, 1,    (caddr_t) &mg_size[4]},
  1820.   #endif
  1821. + #ifdef    GREY
  1822. + {"-nogrey",    NULL,        FalseArg, BooleanArg, 2,(caddr_t) &use_grey},
  1823. + {"+nogrey",    "grey",        TrueArg, BooleanArg, 1,    (caddr_t) &use_grey},
  1824. + #endif
  1825.   };
  1826.   
  1827.   /*
  1828. ***************
  1829. *** 2478,2484 ****
  1830. --- 2570,2584 ----
  1831.           current_page = (*curr_page ? atoi(curr_page) : total_pages) - 1;
  1832.           if (current_page < 0 || current_page >= total_pages) usage();
  1833.       }
  1834. +     if (version) puts((_Xconst char *) &header);
  1835.   
  1836. + #ifdef    GREY
  1837. +     if (DefaultDepthOfScreen(SCRN) == 1)
  1838. +         use_grey = False;
  1839. +     if (use_grey)
  1840. +         init_pix();
  1841. + #endif
  1842. + 
  1843.   #ifndef X10
  1844.   
  1845.       /*
  1846. ***************
  1847. *** 2503,2509 ****
  1848.           XCreateGC(DISP, RootWindowOfScreen(SCRN),\
  1849.               GCFunction|GCForeground|GCBackground, &values))
  1850.   
  1851. !         if (copy == 2) copy = (PlanesOfScreen(SCRN) > 1);
  1852.           if (copy || (set_bits && clr_bits))
  1853.           ruleGC = MakeGC(GXcopy, fore_Pixel, back_Pixel);
  1854.           if (copy) foreGC = ruleGC;
  1855. --- 2603,2609 ----
  1856.           XCreateGC(DISP, RootWindowOfScreen(SCRN),\
  1857.               GCFunction|GCForeground|GCBackground, &values))
  1858.   
  1859. !         if (copy == 2) copy = (DefaultDepthOfScreen(SCRN) > 1);
  1860.           if (copy || (set_bits && clr_bits))
  1861.           ruleGC = MakeGC(GXcopy, fore_Pixel, back_Pixel);
  1862.           if (copy) foreGC = ruleGC;
  1863. diff -cr xdvi_old/xdvi.h xdvi_new/xdvi.h
  1864. *** xdvi_old/xdvi.h    Fri Mar 27 18:15:28 1992
  1865. --- xdvi_new/xdvi.h    Mon Jun  1 16:28:20 1992
  1866. ***************
  1867. *** 8,13 ****
  1868. --- 8,14 ----
  1869.   
  1870.   #ifndef X10
  1871.   #include <X11/Xlib.h>    /* include Xfuncs.h, if available */
  1872. + #include <X11/Xutil.h>    /* needed for XDestroyImage */
  1873.   #include <X11/Xos.h>    /* same as below */
  1874.   #else    /* X10 */
  1875.   #include <X/Xlib.h>    /* get type of Window */
  1876. ***************
  1877. *** 181,187 ****
  1878.       set_char_proc    set_char_p;
  1879.       struct tn    *tn_head;
  1880.       ubyte        *pos, *end;
  1881. !     Boolean        virtual;
  1882.   #ifdef    TEXXET
  1883.       int        dir;
  1884.   #endif
  1885. --- 182,188 ----
  1886.       set_char_proc    set_char_p;
  1887.       struct tn    *tn_head;
  1888.       ubyte        *pos, *end;
  1889. !     struct font    *virtual;
  1890.   #ifdef    TEXXET
  1891.       int        dir;
  1892.   #endif
  1893. ***************
  1894. *** 245,250 ****
  1895. --- 246,255 ----
  1896.       short x, y;        /* x and y offset in pixels */
  1897.       struct bitmap bitmap;    /* bitmap for character */
  1898.       short x2, y2;        /* x and y offset in pixels (shrunken bitmap) */
  1899. + #ifdef    GREY
  1900. +     XImage *image2;
  1901. +     char *pixmap2;
  1902. + #endif
  1903.       struct bitmap bitmap2;    /* shrunken bitmap for character */
  1904.   };
  1905.   
  1906. ***************
  1907. *** 358,363 ****
  1908. --- 363,381 ----
  1909.   
  1910.   EXTERN    jmp_buf    dvi_env;    /* mechanism to communicate dvi file errors */
  1911.   
  1912. + #ifdef    GREY
  1913. + #ifndef    X10
  1914. + EXTERN    Display    *DISP;
  1915. + EXTERN    Screen    *SCRN;
  1916. + EXTERN    long    pixel4[17];
  1917. + EXTERN    long    pixel3[10];
  1918. + EXTERN    long    pixel2[5];
  1919. + EXTERN    Boolean    use_grey    INIT(True);
  1920. + #else    /* Sorry - GREY works only with X11 */
  1921. + #undef    GREY
  1922. + #endif    /* X10 */
  1923. + #endif    /* GREY */
  1924. + 
  1925.   /********************************
  1926.    *       Procedures        *
  1927.    *******************************/
  1928. ***************
  1929. *** 369,374 ****
  1930. --- 387,395 ----
  1931.   extern    void    dot_at(int, int);
  1932.   extern    void    do_attribute_path(int, int, int, int);
  1933.   extern    void    put_bitmap(struct bitmap *, int, int);
  1934. + #ifdef    GREY
  1935. + extern    void    put_image(XImage *, int, int);
  1936. + #endif
  1937.   extern    void    put_rectangle(int, int, int, int, WIDEARG(Boolean, int));
  1938.   extern    void    redraw_page(void);
  1939.   #if    NeedVarargsPrototypes
  1940. ***************
  1941. *** 413,418 ****
  1942. --- 434,442 ----
  1943.   extern    void    dot_at();
  1944.   extern    void    do_attribute_path();
  1945.   extern    void    put_bitmap();
  1946. + #ifdef    GREY
  1947. + extern    void    put_image();
  1948. + #endif
  1949.   extern    void    put_rectangle();
  1950.   extern    void    redraw_page();
  1951.   extern    volatile void    oops();
  1952. diff -cr xdvi_old/xdvi_man.sed xdvi_new/xdvi_man.sed
  1953. *** xdvi_old/xdvi_man.sed    Thu Dec  5 17:27:34 1991
  1954. --- xdvi_new/xdvi_man.sed    Sun Jun  7 11:36:01 1992
  1955. ***************
  1956. *** 18,25 ****
  1957. --- 18,28 ----
  1958.   #ifx11
  1959.   [\-geometry \fIgeometry\fP] [\-icongeometry \fIgeometry\fP] [\-iconic]
  1960.   [\-display \fIdisplay\fP] [\-copy] [\-thorough]
  1961. + #endif
  1962.   #ifbuttons
  1963.   [\-expert]
  1964. + #endif
  1965. + [\-version]
  1966.   #ifx10
  1967.   [\-geometry \fIgeometry\fP | =\fIgeometry\fP]
  1968.   [\-display \fIhost\fP:\fIdisplay\fP | \fIhost\fP:\fIdisplay\fP]
  1969. ***************
  1970. *** 179,184 ****
  1971. --- 182,190 ----
  1972.   Prevent the buttons from appearing.  See also the `x' keystroke.
  1973.   #endif
  1974.   .TP
  1975. + .BI \-version
  1976. + Print information on the version of \fIxdvi\fR.
  1977. + .TP
  1978.   .BI \-margins " dimen"
  1979.   (%%dot%%Margin)
  1980.   Specifies the size of both the top margin and side margin.
  1981. ***************
  1982. *** 230,236 ****
  1983. --- 236,251 ----
  1984.   legal (8.5x14), foolscap (13.5x17), as well as the ISO sizes a1-a7,
  1985.   b1-b7, c1-c7, a1r-a7r (a1-a7 rotated), etc.  The default size is
  1986.   %%defaultpagesize%%.
  1987. + #ifgrey
  1988.   .TP
  1989. + .B \-nogrey
  1990. + (.grey)
  1991. + Turns off the use of greyscale anti-aliasing when printing shrunken bitmaps.
  1992. + (In this case, the logic of the corresponding resource is the reverse:
  1993. + -nogrey corresponds to grey:off; +nogrey to grey:on.)
  1994. + See also the `G' keystroke.
  1995. + #endif
  1996. + .TP
  1997.   #ifx11
  1998.   .BI "\-mgs[n]" " size"
  1999.   (.magnifierSize[n])
  2000. ***************
  2001. *** 367,372 ****
  2002. --- 382,394 ----
  2003.   .B x
  2004.   Toggles expert mode (in which the buttons do not appear).  Also `0x' and `1x'
  2005.   clear and reset this mode, respectively.  See also the \fB\-expert\fR option.
  2006. + #endif
  2007. + #ifgrey
  2008. + .TP
  2009. + .B G
  2010. + This key toggles the use of greyscale anti-aliasing for displaying shrunken
  2011. + bitmaps.  In addition, the key sequences `0G' and `1G' clear and
  2012. + set this flag, respectively.  See also the \fB\-nogrey\fR option.
  2013.   #endif
  2014.   .SH MOUSE ACTIONS
  2015.   If the shrink factor is set to any number other than one, then clicking
  2016. -- 
  2017. --
  2018. Molecular Simulations, Inc.            mail: dcmartin@msi.com
  2019. 796 N. Pastoria Avenue                uucp: uunet!dcmartin
  2020. Sunnyvale, California 94086            at&t: 408/522-9236
  2021.