home *** CD-ROM | disk | FTP | other *** search
/ Amiga Elysian Archive / AmigaElysianArchive.iso / printer / dvi2pcl.lha / doodevpages.c < prev    next >
C/C++ Source or Header  |  1992-11-25  |  5KB  |  195 lines
  1. /* $Log:    doodevpages.c,v $
  2.  * Revision 0.8  92/11/23  19:46:40  19:46:40  bt (Bo Thide')
  3.  * Fixed resolution bug. Portable downloading. Added/changed options. PJXL color support
  4.  * 
  5.  * Revision 0.7  92/11/13  02:41:24  02:41:24  bt (Bo Thide')
  6.  * More bug fixes and improvements. Support for PaintJet XL
  7.  * 
  8.  * Revision 0.6  92/11/10  21:47:41  21:47:41  bt (Bo Thide')
  9.  * Bug fixes. Added -R option. Better font handling.
  10.  * 
  11.  * Revision 0.5  92/11/09  16:25:27  16:25:27  bt (Bo Thide')
  12.  * Rewrite of dospecial.c. Extended \special support
  13.  * 
  14.  * Revision 0.4  92/11/08  02:45:43  02:45:43  bt (Bo Thide')
  15.  * Changed to portable bit manipulations. Replaced strrstr for non-POSIX compliant C. Fixed numerous bugs. Added support for more \special's.
  16.  * 
  17.  * Revision 0.3  92/08/24  12:45:35  12:45:35  bt (Bo Thide')
  18.  * Fixed 8 bit (dc font) support.
  19.  * 
  20.  * Revision 0.2  92/08/23  17:28:55  17:28:55  bt (Bo Thide')
  21.  * Source cleaned up.  Changed certain function calls.  Removed globals.
  22.  * 
  23.  * Revision 0.1  92/08/22  23:58:47  23:58:47  bt (Bo Thide')
  24.  * First Release.
  25.  *  */
  26.  
  27. /*
  28.  * This routine processes all pages in the 'two-sided' mode.
  29.  * Reverse is true for LaserJet+, but false for LaserJet II.
  30.  *
  31.  * If reverse is true, all even pages are output first in reverse order,
  32.  * then the odd pages are output in reverse order.
  33.  *
  34.  * Example:
  35.  * First even pages are output: 6 4 2 (2 on top, printed side upwards).
  36.  * Then you turn the stack of paper (6 on top, printed side downwards) and
  37.  * feed in 6 4 2, and 5 3 1 are printed on the other side.
  38.  * 1 is now on top of the stack, printed side upwards.
  39.  *
  40.  * If reverse is false, all odd pages are output first in normal order,
  41.  * then the even pages are output in reverse order.
  42.  *
  43.  * Example:
  44.  * First odd pages are output: 1 3 5 (5 on top of stack, printed side
  45.  * downwards). Then you take the stack of paper and
  46.  * feed in 5 3 1 (5 on top, printed side downwards), and 6 4 2 are printed on
  47.  * the other side. 1 is now on top of the stack, printed side upwards.
  48.  */
  49.  
  50. #include <stdio.h>
  51. #include "globals.h"
  52. #include "pcl.h"
  53.  
  54. static char rcsid[] = "$Header: doodevpages.c,v 0.8 92/11/23 19:46:40 bt Exp $";
  55.  
  56. void doodevpages(bitfile, dvifile, pcllevel, reverse, resolution, device)
  57. FILE    *bitfile;
  58. FILE    *dvifile;
  59. short    pcllevel;
  60. bool    reverse;
  61. short    resolution;
  62. short    device;
  63. { 
  64.     long     backpage, startpage;
  65.     short     is_odd = actualpagecount % 2;
  66.  
  67.     if(inpostamble)
  68.         backpage = lastpage + 1;
  69.     else
  70.         backpage = prevpage + 1;
  71.     maxpages = actualpagecount;
  72.  
  73.     if (reverse)
  74.     {    /* Start with even pages. */
  75.  
  76.         /* Eject an empty paper if odd number of pages */
  77.         if (is_odd)  fputs(PCL4_EJECT_PAGE,bitfile);
  78.  
  79.         startpage = backpage;
  80.         h_offset = e_offset;
  81.  
  82.         while(maxpages--)
  83.         { 
  84.             fseek(dvifile , backpage , 0);
  85.             scanbop(dvifile);
  86.             backpage = prevpage + 1;
  87.             if (! is_odd)
  88.             {
  89.                 printbop(startvals, count);
  90.                 dopage(bitfile, dvifile, pcllevel, resolution,
  91.                   device);
  92.             }
  93.             if(maxpages > 0)
  94.             { 
  95.                 fseek(dvifile , backpage , 0);
  96.                 scanbop(dvifile);
  97.                 if (is_odd)
  98.                 {
  99.                     printbop(startvals, count);
  100.                     dopage(bitfile, dvifile, pcllevel,
  101.                       resolution, device);
  102.                 }
  103.                 backpage = prevpage + 1;
  104.                 maxpages--;
  105.             }
  106.         }
  107.  
  108.         /* then do the odd pages */
  109.         fprintf(stderr,"Reload paper cassette with output package\n");
  110.         fputs(PCL4_MANUAL_FEED,bitfile);
  111.  
  112.         h_offset = o_offset;
  113.         maxpages = actualpagecount;
  114.         backpage = startpage;
  115.         while (maxpages-- > 0)
  116.         {
  117.             fseek(dvifile , backpage , 0);
  118.             scanbop(dvifile);
  119.             backpage = prevpage + 1;
  120.             if (is_odd)
  121.             {
  122.                 printbop(startvals, count);
  123.                 dopage(bitfile, dvifile, pcllevel, resolution,
  124.                   device);
  125.             }
  126.             if(maxpages > 0)
  127.             { 
  128.                 fseek(dvifile , backpage , 0);
  129.                 scanbop(dvifile);
  130.                 if (! is_odd)
  131.                 {
  132.                     printbop(startvals, count);
  133.                     dopage(bitfile, dvifile, pcllevel,
  134.                       resolution, device);
  135.                 }
  136.                 backpage = prevpage + 1;
  137.                 maxpages--;
  138.             }
  139.         }
  140.     }
  141.     else
  142.     {
  143.         /* Do odd pages first */
  144.         h_offset = o_offset;
  145.         maxpages = actualpagecount;
  146.         fseek(dvifile , firstpage-1 , 0);
  147.         while(maxpages-- > 0)
  148.         { 
  149.             if(betweenpages(dvifile, PRESCAN_OFF))
  150.             { 
  151.                 printbop(startvals, count);
  152.                 dopage(bitfile, dvifile, pcllevel, resolution,
  153.                   device);
  154.                 maxpages--;
  155.                 skipnextpage(dvifile);
  156.             }
  157.         }
  158.         /* Then do the even pages */
  159.         fprintf(stderr,"Reload paper cassette with output package\n");
  160.         fputs(PCL4_MANUAL_FEED,bitfile);
  161.  
  162.         h_offset = e_offset;
  163.         maxpages = actualpagecount;
  164.         if (is_odd)  fputs(PCL4_EJECT_PAGE,bitfile); /* Odd number of pages */
  165.  
  166.         while(maxpages--)
  167.         { 
  168.             fseek(dvifile , backpage , 0);
  169.             scanbop(dvifile);
  170.             backpage = prevpage + 1;
  171.             if (! is_odd)
  172.             {
  173.                 printbop(startvals, count);
  174.                 dopage(bitfile, dvifile, pcllevel, resolution,
  175.                   device);
  176.             }
  177.             if(maxpages > 0)
  178.             { 
  179.                 fseek(dvifile , backpage , 0);
  180.                 scanbop(dvifile);
  181.                 if (is_odd)
  182.                 {
  183.                     printbop(startvals, count);
  184.                     dopage(bitfile, dvifile, pcllevel,
  185.                       resolution, device);
  186.                 }
  187.                 backpage = prevpage + 1;
  188.                 maxpages--;
  189.             }
  190.         }
  191.     }
  192.  
  193.     fprintf(stderr,"\n");
  194. }
  195.