home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / x / volume4 / xdvi / patch4 < prev    next >
Encoding:
Text File  |  1989-07-16  |  57.6 KB  |  2,165 lines
  1. Path: uunet!island!argv
  2. From: argv@island.uu.net (Dan Heller)
  3. Newsgroups: comp.sources.x
  4. Subject: v04i044: xdvi, Patch4
  5. Message-ID: <875@island.uu.net>
  6. Date: 17 Jul 89 06:27:26 GMT
  7. Organization: Island Graphics, Marin County, California
  8. Lines: 2154
  9. Approved: island!argv@sun.com
  10.  
  11. Submitted-by: vojta@bosco.Berkeley.EDU
  12. Posting-number: Volume 4, Issue 44
  13. Archive-name: xdvi/patch4
  14.  
  15. Here's patch 4 to xdvi.  This patch allows the magnifying glass to move.
  16. It's jerky, but better than nothing.  Also, it changes the default shrink
  17. factor to 3.  I find it more useful than 4.
  18.  
  19. --Paul Vojta, vojta@math.berkeley.edu
  20.  
  21. ---- cut here ----
  22. diff -cr old/Makefile new/Makefile
  23. *** old/Makefile    Thu Jul 13 12:52:07 1989
  24. --- new/Makefile    Thu Jul 13 12:58:03 1989
  25. ***************
  26. *** 22,28 ****
  27.   BINDIR=/usr/sipb/$$(MACHTYPE)bin
  28.   INCLUDES=-I$(INCDIR)
  29.   CFLAGS=-O $(INCLUDES) $(DEFINES)
  30. ! LIBS=-L$(LIBDIR) -lXaw -lXt $(XMULIB) -lX11 -lm
  31.   SRCS=xdvi.c dvi_init.c dvi_draw.c $(FONTFORMATS_C) pxl_open.c tpic.c \
  32.     xdvi.h dvi.h xdvi.icon
  33.   OBJS=xdvi.o dvi_init.o dvi_draw.o $(FONTFORMATS_O) pxl_open.o tpic.o
  34. --- 22,28 ----
  35.   BINDIR=/usr/sipb/$$(MACHTYPE)bin
  36.   INCLUDES=-I$(INCDIR)
  37.   CFLAGS=-O $(INCLUDES) $(DEFINES)
  38. ! LIBS=-L$(LIBDIR) -lXaw $(XMULIB) -lXt -lX11 -lm
  39.   SRCS=xdvi.c dvi_init.c dvi_draw.c $(FONTFORMATS_C) pxl_open.c tpic.c \
  40.     xdvi.h dvi.h xdvi.icon
  41.   OBJS=xdvi.o dvi_init.o dvi_draw.o $(FONTFORMATS_O) pxl_open.o tpic.o
  42. diff -cr old/README new/README
  43. *** old/README    Thu Jul 13 12:52:13 1989
  44. --- new/README    Sat Jul  8 15:43:09 1989
  45. ***************
  46. *** 61,68 ****
  47.                   time xdvi -d 8 file.dvi
  48.       BMLONG        (X11 only; xdvi.c dvi_draw.c gf.c pk.c pxl.c)  Store
  49.               bitmaps in long integers instead of bytes.
  50. -     MAXCHARS    (dvi_init.c dvi_draw.c gf.c pk.c pxl.c)  Set to 256 for
  51. -             256-character fonts.  Default is 128.
  52.       ALTFONT        Default font to use if the font named in the dvi file
  53.               cannot be found.  Can be set to NULL.  By default, it
  54.               is "cmr10".
  55. --- 61,66 ----
  56. ***************
  57. *** 125,130 ****
  58. --- 123,131 ----
  59.       generating table.h.
  60.   --  Patchlevel 3:  --
  61.      13.  Added -altfont command line option and SYSV compilation option.
  62. + --  Patchlevel 4:  --
  63. +    14.  Removed MAXCHARS compilation option.  It's automatic now.  Made X10
  64. +     scrolling smoother.  Implemented the moving magnifying glass.
  65.   
  66.   Paul Vojta, vojta@math.berkeley.edu
  67.   ================================================================================
  68. diff -cr old/dvi_draw.c new/dvi_draw.c
  69. *** old/dvi_draw.c    Thu Jul 13 12:52:19 1989
  70. --- new/dvi_draw.c    Sat Jul  8 15:20:40 1989
  71. ***************
  72. *** 19,25 ****
  73.    *    MSBITFIRST    store bitmaps internally in with significant bit first
  74.    *    BMSHORT    store bitmaps in shorts instead of bytes
  75.    *    BMLONG    store bitmaps in longs instead of bytes
  76. -  *    MAXCHARS set to 256 for 256 character fonts (default = 128)
  77.    */
  78.   
  79.   #include <stdio.h>
  80. --- 19,24 ----
  81. ***************
  82. *** 294,302 ****
  83.   {
  84.       register struct glyph *g;
  85.   
  86. !     g = ¤t_font->glyph[ch];
  87. !     if (g->bitmap.bits == NULL) {
  88. !         if (g->addr == NULL)
  89.           oops("Character %d not defined in font %s\n", ch,
  90.               current_font->fontname);
  91.           open_pxl_file(current_font);
  92. --- 293,301 ----
  93.   {
  94.       register struct glyph *g;
  95.   
  96. !     if (ch > maxchar ||
  97. !         (g = ¤t_font->glyph[ch])->bitmap.bits == NULL) {
  98. !         if (ch > maxchar || g->addr == 0)
  99.           oops("Character %d not defined in font %s\n", ch,
  100.               current_font->fontname);
  101.           open_pxl_file(current_font);
  102. ***************
  103. *** 378,383 ****
  104. --- 377,383 ----
  105.       *prev = fontp->next;
  106.       fontp->next = current_font;
  107.       current_font = fontp;
  108. +     maxchar = current_font->maxchar;
  109.   }
  110.   
  111.   static
  112. ***************
  113. *** 426,435 ****
  114.                   case SET1:
  115.                   case PUT1:
  116.                   ch1 = one(dvi_file);
  117. - #if    MAXCHARS < 256
  118. -                 if (ch1 >= MAXCHARS)
  119. -                     oops("Character code too large:  %d", ch1);
  120. - #endif    MAXCHARS
  121.                   set_char(ch1);
  122.                   if (ch == SET1)
  123.                       DVI_H += current_font->glyph[ch1].dvi_adv;
  124. --- 426,431 ----
  125. diff -cr old/dvi_init.c new/dvi_init.c
  126. *** old/dvi_init.c    Thu Jul 13 12:52:22 1989
  127. --- new/dvi_init.c    Mon Jul 10 13:27:43 1989
  128. ***************
  129. *** 19,25 ****
  130.    *    MSBITFIRST    store bitmaps internally in with significant bit first
  131.    *    BMSHORT    store bitmaps in shorts instead of bytes
  132.    *    BMLONG    store bitmaps in longs instead of bytes
  133. -  *    MAXCHARS set to 256 for 256 character fonts (default = 128)
  134.    */
  135.   
  136.   #include <stdio.h>
  137. --- 19,24 ----
  138. ***************
  139. *** 29,34 ****
  140. --- 28,34 ----
  141.   #include <sys/stat.h>
  142.   
  143.   #define    dvi_oops(str)    longjmp(dvi_env, (int) str);
  144. + #define XtOffset(type, field)    ((unsigned int)&(((type)NULL)->field))
  145.   extern char    *alt_font;
  146.   
  147.   static    struct stat fstatbuf;        /* mechanism to see if file was */
  148. ***************
  149. *** 35,40 ****
  150. --- 35,41 ----
  151.   time_t    dvi_time;            /* modified since last usage */
  152.   
  153.   struct font *current_font = NULL;    /* ptr into linked list of fonts */
  154. + ubyte    maxchar;
  155.   
  156.   static    Boolean    font_not_found;
  157.   static    struct font **old_fonts;    /* used by read_postamble */
  158. ***************
  159. *** 41,46 ****
  160. --- 42,49 ----
  161.   
  162.   int    n_fonts_left    = 32767;    /* for LRU management of fonts */
  163.   
  164. + char    *realloc();
  165. + 
  166.   /*
  167.    * DVI preamble and postamble information.
  168.    */
  169. ***************
  170. *** 66,72 ****
  171.   #ifndef SYSV
  172.   char    *sprintf();
  173.   #endif
  174. ! char    *malloc();
  175.   FILE    *pxl_open();
  176.   
  177.   static    Boolean
  178. --- 69,75 ----
  179.   #ifndef SYSV
  180.   char    *sprintf();
  181.   #endif
  182. ! char    *malloc(), *strcpy();
  183.   FILE    *pxl_open();
  184.   
  185.   static    Boolean
  186. ***************
  187. *** 159,164 ****
  188. --- 162,168 ----
  189.       for (;;) {
  190.           fontp1 = *fontpp;
  191.           if (fontp1 == NULL) {
  192. +         maxchar = 255;
  193.           if (!define_new_font(fontp, fontp->fontname)) {
  194.               if (alt_font == NULL || !define_new_font(fontp, alt_font)) {
  195.               font_not_found = True;
  196. ***************
  197. *** 171,176 ****
  198. --- 175,186 ----
  199.               fontp->fontname = malloc((unsigned) strlen(alt_font)+1);
  200.               (void) strcpy(fontp->fontname, alt_font);
  201.           }
  202. +         while (maxchar > 0 && fontp->glyph[maxchar].addr == 0)
  203. +             --maxchar;
  204. +         if (maxchar < 255)
  205. +             fontp = (struct font *) realloc((char *) fontp,
  206. +             XtOffset(struct font *, glyph[(int) maxchar + 1]));
  207. +         fontp->maxchar = maxchar;
  208.           break;
  209.           }
  210.           if (strcmp(fontp->fontname, fontp1->fontname) == 0
  211. ***************
  212. *** 294,300 ****
  213.           }
  214.           free(fontp->fontname);
  215.           free(fontp->filename);
  216. !         for (g = &fontp->glyph[0]; g < &fontp->glyph[MAXCHARS]; ++g) {
  217.               if (g->bitmap.bits) free(g->bitmap.bits);
  218.               if (g->bitmap2.bits) free(g->bitmap2.bits);
  219.           }
  220. --- 304,311 ----
  221.           }
  222.           free(fontp->fontname);
  223.           free(fontp->filename);
  224. !         for (g = fontp->glyph; g <= fontp->glyph + fontp->maxchar; ++g)
  225. !         {
  226.               if (g->bitmap.bits) free(g->bitmap.bits);
  227.               if (g->bitmap2.bits) free(g->bitmap2.bits);
  228.           }
  229. ***************
  230. *** 394,400 ****
  231.       register struct glyph *g;
  232.   
  233.       for (f = current_font; f != NULL; f = f->next)
  234. !         for (g = &f->glyph[0]; g < &f->glyph[MAXCHARS]; ++g)
  235.           if (g->bitmap2.bits) {
  236.               free(g->bitmap2.bits);
  237.               g->bitmap2.bits = NULL;
  238. --- 405,411 ----
  239.       register struct glyph *g;
  240.   
  241.       for (f = current_font; f != NULL; f = f->next)
  242. !         for (g = f->glyph; g <= f->glyph + f->maxchar; ++g)
  243.           if (g->bitmap2.bits) {
  244.               free(g->bitmap2.bits);
  245.               g->bitmap2.bits = NULL;
  246. diff -cr old/gf.c new/gf.c
  247. *** old/gf.c    Thu Jul 13 12:52:25 1989
  248. --- new/gf.c    Sat Jul  8 15:21:34 1989
  249. ***************
  250. *** 76,82 ****
  251.    */
  252.       if (debug & DBG_PK)
  253.           Printf("Reading header for GF pixel file %s\n", fontp->filename);
  254. -     GF_file = fontp->file;
  255.       expect(PRE);
  256.       expect(GF_ID_BYTE);
  257.   /*
  258. --- 76,81 ----
  259. ***************
  260. *** 96,116 ****
  261.    *    Read postamble.
  262.    */
  263.       expect(POST);
  264. !     (void) four(GF_file);    /* pointer to last eoc + 1 */
  265. !     (void) four(fontp->file);        /* skip design size */
  266. !     (void) four(fontp->file);        /* skip checksum */
  267. !     hppp = sfour(fontp->file);
  268. !     vppp = sfour(fontp->file);
  269.       if (debug && hppp != vppp)
  270.           oops("Warning: aspect ratio not 1:1 for font %s", fontp->fontname);
  271. !     (void) four(fontp->file);        /* skip min_m */
  272. !     (void) four(fontp->file);        /* skip max_m */
  273. !     (void) four(fontp->file);        /* skip min_n */
  274. !     (void) four(fontp->file);        /* skip max_n */
  275.   /*
  276.    *    Prepare glyph array.
  277.    */
  278. !     for (g = fontp->glyph; g < &fontp->glyph[MAXCHARS]; ++g) {
  279.           g->addr = 0;
  280.           g->bitmap.bits = NULL;
  281.           g->bitmap2.bits = NULL;
  282. --- 95,115 ----
  283.    *    Read postamble.
  284.    */
  285.       expect(POST);
  286. !     (void) four(GF_file);        /* pointer to last eoc + 1 */
  287. !     (void) four(GF_file);        /* skip design size */
  288. !     (void) four(GF_file);        /* skip checksum */
  289. !     hppp = sfour(GF_file);
  290. !     vppp = sfour(GF_file);
  291.       if (debug && hppp != vppp)
  292.           oops("Warning: aspect ratio not 1:1 for font %s", fontp->fontname);
  293. !     (void) four(GF_file);        /* skip min_m */
  294. !     (void) four(GF_file);        /* skip max_m */
  295. !     (void) four(GF_file);        /* skip min_n */
  296. !     (void) four(GF_file);        /* skip max_n */
  297.   /*
  298.    *    Prepare glyph array.
  299.    */
  300. !     for (g = fontp->glyph; g < fontp->glyph + 256; ++g) {
  301.           g->addr = 0;
  302.           g->bitmap.bits = NULL;
  303.           g->bitmap2.bits = NULL;
  304. ***************
  305. *** 123,133 ****
  306.           int addr;
  307.   
  308.           ch = one(GF_file);            /* character code */
  309. - #if    MAXCHARS < 256
  310. -         if (ch >= MAXCHARS)
  311. -         oops("Character code %d outside range, file %s", ch,
  312. -             fontp->fontname);
  313. - #endif    MAXCHARS
  314.           g = &fontp->glyph[ch];
  315.           switch (cmnd) {
  316.           case CHAR_LOC:
  317. --- 122,127 ----
  318. diff -cr old/patchlevel.h new/patchlevel.h
  319. *** old/patchlevel.h    Thu Jul 13 12:52:26 1989
  320. --- new/patchlevel.h    Sat Jul  8 15:43:22 1989
  321. ***************
  322. *** 1 ****
  323. ! #define PATCHLEVEL 3
  324. --- 1 ----
  325. ! #define PATCHLEVEL 4
  326. diff -cr old/pk.c new/pk.c
  327. *** old/pk.c    Thu Jul 13 12:52:29 1989
  328. --- new/pk.c    Sat Jul  8 15:22:10 1989
  329. ***************
  330. *** 29,40 ****
  331.   
  332.   static    int
  333.   PK_get_nyb( fp )
  334. !      register struct font *fp;
  335.   {
  336.     unsigned temp;
  337.     if( PK_bitpos < 0 )
  338.       {
  339. !       PK_input_byte = one(fp->file);
  340.         PK_bitpos = 4;
  341.       }
  342.     temp = PK_input_byte >> PK_bitpos;
  343. --- 29,40 ----
  344.   
  345.   static    int
  346.   PK_get_nyb( fp )
  347. !      register FILE *fp;
  348.   {
  349.     unsigned temp;
  350.     if( PK_bitpos < 0 )
  351.       {
  352. !       PK_input_byte = one(fp);
  353.         PK_bitpos = 4;
  354.       }
  355.     temp = PK_input_byte >> PK_bitpos;
  356. ***************
  357. *** 45,51 ****
  358.   
  359.   static    int
  360.   PK_packed_num( fp )
  361. !      register struct font *fp;
  362.   {
  363.     int i,j;
  364.     if( ( i = PK_get_nyb( fp ) ) == 0 )
  365. --- 45,51 ----
  366.   
  367.   static    int
  368.   PK_packed_num( fp )
  369. !      register FILE *fp;
  370.   {
  371.     int i,j;
  372.     if( ( i = PK_get_nyb( fp ) ) == 0 )
  373. ***************
  374. *** 76,88 ****
  375.   
  376.   
  377.   static    void
  378. ! PK_skip_specials( fp )
  379. !      register struct font *fp;
  380.   {
  381.     int i,j;
  382.     do
  383.       {
  384. !       PK_flag_byte = one(fp->file);
  385.         if( PK_flag_byte >= PK_CMD_START )
  386.       {
  387.         switch( PK_flag_byte )
  388. --- 76,89 ----
  389.   
  390.   
  391.   static    void
  392. ! PK_skip_specials(fontp)
  393. !     register struct font *fontp;
  394.   {
  395.     int i,j;
  396. +   register FILE *fp = fontp->file;
  397.     do
  398.       {
  399. !       PK_flag_byte = one(fp);
  400.         if( PK_flag_byte >= PK_CMD_START )
  401.       {
  402.         switch( PK_flag_byte )
  403. ***************
  404. *** 94,110 ****
  405.             {
  406.           i = 0;
  407.           for (j = PK_CMD_START; j <= PK_flag_byte; j++)
  408. !           i = (i*256) + one(fp->file);
  409. !         while (i--) (void) one(fp->file);
  410.           break;
  411.             }
  412.           case PK_Y :
  413. !           (void) four(fp->file);
  414.           case PK_POST :
  415.           case PK_NOOP :
  416.             break;
  417.           default :
  418. !           oops("Unexpected %d in PK file %s\n", PK_flag_byte, fp->fontname);
  419.             break;
  420.           }
  421.       }
  422. --- 95,112 ----
  423.             {
  424.           i = 0;
  425.           for (j = PK_CMD_START; j <= PK_flag_byte; j++)
  426. !           i = (i*256) + one(fp);
  427. !         while (i--) (void) one(fp);
  428.           break;
  429.             }
  430.           case PK_Y :
  431. !           (void) four(fp);
  432.           case PK_POST :
  433.           case PK_NOOP :
  434.             break;
  435.           default :
  436. !           oops("Unexpected %d in PK file %s\n", PK_flag_byte,
  437. !         fontp->fontname);
  438.             break;
  439.           }
  440.       }
  441. ***************
  442. *** 147,153 ****
  443.     /*if (fontp->f_scale == 0) fontp->f_scale = 1000;*/
  444.       {
  445.           register struct glyph *g;
  446. !         for (g = fontp->glyph; g < &fontp->glyph[MAXCHARS]; ++g) {
  447.           g->addr = 0;
  448.           g->bitmap.bits = NULL;
  449.           g->bitmap2.bits = NULL;
  450. --- 149,155 ----
  451.     /*if (fontp->f_scale == 0) fontp->f_scale = 1000;*/
  452.       {
  453.           register struct glyph *g;
  454. !         for (g = fontp->glyph; g < fontp->glyph + 256; ++g) {
  455.           g->addr = 0;
  456.           g->bitmap.bits = NULL;
  457.           g->bitmap2.bits = NULL;
  458. ***************
  459. *** 173,183 ****
  460.           bytes_left = (flag_low_bits << 8) + one(fontp->file);
  461.           cc = one(fontp->file);
  462.           }
  463. - #if    MAXCHARS < 256
  464. -         if (cc >= MAXCHARS)
  465. -         oops("Character code %d outside range, file %s\n", cc,
  466. -             fontp->fontname);
  467. - #endif    MAXCHARS
  468.           fontp->glyph[cc].addr = ftell(fontp->file);
  469.           fontp->glyph[cc].x2 = PK_flag_byte;
  470.           Fseek(fontp->file, (long) bytes_left, 1);
  471. --- 175,180 ----
  472. ***************
  473. *** 185,192 ****
  474.   }
  475.   
  476.   static    void
  477. ! read_char(fp, ch)
  478. !     register struct font *fp;
  479.       ubyte ch;
  480.   {
  481.       int    i, j;
  482. --- 182,189 ----
  483.   }
  484.   
  485.   static    void
  486. ! read_char(fontp, ch)
  487. !     register struct font *fontp;
  488.       ubyte ch;
  489.   {
  490.       int    i, j;
  491. ***************
  492. *** 195,206 ****
  493.       Boolean    paint_switch;
  494.       BMUNIT    *cp;
  495.       register struct glyph *g;
  496.       long    fpwidth;
  497.       BMUNIT    word;
  498.       int    word_weight, bytes_wide;
  499.       int    rows_left, h_bit, count;
  500.   
  501. !   g = &fp->glyph[ch];
  502.     PK_flag_byte = g->x2;
  503.     PK_dyn_f = PK_flag_byte >> 4;
  504.     paint_switch = ((PK_flag_byte & 8) != 0);
  505. --- 192,204 ----
  506.       Boolean    paint_switch;
  507.       BMUNIT    *cp;
  508.       register struct glyph *g;
  509. +     register FILE *fp = fontp->file;
  510.       long    fpwidth;
  511.       BMUNIT    word;
  512.       int    word_weight, bytes_wide;
  513.       int    rows_left, h_bit, count;
  514.   
  515. !   g = &fontp->glyph[ch];
  516.     PK_flag_byte = g->x2;
  517.     PK_dyn_f = PK_flag_byte >> 4;
  518.     paint_switch = ((PK_flag_byte & 8) != 0);
  519. ***************
  520. *** 214,238 ****
  521.   
  522.       /* now read rest of character preamble */
  523.   
  524. !     if (n != 4) fpwidth = snum(fp->file, 3);
  525.       else {
  526. !     fpwidth = sfour(fp->file);
  527. !     (void) four(fp->file);    /* horizontal escapement */
  528.       }
  529. !     (void) num(fp->file, n);    /* vertical escapement */
  530.       {
  531.       unsigned long w, h;
  532. !     w = num(fp->file, n);
  533. !     h = num(fp->file, n);
  534.       if (w > 0x7fff || h > 0x7fff)
  535. !         oops("Too large character (%d) in file %s\n", ch, fp->fontname);
  536.       g->bitmap.w = w;
  537.       g->bitmap.h = h;
  538.       }
  539. !     g->x = snum(fp->file, n);
  540. !     g->y = snum(fp->file, n);
  541.   
  542. !     g->dvi_adv = ((double) fp->scale * fpwidth) / (1 << 20);
  543.   
  544.       if (debug & DBG_PK) {
  545.       if (g->bitmap.w != 0)
  546. --- 212,237 ----
  547.   
  548.       /* now read rest of character preamble */
  549.   
  550. !     if (n != 4) fpwidth = snum(fp, 3);
  551.       else {
  552. !     fpwidth = sfour(fp);
  553. !     (void) four(fp);    /* horizontal escapement */
  554.       }
  555. !     (void) num(fp, n);    /* vertical escapement */
  556.       {
  557.       unsigned long w, h;
  558. ! 
  559. !     w = num(fp, n);
  560. !     h = num(fp, n);
  561.       if (w > 0x7fff || h > 0x7fff)
  562. !         oops("Too large character (%d) in file %s\n", ch, fontp->fontname);
  563.       g->bitmap.w = w;
  564.       g->bitmap.h = h;
  565.       }
  566. !     g->x = snum(fp, n);
  567. !     g->y = snum(fp, n);
  568.   
  569. !     g->dvi_adv = ((double) fontp->scale * fpwidth) / (1 << 20);
  570.   
  571.       if (debug & DBG_PK) {
  572.       if (g->bitmap.w != 0)
  573. ***************
  574. *** 242,248 ****
  575.       }
  576.   
  577.       if (g->bitmap.w == 0) return;
  578. !     alloc_bitmap(&g->bitmap, fp->fontname, ch);
  579.       cp = (BMUNIT *) g->bitmap.bits;
  580.   /*
  581.    * read character data into *cp
  582. --- 241,247 ----
  583.       }
  584.   
  585.       if (g->bitmap.w == 0) return;
  586. !     alloc_bitmap(&g->bitmap, fontp->fontname, ch);
  587.       cp = (BMUNIT *) g->bitmap.bits;
  588.   /*
  589.    * read character data into *cp
  590. ***************
  591. *** 264,270 ****
  592.           {
  593.                     if (--PK_bitpos < 0)
  594.                       {
  595. !                       word = one(fp->file);
  596.                         PK_bitpos = 7;
  597.                       }
  598.   #ifndef    MSBITFIRST
  599. --- 263,269 ----
  600.           {
  601.                     if (--PK_bitpos < 0)
  602.                       {
  603. !                       word = one(fp);
  604.                         PK_bitpos = 7;
  605.                       }
  606.   #ifndef    MSBITFIRST
  607. ***************
  608. *** 357,364 ****
  609.           }
  610.         if (cp != ((BMUNIT *) (g->bitmap.bits + bytes_wide * g->bitmap.h)))
  611.           oops("Wrong number of bits stored:  char. %d, font %s\n", ch,
  612. !         fp->fontname);
  613.         if (rows_left != 0 || h_bit != g->bitmap.w)
  614. !         oops("Bad pk file (%s), too many bits\n", fp->fontname);
  615.       }
  616.   }
  617. --- 356,363 ----
  618.           }
  619.         if (cp != ((BMUNIT *) (g->bitmap.bits + bytes_wide * g->bitmap.h)))
  620.           oops("Wrong number of bits stored:  char. %d, font %s\n", ch,
  621. !         fontp->fontname);
  622.         if (rows_left != 0 || h_bit != g->bitmap.w)
  623. !         oops("Bad pk file (%s), too many bits\n", fontp->fontname);
  624.       }
  625.   }
  626. diff -cr old/pxl.c new/pxl.c
  627. *** old/pxl.c    Thu Jul 13 12:52:31 1989
  628. --- new/pxl.c    Sat Jul  8 15:23:15 1989
  629. ***************
  630. *** 56,85 ****
  631.           register struct font *fontp;
  632.   {
  633.       register struct glyph *g;
  634.           long font_dir_ptr;
  635.   
  636.       if (debug & DBG_PK)
  637.           Printf("Reading header for PXL file %s\n", fontp->filename);
  638.       fontp->read_char = read_char;
  639. !     if (four(fontp->file) != 1001)
  640.           oops("File %s has wrong PXL magic number.\n", fontp->filename);
  641.       /* seek to trailer info */
  642. !     Fseek(fontp->file, (long) -5 * 4, 2);
  643. !     (void) four(fontp->file);    /* checksum */
  644. !     (void) four(fontp->file);    /* magnify */
  645. !     (void) four(fontp->file);    /* design size */
  646. !         font_dir_ptr = sfour(fontp->file) * 4;
  647. !     (void) four(fontp->file);    /* pxl id word */
  648.       /* seek to font directory */
  649. !     Fseek(fontp->file, font_dir_ptr, 0);
  650. !     for (g = fontp->glyph; g < &fontp->glyph[128]; ++g) {
  651.           g->bitmap.bits = NULL;
  652.           g->bitmap2.bits = NULL;
  653. !         g->bitmap.w = two(fontp->file);
  654. !         g->bitmap.h = two(fontp->file);
  655. !         g->x = stwo(fontp->file);
  656. !         g->y = stwo(fontp->file);
  657. !         g->addr = four(fontp->file) * 4;
  658.           /*
  659.           **  The TFM-width word is kind of funny in the units
  660.           **  it is expressed in.  It works this way:
  661. --- 56,86 ----
  662.           register struct font *fontp;
  663.   {
  664.       register struct glyph *g;
  665. +     register FILE *fp;
  666.           long font_dir_ptr;
  667.   
  668.       if (debug & DBG_PK)
  669.           Printf("Reading header for PXL file %s\n", fontp->filename);
  670.       fontp->read_char = read_char;
  671. !     if (four(fp = fontp->file) != 1001)
  672.           oops("File %s has wrong PXL magic number.\n", fontp->filename);
  673.       /* seek to trailer info */
  674. !     Fseek(fp, (long) -5 * 4, 2);
  675. !     (void) four(fp);    /* checksum */
  676. !     (void) four(fp);    /* magnify */
  677. !     (void) four(fp);    /* design size */
  678. !         font_dir_ptr = sfour(fp) * 4;
  679. !     (void) four(fp);    /* pxl id word */
  680.       /* seek to font directory */
  681. !     Fseek(fp, font_dir_ptr, 0);
  682. !     for (g = fontp->glyph; g < fontp->glyph + 128; ++g) {
  683.           g->bitmap.bits = NULL;
  684.           g->bitmap2.bits = NULL;
  685. !         g->bitmap.w = two(fp);
  686. !         g->bitmap.h = two(fp);
  687. !         g->x = stwo(fp);
  688. !         g->y = stwo(fp);
  689. !         g->addr = four(fp) * 4;
  690.           /*
  691.           **  The TFM-width word is kind of funny in the units
  692.           **  it is expressed in.  It works this way:
  693. ***************
  694. *** 110,127 ****
  695.           */
  696.   
  697.           g->dvi_adv =
  698. !             ((double) fontp->scale * four(fontp->file)) / (1 << 20);
  699.           if (debug & DBG_PK)
  700.               Printf("size=%dx%d, dvi_adv=%d\n", g->bitmap.w, g->bitmap.h,
  701.               g->dvi_adv);
  702.       }
  703. ! #if    MAXCHARS > 128
  704. !     for ( ; g < &fontp->glyph[MAXCHARS]; ++g) {
  705. !         g->bitmap.bits = NULL;
  706. !         g->bitmap2.bits = NULL;
  707. !         g->addr = 0;
  708. !     }
  709. ! #endif    MAXCHARS
  710.   }
  711.   
  712.   static void
  713. --- 111,122 ----
  714.           */
  715.   
  716.           g->dvi_adv =
  717. !             ((double) fontp->scale * four(fp)) / (1 << 20);
  718.           if (debug & DBG_PK)
  719.               Printf("size=%dx%d, dvi_adv=%d\n", g->bitmap.w, g->bitmap.h,
  720.               g->dvi_adv);
  721.       }
  722. !     maxchar = 127;
  723.   }
  724.   
  725.   static void
  726. ***************
  727. *** 131,136 ****
  728. --- 126,132 ----
  729.   {
  730.       register struct bitmap *bitmap;
  731.       register BMUNIT *ptr;
  732. +     register FILE *fp = fontp->file;
  733.       register int i, j;
  734.   #ifndef    BMLONG
  735.       register int padding_length;
  736. ***************
  737. *** 146,174 ****
  738.       for (i = bitmap->h; i > 0; --i) {
  739.           for (j = bitmap->bytes_wide; j > 0; j -= BYTES_PER_BMUNIT) {
  740.   #ifndef    MSBITFIRST
  741. !         *ptr = _reverse_byte[one(fontp->file)];
  742.   #if    BYTES_PER_BMUNIT > 1
  743. !         *ptr |= _reverse_byte[one(fontp->file)] << 8;
  744.   #endif
  745.   #ifdef    BMLONG
  746. !         *ptr |= _reverse_byte[one(fontp->file)] << 16;
  747. !         *ptr |= _reverse_byte[one(fontp->file)] << 24;
  748.   #endif    BMLONG
  749.   #else    MSBITFIRST
  750.           *ptr = 0;
  751.   #ifdef    BMLONG
  752. !         *ptr |= one(fontp->file) << 24;
  753. !         *ptr |= one(fontp->file) << 16;
  754.   #endif    BMLONG
  755.   #if    BYTES_PER_BMUNIT > 1
  756. !         *ptr |= one(fontp->file) << 8;
  757.   #endif
  758. !         *ptr |= one(fontp->file);
  759.   #endif    MSBITFIRST
  760.           ++ptr;
  761.           }
  762.   #ifndef    BMLONG
  763. !         for (j = padding_length; j > 0; --j) (void) one(fontp->file);
  764.   #endif    BMLONG
  765.       }
  766.   }
  767. --- 142,170 ----
  768.       for (i = bitmap->h; i > 0; --i) {
  769.           for (j = bitmap->bytes_wide; j > 0; j -= BYTES_PER_BMUNIT) {
  770.   #ifndef    MSBITFIRST
  771. !         *ptr = _reverse_byte[one(fp)];
  772.   #if    BYTES_PER_BMUNIT > 1
  773. !         *ptr |= _reverse_byte[one(fp)] << 8;
  774.   #endif
  775.   #ifdef    BMLONG
  776. !         *ptr |= _reverse_byte[one(fp)] << 16;
  777. !         *ptr |= _reverse_byte[one(fp)] << 24;
  778.   #endif    BMLONG
  779.   #else    MSBITFIRST
  780.           *ptr = 0;
  781.   #ifdef    BMLONG
  782. !         *ptr |= one(fp) << 24;
  783. !         *ptr |= one(fp) << 16;
  784.   #endif    BMLONG
  785.   #if    BYTES_PER_BMUNIT > 1
  786. !         *ptr |= one(fp) << 8;
  787.   #endif
  788. !         *ptr |= one(fp);
  789.   #endif    MSBITFIRST
  790.           ++ptr;
  791.           }
  792.   #ifndef    BMLONG
  793. !         for (j = padding_length; j > 0; --j) (void) one(fp);
  794.   #endif    BMLONG
  795.       }
  796.   }
  797. diff -cr old/xdvi.c new/xdvi.c
  798. *** old/xdvi.c    Thu Jul 13 12:52:43 1989
  799. --- new/xdvi.c    Thu Jul 13 13:07:32 1989
  800. ***************
  801. *** 19,25 ****
  802.    *    MSBITFIRST    store bitmaps internally in with significant bit first
  803.    *    BMSHORT    store bitmaps in shorts instead of bytes
  804.    *    BMLONG    store bitmaps in longs instead of bytes
  805. -  *    MAXCHARS set to 256 for 256 character fonts (default = 128)
  806.    *    ALTFONT    default for -altfont option.
  807.    */
  808.   #ifndef lint
  809. --- 19,24 ----
  810. ***************
  811. *** 50,56 ****
  812.   #endif not OLD_X11_TOOLKIT
  813.   #include <X11/Shell.h>    /* needed for def. of XtNiconX */
  814.   #include <X11/Viewport.h>
  815. - #include <X11/Simple.h>
  816.   #include <X11/cursorfont.h>
  817.   #include "xdvi.icon"
  818.   
  819. --- 49,54 ----
  820. ***************
  821. *** 72,80 ****
  822.   static    Screen    *SCRN;
  823.   static    Cursor    redraw_cursor, ready_cursor;
  824.   #define    SetCursor(x)    XDefineCursor(DISP, mane.win, x)
  825. ! #define    ClearPage()    XClearWindow(DISP, mane.win);
  826.   #define    Flush()        XFlush(DISP)
  827. ! static    Boolean    unmapped = True;
  828.   #ifndef X11HEIGHT
  829.   #define    X11HEIGHT    8    /* Height of server default font */
  830.   #endif X11HEIGHT
  831. --- 70,82 ----
  832.   static    Screen    *SCRN;
  833.   static    Cursor    redraw_cursor, ready_cursor;
  834.   #define    SetCursor(x)    XDefineCursor(DISP, mane.win, x)
  835. ! #define    ClearPage(wr)    XClearWindow(DISP, (wr).win);
  836. ! #define    ClearArea(win, x, y, w, h)    XClearArea(DISP, win, x, y, w, h, False)
  837. ! #define    CopyArea(win, x, y, w, h, x2, y2) \
  838. !             XCopyArea(DISP, win, win, DefaultGCOfScreen(SCRN), \
  839. !                 x, y, w, h, x2, y2)
  840.   #define    Flush()        XFlush(DISP)
  841. ! static    Boolean    resized    = False;
  842.   #ifndef X11HEIGHT
  843.   #define    X11HEIGHT    8    /* Height of server default font */
  844.   #endif X11HEIGHT
  845. ***************
  846. *** 86,92 ****
  847.   typedef    int        Position;
  848.   typedef    int        Dimension;
  849.   #define    SetCursor(x)
  850. ! #define    ClearPage()    XClear(mane.win);
  851.   #define    XBell(a,b)    XFeep(b/10-1)
  852.   #define    Flush()        XFlush()
  853.   #define    ConnectionNumber(DISP)    (_XlibCurrentDisplay->fd)
  854. --- 88,97 ----
  855.   typedef    int        Position;
  856.   typedef    int        Dimension;
  857.   #define    SetCursor(x)
  858. ! #define    ClearPage(wr)    XClear((wr).win);
  859. ! #define    ClearArea(win, x, y, w, h)    XPixSet(win, x, y, w, h, backpix)
  860. ! #define    CopyArea(win, x, y, w, h, x2, y2) \
  861. !             XCopyArea(win, x, y, x2, y2, w, h, GXcopy);
  862.   #define    XBell(a,b)    XFeep(b/10-1)
  863.   #define    Flush()        XFlush()
  864.   #define    ConnectionNumber(DISP)    (_XlibCurrentDisplay->fd)
  865. ***************
  866. *** 143,156 ****
  867.   
  868.   int    page_w, page_h;
  869.   static    int    screen_w, screen_h;
  870.   static    Dimension    window_w, window_h;
  871.   static    int    home_x, home_y;
  872.   static    int    min_x, max_x, min_y, max_y;
  873.   
  874. ! struct WindowRec mane    = {NULL, 4, 0, 0, MAXINT, 0, MAXINT, 0};
  875. ! struct WindowRec alt    = {NULL, 1, 0, 0, MAXINT, 0, MAXINT, 0};
  876.   /*    curr is temporary storage except for within redraw() */
  877. ! struct WindowRec curr    = {NULL, 4, 0, 0, MAXINT, 0, MAXINT, 0};
  878.   
  879.   /*
  880.    *    Mechanism to keep track of the magnifier window.  The problems are,
  881. --- 148,173 ----
  882.   
  883.   int    page_w, page_h;
  884.   static    int    screen_w, screen_h;
  885. + #define    clip_w    mane.width
  886. + #define    clip_h    mane.height
  887. + #ifndef X10
  888.   static    Dimension    window_w, window_h;
  889. + static    Position    main_x, main_y;
  890. + #else X10
  891. + #define    window_w clip_w
  892. + #define    window_h clip_h
  893. + #define    main_x    0
  894. + #define    main_y    0
  895. + #endif X10
  896. + static    Position mag_x, mag_y, new_mag_x, new_mag_y;
  897. + static    Boolean    mag_moved = False;
  898.   static    int    home_x, home_y;
  899.   static    int    min_x, max_x, min_y, max_y;
  900.   
  901. ! struct WindowRec mane    = {NULL, 3, 0, 0, 0, 0, MAXDIM, 0, MAXDIM, 0};
  902. ! struct WindowRec alt    = {NULL, 1, 0, 0, 0, 0, MAXDIM, 0, MAXDIM, 0};
  903.   /*    curr is temporary storage except for within redraw() */
  904. ! struct WindowRec curr    = {NULL, 3, 0, 0, 0, 0, MAXDIM, 0, MAXDIM, 0};
  905.   
  906.   /*
  907.    *    Mechanism to keep track of the magnifier window.  The problems are,
  908. ***************
  909. *** 259,264 ****
  910. --- 276,282 ----
  911.   
  912.   #ifndef X10
  913.   static    Widget    top_level, vport_widget, draw_widget, clip_widget;
  914. + static    Widget    x_bar, y_bar;    /* horizontal and vertical scroll bars */
  915.   static    XImage    *image;
  916.   
  917.   static    Arg    vport_args[] = {
  918. ***************
  919. *** 289,295 ****
  920.   
  921.   #ifdef lint
  922.   #ifndef X10
  923. ! WidgetClass    viewportWidgetClass, simpleWidgetClass;
  924.   char    xdvi_bits[288];
  925.   #else X10
  926.   short    xdvi_bits[15], xdvi_mask_bits[15];
  927. --- 307,313 ----
  928.   
  929.   #ifdef lint
  930.   #ifndef X10
  931. ! WidgetClass    viewportWidgetClass, widgetClass;
  932.   char    xdvi_bits[288];
  933.   #else X10
  934.   short    xdvi_bits[15], xdvi_mask_bits[15];
  935. ***************
  936. *** 323,329 ****
  937.   {
  938.   
  939.       if (debug & DBG_BITMAP)
  940. !         Printf("X(%d,%d)\n", x-curr.base_x, y-curr.base_y);
  941.       if (x < max_x && x + bitmap->w >= min_x &&
  942.           y < max_y && y + bitmap->h >= min_y) {
  943.           if (--event_counter == 0) read_events(False);
  944. --- 341,347 ----
  945.   {
  946.   
  947.       if (debug & DBG_BITMAP)
  948. !         Printf("X(%d,%d)\n", x - curr.base_x, y - curr.base_y);
  949.       if (x < max_x && x + bitmap->w >= min_x &&
  950.           y < max_y && y + bitmap->h >= min_y) {
  951.           if (--event_counter == 0) read_events(False);
  952. ***************
  953. *** 358,363 ****
  954. --- 376,461 ----
  955.       put_rectangle(x + w - t, y, t, h, True);
  956.   }
  957.   
  958. + /*
  959. +  *    Event-handling routines
  960. +  */
  961. + 
  962. + static    void
  963. + expose(windowrec, x, y, w, h)
  964. +     register struct WindowRec *windowrec;
  965. +     int    x, y, w, h;
  966. + {
  967. +     if (windowrec->min_x > x) windowrec->min_x = x;
  968. +     if (windowrec->max_x < x + w)
  969. +         windowrec->max_x = x + w;
  970. +     if (windowrec->min_y > y) windowrec->min_y = y;
  971. +     if (windowrec->max_y < y + h)
  972. +         windowrec->max_y = y + h;
  973. + }
  974. + 
  975. + static    void
  976. + clearexpose(windowrec, x, y, w, h)
  977. +     struct WindowRec *windowrec;
  978. +     int    x, y, w, h;
  979. + {
  980. +     ClearArea(windowrec->win, x, y, w, h);
  981. +     expose(windowrec, x, y, w, h);
  982. + }
  983. + 
  984. + static    void
  985. + scrollwindow(windowrec, x0, y0)
  986. +     register struct WindowRec *windowrec;
  987. +     int    x0, y0;
  988. + {
  989. +     int    x, y;
  990. +     int    x2 = 0, y2 = 0;
  991. +     int    ww, hh;
  992. + 
  993. +     x = x0 - windowrec->base_x;
  994. +     y = y0 - windowrec->base_y;
  995. +     ww = windowrec->width - x;
  996. +     hh = windowrec->height - y;
  997. +     windowrec->base_x = x0;
  998. +     windowrec->base_y = y0;
  999. +     if (curr.win == windowrec->win) {
  1000. +         curr.base_x = x0;
  1001. +         curr.base_y = y0;
  1002. +     }
  1003. +     windowrec->min_x -= x;
  1004. +     if (windowrec->min_x < 0) windowrec->min_x = 0;
  1005. +     windowrec->max_x -= x;
  1006. +     if (windowrec->max_x > windowrec->width)
  1007. +         windowrec->max_x = windowrec->width;
  1008. +     windowrec->min_y -= y;
  1009. +     if (windowrec->min_y < 0) windowrec->min_y = 0;
  1010. +     windowrec->max_y -= y;
  1011. +     if (windowrec->max_y > windowrec->height)
  1012. +         windowrec->max_y = windowrec->height;
  1013. +     if (x < 0) {
  1014. +         x2 = -x;
  1015. +         x = 0;
  1016. +         ww = windowrec->width - x2;
  1017. +     }
  1018. +     if (y < 0) {
  1019. +         y2 = -y;
  1020. +         y = 0;
  1021. +         hh = windowrec->height - y2;
  1022. +     }
  1023. +     if (ww <= 0 || hh <= 0) {
  1024. +         ClearPage(*windowrec);
  1025. +         windowrec->min_x = windowrec->min_y = 0;
  1026. +         windowrec->max_x = windowrec->width;
  1027. +         windowrec->max_y = windowrec->height;
  1028. +     }
  1029. +     else {
  1030. +         CopyArea(windowrec->win, x, y, ww, hh, x2, y2);
  1031. +         if (x > 0) clearexpose(windowrec, ww, 0, x, windowrec->height);
  1032. +         if (x2 > 0) clearexpose(windowrec, 0, 0, x2, windowrec->height);
  1033. +         if (y > 0) clearexpose(windowrec, 0, hh, windowrec->width, y);
  1034. +         if (y2 > 0) clearexpose(windowrec, 0, 0, windowrec->width, y2);
  1035. +     }
  1036. + }
  1037. + 
  1038.   #ifndef X10
  1039.   /*
  1040.    *    routines for X11 toolkit
  1041. ***************
  1042. *** 368,374 ****
  1043.       {XtNheight,    (XtArgVal) &window_h},
  1044.   };
  1045.   
  1046. ! #define    get_wh(widget)    XtGetValues(widget, arg_wh, 2)
  1047.   
  1048.   static    Position    window_x, window_y;
  1049.   static    Arg        arg_xy[] = {
  1050. --- 466,475 ----
  1051.       {XtNheight,    (XtArgVal) &window_h},
  1052.   };
  1053.   
  1054. ! static    Arg    arg_wh_clip[] = {
  1055. !     {XtNwidth,    (XtArgVal) &clip_w},
  1056. !     {XtNheight,    (XtArgVal) &clip_h},
  1057. ! };
  1058.   
  1059.   static    Position    window_x, window_y;
  1060.   static    Arg        arg_xy[] = {
  1061. ***************
  1062. *** 381,461 ****
  1063.   #define    mane_base_x    0
  1064.   #define    mane_base_y    0
  1065.   
  1066. ! static    Boolean
  1067. ! scroll(horizontal, percent)
  1068. !     Boolean    horizontal;
  1069. !     float    percent;
  1070. ! {
  1071. !     register Widget    widget;
  1072. ! 
  1073. !     widget = XtNameToWidget(vport_widget,
  1074. !         horizontal ? "horizontal" : "vertical");
  1075. !     if (!widget) return False;
  1076. !     XtGetValues(clip_widget, horizontal ? &arg_wh[0] : &arg_wh[1], 1);
  1077. !     XtCallCallbacks(widget, XtNscrollProc,
  1078. !         (int) (percent*(horizontal ? window_w : window_h)));
  1079. !     return True;
  1080. ! }
  1081. ! 
  1082. ! /*
  1083. !  *    We unmap the window so that it does not generate expose events when
  1084. !  *    moving things around.  I have found that compress_exposure does not do
  1085. !  *    this.
  1086. !  */
  1087. ! 
  1088.   static
  1089. ! unmap()
  1090.   {
  1091. -     if (unmapped) return;
  1092. -     XUnmapWindow(DISP, mane.win);
  1093. -     unmapped = True;
  1094. - }
  1095. - 
  1096. - static
  1097. - home()
  1098. - {
  1099. -     register Widget    widget;
  1100.       register int coord;
  1101.   
  1102. -     unmap();
  1103.       get_xy();
  1104. !     get_wh(clip_widget);
  1105. !     widget = XtNameToWidget(vport_widget, "horizontal");
  1106. !     if (widget) {
  1107.           coord = 0;
  1108. !         if (page_w > window_w) {
  1109. !         coord = (page_w - window_w) / 2;
  1110.           if (coord > home_x / mane.shrinkfactor)
  1111.               coord = home_x / mane.shrinkfactor;
  1112.           }
  1113. !         XtCallCallbacks(widget, XtNscrollProc, window_x + coord);
  1114.       }
  1115. !     widget = XtNameToWidget(vport_widget, "vertical");
  1116. !     if (widget) {
  1117.           coord = 0;
  1118. !         if (page_h > window_h) {
  1119. !         coord = (page_h - window_h) / 2;
  1120.           if (coord > home_y / mane.shrinkfactor)
  1121.               coord = home_y / mane.shrinkfactor;
  1122.           }
  1123. !         XtCallCallbacks(widget, XtNscrollProc, window_y + coord);
  1124.       }
  1125.   }
  1126.   
  1127.   static    void
  1128.   center(x, y)
  1129.       int x, y;
  1130.   {
  1131. -     register Widget widget;
  1132. - 
  1133.   /*    We use the clip widget here because it gives a more exact value. */
  1134. !     get_wh(clip_widget);
  1135. !     x -= window_w/2;
  1136. !     y -= window_h/2;
  1137. !     widget = XtNameToWidget(vport_widget, "horizontal");
  1138. !     if (widget) XtCallCallbacks(widget, XtNscrollProc, x);
  1139. !     widget = XtNameToWidget(vport_widget, "vertical");
  1140. !     if (widget) XtCallCallbacks(widget, XtNscrollProc, y);
  1141.       XWarpPointer(DISP, None, None, 0, 0, 0, 0, -x, -y);
  1142.   }
  1143.   
  1144. --- 482,536 ----
  1145.   #define    mane_base_x    0
  1146.   #define    mane_base_y    0
  1147.   
  1148. ! #define    home(x)    Xtk_home()
  1149.   static
  1150. ! Xtk_home()
  1151.   {
  1152.       register int coord;
  1153.   
  1154.       get_xy();
  1155. !     if (x_bar) {
  1156.           coord = 0;
  1157. !         if (page_w > clip_w) {
  1158. !         coord = (page_w - clip_w) / 2;
  1159.           if (coord > home_x / mane.shrinkfactor)
  1160.               coord = home_x / mane.shrinkfactor;
  1161.           }
  1162. !         XtCallCallbacks(x_bar, XtNscrollProc, window_x + coord);
  1163.       }
  1164. !     if (y_bar) {
  1165.           coord = 0;
  1166. !         if (page_h > clip_h) {
  1167. !         coord = (page_h - clip_h) / 2;
  1168.           if (coord > home_y / mane.shrinkfactor)
  1169.               coord = home_y / mane.shrinkfactor;
  1170.           }
  1171. !         XtCallCallbacks(y_bar, XtNscrollProc, window_y + coord);
  1172.       }
  1173.   }
  1174.   
  1175. + static
  1176. + get_geom()
  1177. + {
  1178. +     register Dimension old_clip_w = clip_w;
  1179. + 
  1180. +     XtGetValues(vport_widget, arg_wh, 2);
  1181. +     XtGetValues(clip_widget, arg_wh_clip, 2);
  1182. +     x_bar = XtNameToWidget(vport_widget, "horizontal");
  1183. +     y_bar = XtNameToWidget(vport_widget, "vertical");
  1184. +     if (old_clip_w == 0) home(False);
  1185. +     resized = False;
  1186. + }
  1187. + 
  1188.   static    void
  1189.   center(x, y)
  1190.       int x, y;
  1191.   {
  1192.   /*    We use the clip widget here because it gives a more exact value. */
  1193. !     x -= clip_w/2;
  1194. !     y -= clip_h/2;
  1195. !     if (x_bar) XtCallCallbacks(x_bar, XtNscrollProc, x);
  1196. !     if (y_bar) XtCallCallbacks(y_bar, XtNscrollProc, y);
  1197.       XWarpPointer(DISP, None, None, 0, 0, 0, 0, -x, -y);
  1198.   }
  1199.   
  1200. ***************
  1201. *** 473,498 ****
  1202.   {
  1203.       XBell(DISP, 20);
  1204.   }
  1205.   #else X10
  1206. ! static
  1207. ! home()
  1208.   {
  1209. !     mane.base_x = 0;
  1210. !     if (page_w > window_w) {
  1211. !         mane.base_x = (page_w - window_w) / 2;
  1212. !         if (mane.base_x > home_x / mane.shrinkfactor)
  1213. !         mane.base_x = home_x / mane.shrinkfactor;
  1214.       }
  1215. !     mane.base_y = 0;
  1216. !     if (page_h > window_h) {
  1217. !         mane.base_y = (page_h - window_h) / 2;
  1218. !         if (mane.base_y > home_y / mane.shrinkfactor)
  1219. !         mane.base_y = home_y / mane.shrinkfactor;
  1220.       }
  1221.   }
  1222.   
  1223. - #define    unmap()
  1224. - #define    get_wh(widget)
  1225.   #define    get_xy()
  1226.   #define    window_x 0
  1227.   #define    window_y 0
  1228. --- 548,593 ----
  1229.   {
  1230.       XBell(DISP, 20);
  1231.   }
  1232. + 
  1233. +     /*ARGSUSED*/
  1234. + static    void
  1235. + handle_resize(widget, junk, event)
  1236. +     Widget    widget;
  1237. +     caddr_t    junk;
  1238. +     XEvent    *event;
  1239. + {
  1240. +     resized = True;
  1241. + }
  1242. + 
  1243.   #else X10
  1244. ! static    void
  1245. ! home(scrl)
  1246. !     Boolean    scrl;
  1247.   {
  1248. !     int    x = 0, y = 0;
  1249. ! 
  1250. !     if (page_w > clip_w) {
  1251. !         x = (page_w - clip_w) / 2;
  1252. !         if (x > home_x / mane.shrinkfactor)
  1253. !         x = home_x / mane.shrinkfactor;
  1254.       }
  1255. !     if (page_h > clip_h) {
  1256. !         y = (page_h - clip_h) / 2;
  1257. !         if (y > home_y / mane.shrinkfactor)
  1258. !         y = home_y / mane.shrinkfactor;
  1259.       }
  1260. +     if (scrl)
  1261. +         scrollwindow(&mane, x, y);
  1262. +     else {
  1263. +         mane.base_x = x;
  1264. +         mane.base_y = y;
  1265. +         if (curr.win == mane.win) {
  1266. +         curr.base_x = x;
  1267. +         curr.base_y = y;
  1268. +         }
  1269. +     }
  1270.   }
  1271.   
  1272.   #define    get_xy()
  1273.   #define    window_x 0
  1274.   #define    window_y 0
  1275. ***************
  1276. *** 500,506 ****
  1277. --- 595,629 ----
  1278.   #define    mane_base_y    mane.base_y
  1279.   #endif X10
  1280.   
  1281. + static    void
  1282. + compute_mag_pos(xp, yp)
  1283. +     int    *xp, *yp;
  1284. + {
  1285. +     register int t;
  1286. + 
  1287. +     t = mag_x + main_x - alt.width/2;
  1288.   #ifndef X10
  1289. +     if (t > WidthOfScreen(SCRN) - alt.width - 2*MAGBORD)
  1290. +         t = WidthOfScreen(SCRN) - alt.width - 2*MAGBORD;
  1291. + #else X10
  1292. +     if (t > window_w - alt.width - 2*MAGBORD)
  1293. +         t = window_w - alt.width - 2*MAGBORD;
  1294. + #endif X10
  1295. +     if (t < 0) t = 0;
  1296. +     *xp = t;
  1297. +     t = mag_y + main_y - alt.height/2;
  1298. + #ifndef X10
  1299. +     if (t > HeightOfScreen(SCRN) - alt.height - 2*MAGBORD)
  1300. +         t = HeightOfScreen(SCRN) - alt.height - 2*MAGBORD;
  1301. + #else X10
  1302. +     if (t > window_h - alt.height - 2*MAGBORD)
  1303. +         t = window_h - alt.height - 2*MAGBORD;
  1304. + #endif X10
  1305. +     if (t < 0) t = 0;
  1306. +     *yp = t;
  1307. + }
  1308. + 
  1309. + #ifndef X10
  1310.       /*ARGSUSED*/
  1311.   static    void
  1312.   handle_button(widget, junk, event)
  1313. ***************
  1314. *** 509,565 ****
  1315.       XButtonEvent *event;
  1316.   #else X10
  1317.   static    void
  1318. ! handle_button(event, mag_size)
  1319.       XButtonPressedEvent *event;
  1320. -     int mag_size;
  1321.   #endif X10
  1322.   {
  1323.       int x, y;
  1324.   #ifndef X10
  1325. -     int mag_size = mg_size[event->button - 1];
  1326.       XSetWindowAttributes attr;
  1327. - #endif X10
  1328.   
  1329. !     if (alt.win != NULL || mane.shrinkfactor == 1 || mag_size <= 0)
  1330.           XBell(DISP, 20);
  1331.       else {
  1332.   #ifndef X10
  1333. !         x = event->x_root - mag_size/2;
  1334. !         if (x > WidthOfScreen(SCRN) - mag_size - 2*MAGBORD)
  1335. !         x = WidthOfScreen(SCRN) - mag_size - 2*MAGBORD;
  1336. !         if (x < 0) x = 0;
  1337. !         y = event->y_root - mag_size/2;
  1338. !         if (y > HeightOfScreen(SCRN) - mag_size - 2*MAGBORD)
  1339. !         y = HeightOfScreen(SCRN) - mag_size - 2*MAGBORD;
  1340. !         if (y < 0) y = 0;
  1341. ! #else X10
  1342. !         x = event->x - mag_size/2;
  1343. !         if (x > window_w - mag_size - 2*MAGBORD)
  1344. !         x = window_w - mag_size - 2*MAGBORD;
  1345. !         if (x < 0) x = 0;
  1346. !         y = event->y - mag_size/2;
  1347. !         if (y > window_h - mag_size - 2*MAGBORD)
  1348. !         y = window_h - mag_size - 2*MAGBORD;
  1349. !         if (y < 0) y = 0;
  1350.   #endif X10
  1351.           alt.base_x = (event->x + mane_base_x) * mane.shrinkfactor -
  1352. !         mag_size/2;
  1353.           alt.base_y = (event->y + mane_base_y) * mane.shrinkfactor -
  1354. !         mag_size/2;
  1355.   #ifndef X10
  1356.           attr.save_under = True;
  1357.           attr.border_pixel = fore_args.value;
  1358.           attr.background_pixel = back_args.value;
  1359.           alt.win = XCreateWindow(DISP, RootWindowOfScreen(SCRN),
  1360. !             x, y, mag_size, mag_size, MAGBORD,
  1361.               0,    /* depth from parent */
  1362.               InputOutput, CopyFromParent,
  1363. !             CWSaveUnder|CWBorderPixel|CWBackPixel, &attr);
  1364. !         XSetTransientForHint(DISP, alt.win, XtWindow(top_level));
  1365.           XSelectInput(DISP, alt.win, ExposureMask);
  1366.   #else X10
  1367.           alt.win = XCreateWindow(mane.win,
  1368. !             x, y, mag_size, mag_size, MAGBORD,
  1369.               bdrmap, backmap);
  1370.           XSelectInput(alt.win, ExposeRegion);
  1371.   #endif X10
  1372. --- 632,676 ----
  1373.       XButtonEvent *event;
  1374.   #else X10
  1375.   static    void
  1376. ! handle_button(event)
  1377.       XButtonPressedEvent *event;
  1378.   #endif X10
  1379.   {
  1380.       int x, y;
  1381.   #ifndef X10
  1382.       XSetWindowAttributes attr;
  1383.   
  1384. !     alt.width = alt.height = mg_size[event->button - 1];
  1385. ! #endif X10
  1386. !     if (alt.win != NULL || mane.shrinkfactor == 1 || alt.width <= 0)
  1387.           XBell(DISP, 20);
  1388.       else {
  1389. +         mag_x = event->x;
  1390. +         mag_y = event->y;
  1391.   #ifndef X10
  1392. !         main_x = event->x_root - mag_x;
  1393. !         main_y = event->y_root - mag_y;
  1394.   #endif X10
  1395. +         compute_mag_pos(&x, &y);
  1396.           alt.base_x = (event->x + mane_base_x) * mane.shrinkfactor -
  1397. !         alt.width/2;
  1398.           alt.base_y = (event->y + mane_base_y) * mane.shrinkfactor -
  1399. !         alt.height/2;
  1400.   #ifndef X10
  1401.           attr.save_under = True;
  1402.           attr.border_pixel = fore_args.value;
  1403.           attr.background_pixel = back_args.value;
  1404. +         attr.override_redirect = True;
  1405.           alt.win = XCreateWindow(DISP, RootWindowOfScreen(SCRN),
  1406. !             x, y, alt.width, alt.height, MAGBORD,
  1407.               0,    /* depth from parent */
  1408.               InputOutput, CopyFromParent,
  1409. !             CWSaveUnder | CWBorderPixel | CWBackPixel |
  1410. !             CWOverrideRedirect, &attr);
  1411.           XSelectInput(DISP, alt.win, ExposureMask);
  1412.   #else X10
  1413.           alt.win = XCreateWindow(mane.win,
  1414. !             x, y, alt.width, alt.height, MAGBORD,
  1415.               bdrmap, backmap);
  1416.           XSelectInput(alt.win, ExposeRegion);
  1417.   #endif X10
  1418. ***************
  1419. *** 571,576 ****
  1420. --- 682,718 ----
  1421.   #ifndef X10
  1422.       /*ARGSUSED*/
  1423.   static    void
  1424. + handle_motion(widget, junk, event)
  1425. +     Widget    widget;
  1426. +     caddr_t    junk;
  1427. +     XMotionEvent *event;
  1428. + {
  1429. +     new_mag_x = event->x;
  1430. +     main_x = event->x_root - new_mag_x;
  1431. +     new_mag_y = event->y;
  1432. +     main_y = event->y_root - new_mag_y;
  1433. +     mag_moved = (new_mag_x != mag_x || new_mag_y != mag_y);
  1434. + }
  1435. + #endif X10
  1436. + 
  1437. + static    void
  1438. + movemag(x, y)
  1439. +     int    x, y;
  1440. + {
  1441. +     int    xx, yy;
  1442. + 
  1443. +     mag_x = x;
  1444. +     mag_y = y;
  1445. +     if (mag_x == new_mag_x && mag_y == new_mag_y) mag_moved = False;
  1446. +     compute_mag_pos(&xx, &yy);
  1447. +     XMoveWindow(DPY alt.win, xx, yy);
  1448. +     scrollwindow(&alt, (x + mane_base_x) * mane.shrinkfactor - alt.width/2,
  1449. +         (y + mane_base_y) * mane.shrinkfactor - alt.height/2);
  1450. + }
  1451. + 
  1452. + #ifndef X10
  1453. +     /*ARGSUSED*/
  1454. + static    void
  1455.   handle_release(widget, junk, event)
  1456.       Widget    widget;
  1457.       caddr_t    junk;
  1458. ***************
  1459. *** 586,591 ****
  1460. --- 728,734 ----
  1461.           XDestroyWindow(DPY alt.win);
  1462.           if (curr.win == alt.win) alt_canit = True;
  1463.           alt.win = NULL;
  1464. +         mag_moved = False;
  1465.           can_exposures(&alt);
  1466.           }
  1467.   }
  1468. ***************
  1469. *** 606,617 ****
  1470.           }
  1471.           else
  1472.           alt_stat = 0;
  1473. !     if (windowrec->min_x > event->x) windowrec->min_x = event->x;
  1474. !     if (windowrec->max_x < event->x + event->width)
  1475. !         windowrec->max_x = event->x + event->width;
  1476. !     if (windowrec->min_y > event->y) windowrec->min_y = event->y;
  1477. !     if (windowrec->max_y < event->y + event->height)
  1478. !         windowrec->max_y = event->y + event->height;
  1479.   }
  1480.   #endif X10
  1481.   
  1482. --- 749,755 ----
  1483.           }
  1484.           else
  1485.           alt_stat = 0;
  1486. !     expose(windowrec, event->x, event->y, event->width, event->height);
  1487.   }
  1488.   #endif X10
  1489.   
  1490. ***************
  1491. *** 643,654 ****
  1492.            * Also, watch out, if we destroy the magnifying glass while
  1493.            * writing it.
  1494.            */
  1495. !         if (!XtPending() && (!wait || canit || mane.min_x < MAXINT ||
  1496. !             alt.min_x < MAXINT))
  1497.           if (alt_canit) longjmp(canit_env, 1);
  1498.           else return;
  1499.   #ifndef X10
  1500.           XtNextEvent(&event);
  1501.           if (event.xany.window == alt.win &&
  1502.               event.type == Expose) {
  1503.           handle_exp((Widget) NULL, &alt, &event.xexpose);
  1504. --- 781,793 ----
  1505.            * Also, watch out, if we destroy the magnifying glass while
  1506.            * writing it.
  1507.            */
  1508. !         if (!XtPending() && (!wait || canit || mane.min_x < MAXDIM ||
  1509. !             alt.min_x < MAXDIM || mag_moved))
  1510.           if (alt_canit) longjmp(canit_env, 1);
  1511.           else return;
  1512.   #ifndef X10
  1513.           XtNextEvent(&event);
  1514. +         if (resized) get_geom();
  1515.           if (event.xany.window == alt.win &&
  1516.               event.type == Expose) {
  1517.           handle_exp((Widget) NULL, &alt, &event.xexpose);
  1518. ***************
  1519. *** 667,685 ****
  1520.           switch (event.type) {
  1521.           case ExposeWindow:
  1522.           if (event.window == mane.win) {
  1523. !             window_h = ((XExposeEvent *)(&event))->height;
  1524. !             window_w = ((XExposeEvent *)(&event))->width;
  1525. !             home();
  1526. !             ch = '\f';
  1527. !             break;
  1528. !         }
  1529. !         /* otherwise control passes through */
  1530.   
  1531.           case ExposeRegion:
  1532.               /* check in case we already destroyed the window */
  1533.           if (event.window == mane.win || alt.win != NULL) {
  1534.               struct WindowRec *wr =
  1535.               (event.window == mane.win ? &mane : &alt);
  1536.               if (wr == &alt)
  1537.               if (alt_stat < 0) { /* destroy upon exposure */
  1538.                   alt_stat = 0;
  1539. --- 806,824 ----
  1540.           switch (event.type) {
  1541.           case ExposeWindow:
  1542.           if (event.window == mane.win) {
  1543. !             register Dimension old_clip_w = clip_w;
  1544.   
  1545. +             window_w = ((XExposeEvent *) &event)->width;
  1546. +             window_h = ((XExposeEvent *) &event)->height;
  1547. +             if (old_clip_w == 0) home(False);
  1548. +         }
  1549. +         /* control falls through */
  1550.           case ExposeRegion:
  1551.               /* check in case we already destroyed the window */
  1552.           if (event.window == mane.win || alt.win != NULL) {
  1553.               struct WindowRec *wr =
  1554.               (event.window == mane.win ? &mane : &alt);
  1555. + 
  1556.               if (wr == &alt)
  1557.               if (alt_stat < 0) { /* destroy upon exposure */
  1558.                   alt_stat = 0;
  1559. ***************
  1560. *** 688,713 ****
  1561.               }
  1562.               else
  1563.                   alt_stat = 0;
  1564. ! #define    ev        ((XExposeEvent *)(&event))
  1565. !             if (wr->min_x > ev->x) wr->min_x = ev->x;
  1566. !             if (wr->max_x < ev->x + ev->width)
  1567. !             wr->max_x = ev->x + ev->width;
  1568. !             if (wr->min_y > ev->y) wr->min_y = ev->y;
  1569. !             if (wr->max_y < ev->y + ev->height)
  1570. !             wr->max_y = ev->y + ev->height;
  1571. ! #undef    ev
  1572.           }
  1573.           break;
  1574.   
  1575.           case ButtonPressed: {
  1576. !             int n = 0;
  1577. !             switch (((XButtonPressedEvent *) (&event))->detail &
  1578.                   ValueMask) {
  1579. -             case LeftButton:  n=0; break;
  1580.               case MiddleButton:  n=1; break;
  1581.               case RightButton:  n=2; break;
  1582.               }
  1583. !             handle_button((XButtonPressedEvent *) (&event), mg_size[n]);
  1584.           }
  1585.           break;
  1586.           case ButtonReleased:
  1587. --- 827,864 ----
  1588.               }
  1589.               else
  1590.                   alt_stat = 0;
  1591. !             if (((XExposeEvent *) &event)->detail & ExposeCopy)
  1592. !             ClearArea(event.window,
  1593. !                 ((XExposeEvent *) &event)->x,
  1594. !                 ((XExposeEvent *) &event)->y,
  1595. !                 ((XExposeEvent *) &event)->width,
  1596. !                 ((XExposeEvent *) &event)->height);
  1597. !             expose(wr, ((XExposeEvent *) &event)->x,
  1598. !             ((XExposeEvent *) &event)->y,
  1599. !             ((XExposeEvent *) &event)->width,
  1600. !             ((XExposeEvent *) &event)->height);
  1601.           }
  1602. +         case ExposeCopy:    /* throw away junk event */
  1603.           break;
  1604.   
  1605. +         case MouseMoved:
  1606. +         case LeftDownMotion:
  1607. +         case MiddleDownMotion:
  1608. +         case RightDownMotion:
  1609. +         new_mag_x = ((XMouseMovedEvent *) &event)->x;
  1610. +         new_mag_y = ((XMouseMovedEvent *) &event)->y;
  1611. +         mag_moved = (new_mag_x != mag_x || new_mag_y != mag_y);
  1612. +         break;
  1613. + 
  1614.           case ButtonPressed: {
  1615. !             register int n = 0;
  1616. !             switch (((XButtonPressedEvent *) &event)->detail &
  1617.                   ValueMask) {
  1618.               case MiddleButton:  n=1; break;
  1619.               case RightButton:  n=2; break;
  1620.               }
  1621. !             alt.width = alt.height = mg_size[n];
  1622. !             handle_button((XButtonPressedEvent *) &event);
  1623.           }
  1624.           break;
  1625.           case ButtonReleased:
  1626. ***************
  1627. *** 718,723 ****
  1628. --- 869,877 ----
  1629.           if (nbytes > 1) goto bad;
  1630.           if (nbytes != 0) ch = *string;
  1631.           break;
  1632. + /*MouseMoved */
  1633. +         default:
  1634. +         Fprintf(stderr, "???:  %x\n", event.type);
  1635.           }
  1636.   #endif X10
  1637.           if (ch == '\0') continue;
  1638. ***************
  1639. *** 771,791 ****
  1640.               /* redisplay current page */
  1641.               break;
  1642.           case '^':
  1643. !             home();
  1644. !             break;
  1645. ! #ifndef X10
  1646. !         case 'u':
  1647. !             if (!scroll(False, -0.67)) goto bad;
  1648.               continue;
  1649. !         case 'd':
  1650. !             if (!scroll(False, 0.67)) goto bad;
  1651. !             continue;
  1652.           case 'l':
  1653. !             if (!scroll(True, -0.67)) goto bad;
  1654.               continue;
  1655.           case 'r':
  1656. !             if (!scroll(True, 0.67)) goto bad;
  1657.               continue;
  1658.           case 'c':
  1659.               center(event.xkey.x, event.xkey.y);
  1660.               continue;
  1661. --- 925,953 ----
  1662.               /* redisplay current page */
  1663.               break;
  1664.           case '^':
  1665. !             home(True);
  1666.               continue;
  1667. ! #ifndef X10
  1668.           case 'l':
  1669. !             if (!x_bar) goto bad;
  1670. !             XtCallCallbacks(x_bar, XtNscrollProc,
  1671. !             -2 * (int) clip_w / 3);
  1672.               continue;
  1673.           case 'r':
  1674. !             if (!x_bar) goto bad;
  1675. !             XtCallCallbacks(x_bar, XtNscrollProc,
  1676. !             2 * (int) clip_w / 3);
  1677.               continue;
  1678. +         case 'u':
  1679. +             if (!y_bar) goto bad;
  1680. +             XtCallCallbacks(y_bar, XtNscrollProc,
  1681. +             -2 * (int) clip_h / 3);
  1682. +             continue;
  1683. +         case 'd':
  1684. +             if (!y_bar) goto bad;
  1685. +             XtCallCallbacks(y_bar, XtNscrollProc,
  1686. +             2 * (int) clip_h / 3);
  1687. +             continue;
  1688.           case 'c':
  1689.               center(event.xkey.x, event.xkey.y);
  1690.               continue;
  1691. ***************
  1692. *** 802,837 ****
  1693.               ImageByteOrder(DISP));
  1694.               continue;
  1695.   #else X10
  1696. -         case 'u':
  1697. -             if (mane.base_y == 0) goto bad;
  1698. -             mane.base_y -= window_h;
  1699. -             if (mane.base_y < 0)
  1700. -             mane.base_y = 0;
  1701. -             break;
  1702. -         case 'd':
  1703. -             if (mane.base_y >= page_h - window_h) goto bad;
  1704. -             mane.base_y += window_h;
  1705. -             if (mane.base_y > page_h - window_h)
  1706. -             mane.base_y = page_h - window_h;
  1707. -             break;
  1708.           case 'l':
  1709.               if (mane.base_x == 0) goto bad;
  1710. !             mane.base_x -= window_w;
  1711. !             if (mane.base_x < 0)
  1712. !             mane.base_x = 0;
  1713. !             break;
  1714.           case 'r':
  1715. !             if (mane.base_x >= page_w - window_w) goto bad;
  1716. !             mane.base_x += window_w;
  1717. !             if (mane.base_x > page_w - window_w)
  1718. !             mane.base_x = page_w - window_w;
  1719. !             break;
  1720.           case 'c':
  1721. ! #define    ev        ((XKeyPressedEvent *) (&event))
  1722. !             mane.base_x += ev->x - window_w/2;
  1723. !             mane.base_y += ev->y - window_h/2;
  1724.               XWarpMouse(mane.win, window_w/2, window_h/2, 3);
  1725. !             break;
  1726.           case 'M':
  1727.               home_x = (ev->x + mane.base_x) * mane.shrinkfactor;
  1728.               home_y = (ev->y + mane.base_y) * mane.shrinkfactor;
  1729. --- 964,999 ----
  1730.               ImageByteOrder(DISP));
  1731.               continue;
  1732.   #else X10
  1733.           case 'l':
  1734.               if (mane.base_x == 0) goto bad;
  1735. !             number0 = mane.base_x - 2 * clip_w / 3;
  1736. !             if (number0 < 0) number0 = 0;
  1737. !             scrollwindow(&mane, number0, mane.base_y);
  1738. !             continue;
  1739.           case 'r':
  1740. !             number0 = mane.base_x + 2 * clip_w / 3;
  1741. !             if (number0 > page_w - clip_w) number0 = page_w - clip_w;
  1742. !             if (number0 == mane.base_x) goto bad;
  1743. !             scrollwindow(&mane, number0, mane.base_y);
  1744. !             continue;
  1745. !         case 'u':
  1746. !             if (mane.base_y == 0) goto bad;
  1747. !             number0 = mane.base_y - 2 * clip_h / 3;
  1748. !             if (number0 < 0) number0 = 0;
  1749. !             scrollwindow(&mane, mane.base_x, number0);
  1750. !             continue;
  1751. !         case 'd':
  1752. !             number0 = mane.base_y + 2 * clip_h / 3;
  1753. !             if (number0 > page_h - clip_h) number0 = page_h - clip_h;
  1754. !             if (number0 == mane.base_y) goto bad;
  1755. !             scrollwindow(&mane, mane.base_x, number0);
  1756. !             continue;
  1757.           case 'c':
  1758. ! #define    ev        ((XKeyPressedEvent *) &event)
  1759. !             scrollwindow(&mane, mane.base_x + ev->x - window_w/2,
  1760. !             mane.base_y + ev->y - window_h/2);
  1761.               XWarpMouse(mane.win, window_w/2, window_h/2, 3);
  1762. !             continue;
  1763.           case 'M':
  1764.               home_x = (ev->x + mane.base_x) * mane.shrinkfactor;
  1765.               home_y = (ev->y + mane.base_y) * mane.shrinkfactor;
  1766. ***************
  1767. *** 842,848 ****
  1768.               if (!arg0) {
  1769.               long fac1, fac2;
  1770.               shrink_factor = 1;
  1771. -             get_wh(vport_widget);
  1772.               fac1 = ROUNDUP(PAPER_WIDTH, window_w);
  1773.               fac2 = ROUNDUP(PAPER_HEIGHT, window_h);
  1774.               if (fac1 < fac2)
  1775. --- 1004,1009 ----
  1776. ***************
  1777. *** 853,859 ****
  1778.               if (number0 <= 0) goto bad;
  1779.               if (number0 == mane.shrinkfactor) continue;
  1780.               shrink_factor = mane.shrinkfactor = number0;
  1781. -             unmap();
  1782.               init_page();
  1783.               if (number0 != 1 && number0 != bak_shrink) {
  1784.               bak_shrink = number0;
  1785. --- 1014,1019 ----
  1786. ***************
  1787. *** 860,870 ****
  1788.               reset_fonts();
  1789.               }
  1790.   #ifndef X10
  1791.               set_draw_args();
  1792.               XtSetValues(draw_widget, draw_args, 2);
  1793. ! #endif X10
  1794. !             home();
  1795.               break;
  1796.           case 'S':
  1797.               if (!arg0) goto bad;
  1798.               if (number0 < 0) goto bad;
  1799. --- 1020,1036 ----
  1800.               reset_fonts();
  1801.               }
  1802.   #ifndef X10
  1803. +             XUnmapWindow(DISP, mane.win);
  1804.               set_draw_args();
  1805.               XtSetValues(draw_widget, draw_args, 2);
  1806. !             get_geom();
  1807. !             home(False);
  1808. !             XMapWindow(DISP, mane.win);
  1809. !             continue;
  1810. ! #else X10
  1811. !             home(False);
  1812.               break;
  1813. + #endif X10
  1814.           case 'S':
  1815.               if (!arg0) goto bad;
  1816.               if (number0 < 0) goto bad;
  1817. ***************
  1818. *** 872,878 ****
  1819.               density = number0;
  1820.               reset_fonts();
  1821.               if (mane.shrinkfactor == 1) continue;
  1822. -             unmap();
  1823.               break;
  1824.           case 'R':
  1825.               /* reread DVI file */
  1826. --- 1038,1043 ----
  1827. ***************
  1828. *** 885,891 ****
  1829.           if (current_page != next_page) {
  1830.               current_page = next_page;
  1831.               spec_warn = True;
  1832. !             home();
  1833.           }
  1834.           canit = True;
  1835.           Flush();
  1836. --- 1050,1056 ----
  1837.           if (current_page != next_page) {
  1838.               current_page = next_page;
  1839.               spec_warn = True;
  1840. !             home(False);
  1841.           }
  1842.           canit = True;
  1843.           Flush();
  1844. ***************
  1845. *** 916,922 ****
  1846.           max_y - min_y, min_x, min_y, curr.base_x, curr.base_y);
  1847.       SetCursor(redraw_cursor);
  1848.       if (errtext = (char *) setjmp(dvi_env)) {
  1849. !         ClearPage();
  1850.   #ifndef X10
  1851.           get_xy();
  1852.           XDrawString(DISP, mane.win, foreGC,
  1853. --- 1081,1087 ----
  1854.           max_y - min_y, min_x, min_y, curr.base_x, curr.base_y);
  1855.       SetCursor(redraw_cursor);
  1856.       if (errtext = (char *) setjmp(dvi_env)) {
  1857. !         ClearPage(mane);
  1858.   #ifndef X10
  1859.           get_xy();
  1860.           XDrawString(DISP, mane.win, foreGC,
  1861. ***************
  1862. *** 941,953 ****
  1863.   redraw_page()
  1864.   {
  1865.       if (debug & DBG_EVENT) fputs("Redraw page:  ", stdout);
  1866. -     get_wh(clip_widget);
  1867.       get_xy();
  1868. !     ClearPage();
  1869.       mane.min_x = -window_x;
  1870. !     mane.max_x = -window_x + window_w;
  1871.       mane.min_y = -window_y;
  1872. !     mane.max_y = -window_y + window_h;
  1873.       redraw(&mane);
  1874.   }
  1875.   
  1876. --- 1106,1117 ----
  1877.   redraw_page()
  1878.   {
  1879.       if (debug & DBG_EVENT) fputs("Redraw page:  ", stdout);
  1880.       get_xy();
  1881. !     ClearPage(mane);
  1882.       mane.min_x = -window_x;
  1883. !     mane.max_x = -window_x + clip_w;
  1884.       mane.min_y = -window_y;
  1885. !     mane.max_y = -window_y + clip_h;
  1886.       redraw(&mane);
  1887.   }
  1888.   
  1889. ***************
  1890. *** 975,981 ****
  1891.   can_exposures(windowrec)
  1892.       struct WindowRec *windowrec;
  1893.   {
  1894. !     windowrec->min_x = windowrec->min_y = MAXINT;
  1895.       windowrec->max_x = windowrec->max_y = 0;
  1896.   }
  1897.   
  1898. --- 1139,1145 ----
  1899.   can_exposures(windowrec)
  1900.       struct WindowRec *windowrec;
  1901.   {
  1902. !     windowrec->min_x = windowrec->min_y = MAXDIM;
  1903.       windowrec->max_x = windowrec->max_y = 0;
  1904.   }
  1905.   
  1906. ***************
  1907. *** 1005,1013 ****
  1908.   {
  1909.       if (debug & DBG_BATCH) {
  1910.   #ifndef X10
  1911. !         while (mane.min_x == MAXINT) read_events(True);
  1912.   #else X10
  1913. !         while (mane.min_x == MAXINT)
  1914.           if (setjmp(canit_env)) break;
  1915.           else read_events(True);
  1916.   #endif X10
  1917. --- 1169,1177 ----
  1918.   {
  1919.       if (debug & DBG_BATCH) {
  1920.   #ifndef X10
  1921. !         while (mane.min_x == MAXDIM) read_events(True);
  1922.   #else X10
  1923. !         while (mane.min_x == MAXDIM)
  1924.           if (setjmp(canit_env)) break;
  1925.           else read_events(True);
  1926.   #endif X10
  1927. ***************
  1928. *** 1025,1042 ****
  1929.               canit = False;
  1930.               can_exposures(&mane);
  1931.               can_exposures(&alt);
  1932. ! #ifndef X10
  1933. !             if (unmapped) {
  1934. !                 /* this creates a redraw event */
  1935. !             XMapWindow(DISP, mane.win);
  1936. !             unmapped = False;
  1937. !             }
  1938. !             else
  1939. ! #endif
  1940. !             redraw_page();
  1941.           }
  1942. !         else if (alt.min_x < MAXINT) redraw(&alt);
  1943. !         else if (mane.min_x < MAXINT) redraw(&mane);
  1944.           Flush();
  1945.           }
  1946.       }
  1947. --- 1189,1208 ----
  1948.               canit = False;
  1949.               can_exposures(&mane);
  1950.               can_exposures(&alt);
  1951. !             redraw_page();
  1952.           }
  1953. !         else if (mag_moved) {
  1954. !             if (alt.win == NULL) mag_moved = False;
  1955. !             else if (abs(new_mag_x - mag_x) >
  1956. !             2 * abs(new_mag_y - mag_y))
  1957. !                 movemag(new_mag_x, mag_y);
  1958. !             else if (abs(new_mag_y - mag_y) >
  1959. !             2 * abs(new_mag_x - mag_x))
  1960. !                 movemag(mag_x, new_mag_y);
  1961. !             else movemag(new_mag_x, new_mag_y);
  1962. !         }
  1963. !         else if (alt.min_x < MAXDIM) redraw(&alt);
  1964. !         else if (mane.min_x < MAXDIM) redraw(&mane);
  1965.           Flush();
  1966.           }
  1967.       }
  1968. ***************
  1969. *** 1249,1269 ****
  1970.           top_level, vport_args, XtNumber(vport_args));
  1971.       clip_widget = XtNameToWidget(vport_widget, "clip");
  1972.       set_draw_args();
  1973. !     draw_widget = XtCreateManagedWidget("drawing", simpleWidgetClass,
  1974.           vport_widget, draw_args, XtNumber(draw_args));
  1975. !     XtAddEventHandler(vport_widget, KeyPressMask, 0, handle_key,
  1976.           (caddr_t) NULL);
  1977. !     XtAddEventHandler(draw_widget, ExposureMask, GraphicsExpose, handle_exp,
  1978.           (caddr_t) &mane);
  1979. !     XtAddEventHandler(draw_widget, ButtonPressMask, 0, handle_button,
  1980.           (caddr_t) NULL);
  1981. !     XtAddEventHandler(draw_widget, ButtonReleaseMask, 0, handle_release,
  1982.           (caddr_t) NULL);
  1983.       XtRealizeWidget(top_level);
  1984.       curr.win = mane.win = XtWindow(draw_widget);
  1985. -     /* unmapped = True;    (it was initialized this way) */
  1986. -     home();            /* no need to unmap at this stage */
  1987. -     unmapped = False;
  1988.   
  1989.       if (reverse) {
  1990.           if (!fore_color) fore_args.value = WhitePixelOfScreen(SCRN);
  1991. --- 1415,1436 ----
  1992.           top_level, vport_args, XtNumber(vport_args));
  1993.       clip_widget = XtNameToWidget(vport_widget, "clip");
  1994.       set_draw_args();
  1995. !     draw_widget = XtCreateManagedWidget("drawing", widgetClass,
  1996.           vport_widget, draw_args, XtNumber(draw_args));
  1997. !     XtAddEventHandler(vport_widget, KeyPressMask, False, handle_key,
  1998.           (caddr_t) NULL);
  1999. !     XtAddEventHandler(vport_widget, StructureNotifyMask, False,
  2000. !         handle_resize, (caddr_t) NULL);
  2001. !     XtAddEventHandler(draw_widget, ExposureMask, False, handle_exp,
  2002.           (caddr_t) &mane);
  2003. !     XtAddEventHandler(draw_widget, ButtonPressMask, False, handle_button,
  2004.           (caddr_t) NULL);
  2005. !     XtAddEventHandler(draw_widget, ButtonMotionMask, False, handle_motion,
  2006.           (caddr_t) NULL);
  2007. +     XtAddEventHandler(draw_widget, ButtonReleaseMask, False, handle_release,
  2008. +         (caddr_t) NULL);
  2009.       XtRealizeWidget(top_level);
  2010.       curr.win = mane.win = XtWindow(draw_widget);
  2011.   
  2012.       if (reverse) {
  2013.           if (!fore_color) fore_args.value = WhitePixelOfScreen(SCRN);
  2014. ***************
  2015. *** 1311,1317 ****
  2016.           cr_Pixel = high_color ? hl_Pixel : fore_args.value;
  2017.       {
  2018.           XColor bg_Color, cr_Color;
  2019. !         
  2020.           bg_Color.pixel = back_args.value;
  2021.           XQueryColor(DISP, DefaultColormapOfScreen(SCRN), &bg_Color);
  2022.           cr_Color.pixel = cr_Pixel;
  2023. --- 1478,1484 ----
  2024.           cr_Pixel = high_color ? hl_Pixel : fore_args.value;
  2025.       {
  2026.           XColor bg_Color, cr_Color;
  2027. ! 
  2028.           bg_Color.pixel = back_args.value;
  2029.           XQueryColor(DISP, DefaultColormapOfScreen(SCRN), &bg_Color);
  2030.           cr_Color.pixel = cr_Pixel;
  2031. ***************
  2032. *** 1550,1560 ****
  2033.       Sprintf(def, "=%dx%d+0+0", frame.width, frame.height);
  2034.       mane.win = XCreate("DVI Previewer", prog, geometry, def,
  2035.           &frame, 50, 50);
  2036. -     window_w = frame.width;
  2037. -     window_h = frame.height;
  2038.       XSelectInput(mane.win,
  2039.           KeyPressed|ButtonPressed|ButtonReleased|
  2040. !         ExposeWindow|ExposeRegion);
  2041.       XMapWindow(mane.win);
  2042.       XDefineCursor(mane.win,
  2043.           XCreateCursor(xdvi_width, xdvi_height, xdvi_bits, xdvi_mask_bits,
  2044. --- 1717,1726 ----
  2045.       Sprintf(def, "=%dx%d+0+0", frame.width, frame.height);
  2046.       mane.win = XCreate("DVI Previewer", prog, geometry, def,
  2047.           &frame, 50, 50);
  2048.       XSelectInput(mane.win,
  2049.           KeyPressed|ButtonPressed|ButtonReleased|
  2050. !         ExposeWindow|ExposeRegion|ExposeCopy|
  2051. !         LeftDownMotion|MiddleDownMotion|RightDownMotion);
  2052.       XMapWindow(mane.win);
  2053.       XDefineCursor(mane.win,
  2054.           XCreateCursor(xdvi_width, xdvi_height, xdvi_bits, xdvi_mask_bits,
  2055. diff -cr old/xdvi.h new/xdvi.h
  2056. *** old/xdvi.h    Thu Jul 13 12:52:45 1989
  2057. --- new/xdvi.h    Sat Jul  8 15:05:11 1989
  2058. ***************
  2059. *** 34,40 ****
  2060.   #define    True    1
  2061.   #define    False    0
  2062.   
  2063. ! #define    MAXINT        32767
  2064.   
  2065.   #define    pixel_conv(x)    ((int) (((x) / shrink_factor) >> 16))
  2066.   #define    pixel_round(x)    ((int) (((x) / shrink_factor + (1<<15)) >> 16))
  2067. --- 34,40 ----
  2068.   #define    True    1
  2069.   #define    False    0
  2070.   
  2071. ! #define    MAXDIM        32767
  2072.   
  2073.   #define    pixel_conv(x)    ((int) (((x) / shrink_factor) >> 16))
  2074.   #define    pixel_round(x)    ((int) (((x) / shrink_factor + (1<<15)) >> 16))
  2075. ***************
  2076. *** 123,132 ****
  2077.       char *bits;        /* pointer to the bits */
  2078.   };
  2079.   
  2080. - #ifndef    MAXCHARS
  2081. - #define    MAXCHARS    128    /* make 256 for 8 bit characters */
  2082. - #endif    MAXCHARS
  2083. - 
  2084.   /*
  2085.    * Per-character information.
  2086.    * There is one of these for each character in a font.
  2087. --- 123,128 ----
  2088. ***************
  2089. *** 173,183 ****
  2090.       short size;            /* dots per 5 inches */
  2091.       FILE *file;            /* open PXL file or NULL */
  2092.       char *filename;            /* name of PXL file */
  2093.       read_char_proc read_char;    /* function to read bitmap */
  2094. !     struct glyph glyph[MAXCHARS];
  2095.   };
  2096.   
  2097.   extern    struct font    *current_font;
  2098.   
  2099.   /*
  2100.    * Command line flags.
  2101. --- 169,181 ----
  2102.       short size;            /* dots per 5 inches */
  2103.       FILE *file;            /* open PXL file or NULL */
  2104.       char *filename;            /* name of PXL file */
  2105. +     ubyte maxchar;            /* largest character code */
  2106.       read_char_proc read_char;    /* function to read bitmap */
  2107. !     struct glyph glyph[256];
  2108.   };
  2109.   
  2110.   extern    struct font    *current_font;
  2111. + extern    ubyte    maxchar;
  2112.   
  2113.   /*
  2114.    * Command line flags.
  2115. ***************
  2116. *** 205,210 ****
  2117. --- 203,209 ----
  2118.       long    win;        /* type Window is not defined yet */
  2119.       int    shrinkfactor;
  2120.       int    base_x, base_y;
  2121. +     int    width, height;
  2122.       int    min_x, max_x, min_y, max_y;    /* for pending expose events */
  2123.   } mane, alt, curr;
  2124.   
  2125. diff -cr old/xdvi.man.sed new/xdvi.man.sed
  2126. *** old/xdvi.man.sed    Thu Jul 13 12:52:49 1989
  2127. --- new/xdvi.man.sed    Mon Jul 10 13:51:21 1989
  2128. ***************
  2129. *** 44,50 ****
  2130.   .TP
  2131.   .BI \-s " shrink"
  2132.   (.shrinkFactor)
  2133. ! Defines the initial shrink factor.  The default value is 4.
  2134.   .TP
  2135.   .BI \-S " density"
  2136.   (.densityPercent)
  2137. --- 44,50 ----
  2138.   .TP
  2139.   .BI \-s " shrink"
  2140.   (.shrinkFactor)
  2141. ! Defines the initial shrink factor.  The default value is 3.
  2142.   .TP
  2143.   .BI \-S " density"
  2144.   (.densityPercent)
  2145. diff -cr old/xdvi10.man.s new/xdvi10.man.s
  2146. *** old/xdvi10.man.s    Thu Jul 13 12:52:51 1989
  2147. --- new/xdvi10.man.s    Mon Jul 10 13:47:37 1989
  2148. ***************
  2149. *** 44,50 ****
  2150.   .TP
  2151.   .BI \-s " shrink"
  2152.   (shrinkFactor)
  2153. ! Defines the initial shrink factor.  The default value is 4.
  2154.   .TP
  2155.   .BI \-S " density"
  2156.   (densityPercent)
  2157. --- 44,50 ----
  2158.   .TP
  2159.   .BI \-s " shrink"
  2160.   (shrinkFactor)
  2161. ! Defines the initial shrink factor.  The default value is 3.
  2162.   .TP
  2163.   .BI \-S " density"
  2164.   (densityPercent)
  2165.