home *** CD-ROM | disk | FTP | other *** search
/ Piper's Pit BBS/FTP: ibm 0020 - 0029 / ibm0020-0029 / ibm0028.tar / ibm0028 / GRLF-C-2.ZIP / GFUNC / PRINTER.C < prev    next >
Encoding:
C/C++ Source or Header  |  1990-05-30  |  14.7 KB  |  939 lines
  1. /*
  2.  * printer.c
  3.  * contains: prdouble(),prcomp(),premph(),prbold(),prnorm(),prfixlf(),
  4.  * contains: prvarlf(),prskip(),prbufclr(),prselect(),prbell(),prsetflen(),
  5.  * contains: prhtabset(),prsetht(),prvtabset(),prsetvt(),prputc(),prs(),
  6.  * contains: prputl(),prputcr(),prputlf(),prcrlf(),prblanks(),prhtab(),
  7.  * contains: prvtab(),formfeed(),prunidir(),prunder(),prsub(),prsuper(),
  8.  * contains: prhome(),prstop(),prfont(),prbits(),prx(),pruse(),prmode(),
  9.  * contains: prreset(),prscreen(),prstatus(),
  10.  *
  11.  *   Copyright (C)1987-1990 Greenleaf Software Inc. All Rights Reserved.
  12.  *
  13.  */
  14.  
  15. #include <stdio.h>
  16. #include <stdlib.h>
  17. #include <dos.h>
  18. #include "gfuncts.h"
  19.  
  20. int tabs[3] = { 
  21.     1,0,0 };    /* tab stops for default condition    */
  22. int curr_printer=0,    /* current printer number        */
  23.     _lptmode=1;        /* 1 to use bdos(5..), 0 for bios I/O    */
  24.  
  25. /*
  26.  *  void
  27.  * prdouble(ctrl)
  28.  *
  29.  * ARGUMENT
  30.  *  (int)    ctrl    -    ON/OFF - enable/disable
  31.  *
  32.  * DESCRIPTION
  33.  *  This function sets or clears double width printing.
  34.  */
  35. void GF_CONV prdouble(ctrl)
  36. int ctrl;
  37. {
  38.     if (ctrl==ON||ctrl==SET) {
  39.         prx((char)0x0E);
  40.         prx((char)ESC);
  41.         prx((char)'W');
  42.         prx((char)1);
  43.     } else {
  44.         prx((char)0x14);
  45.         prx((char)ESC);
  46.         prx((char)'W');
  47.         prx((char)0);
  48.     }
  49. }
  50.  
  51. /*
  52.  *  void
  53.  * prcomp(ctrl)
  54.  *
  55.  * ARGUMENT
  56.  *  (int)    ctrl    -    ON/OFF - enable/disable
  57.  *
  58.  * DESCRIPTION
  59.  *  Set or clear compressed print (17cpi)
  60.  */
  61. void GF_CONV prcomp(ctrl)
  62. int ctrl;
  63. {
  64.     if(ctrl==ON||ctrl==SET)
  65.         prx((char)0x0F);
  66.     else 
  67.         prx((char)0x12);
  68. }
  69.  
  70. /*
  71.  *  void
  72.  * premph(ctrl)
  73.  *
  74.  * ARGUMENT
  75.  *  (int)    ctrl    -    ON/OFF
  76.  *
  77.  * DESCRIPTION
  78.  *  Sets or clears emphasized printing
  79.  */
  80. void GF_CONV premph(ctrl)
  81. int ctrl;
  82. {
  83.     prx((char)ESC);
  84.     if(ctrl==ON||ctrl==SET)
  85.         prx((char)'E');
  86.     else 
  87.         prx((char)'F');
  88. }
  89.  
  90. /*
  91.  *  void
  92.  * prbold(ctrl)
  93.  *
  94.  * ARGUMENT
  95.  *  (int)    ctrl    -    set or clear bold printing
  96.  *
  97.  * DESCRIPTION
  98.  *  This function sets or clears bold printing
  99.  */
  100. void GF_CONV prbold(ctrl)
  101. int ctrl;
  102. {
  103.     prx((char)ESC);
  104.     if(ctrl==ON||ctrl==SET)
  105.         prx((char)'G');
  106.     else 
  107.         prx((char)'H');
  108. }
  109.  
  110. /*
  111.  *  void
  112.  * prnorm(ctrl)
  113.  *
  114.  * ARGUMENT
  115.  *  (int)    ctrl    -    set/clear  (must be 1)
  116.  *
  117.  * DESCRIPTION
  118.  *  Set normal font mode.
  119.  */
  120. void GF_CONV prnorm(ctrl)
  121. int ctrl;
  122. {
  123.     if (ctrl==ON) {
  124.         prdouble(OFF);
  125.         prcomp(OFF);
  126.         premph(OFF);
  127.         prbold(OFF);
  128.         prunidir(OFF);
  129.         prsub(OFF);
  130.         prsuper(OFF);
  131.         prunder(OFF);
  132.         prfixlf(6,12);
  133.         prhtabset(OFF,(int *)0);
  134.         prvtabset(OFF,(int *)0);
  135.     }
  136. }
  137.  
  138. /*
  139.  *  int
  140.  * prfixlf(inc,n)
  141.  *
  142.  * ARGUMENT
  143.  *  (int)    inc    =     6   (1/6   inch)
  144.  *                8   (1/8   inch)
  145.  *                772 (7/72  inch)
  146.  *                72  (n/72  inch)
  147.  *                216 (n/216 inch)
  148.  *  (int)    n        Number of 1/216ths of inch or 1/72ths
  149.  *
  150.  * DESCRIPTION
  151.  *  Set fixed linefeed increment
  152.  *
  153.  * RETURNS
  154.  *  OK if successful, ERROR if argument is out of range
  155.  */
  156. int GF_CONV prfixlf(inc,n)
  157. int n, inc;
  158. {
  159.     prx((char)ESC);
  160.     switch (inc) {
  161.     default:
  162.     case NORM:
  163.     case 6:
  164.         prx((char)'2');
  165.         prx((char)ESC);
  166.         prx((char)'2');
  167.         break;
  168.     case 8:
  169.         prx((char)'0');
  170.         break;
  171.     case 772:
  172.         prx((char)'1');
  173.         break;
  174.     case 216:
  175.         if(n<1||n>255)
  176.             return ERROR;
  177.         else {
  178.             prx((char)'3');
  179.             prx((char)n);
  180.         }
  181.         break;
  182.     case 72:
  183.         if(n<1||n>85)
  184.             return ERROR;
  185.         else {
  186.             prx((char)'A');
  187.             prx((char)n);
  188.             prx((char)ESC);
  189.             prx((char)'2');
  190.             break;
  191.         }
  192.     }
  193.     return (OK);
  194. }
  195.  
  196. /*
  197.  *  int
  198.  * prvarlf(inc,n)
  199.  *
  200.  * ARGUMENT
  201.  *  (int)    n        - see prfixlf()
  202.  *  (int)    n        -    "
  203.  *
  204.  * DESCRIPTION
  205.  *  Set variable linefeed increment.
  206.  */
  207. int GF_CONV prvarlf(inc,n)
  208. int inc,n;
  209. {
  210.     return (prfixlf(inc,n));
  211. }
  212.  
  213. /*
  214.  *  void
  215.  * prskip(ctrl,n)
  216.  *
  217.  * ARGUMENT
  218.  *  (int)    ctrl    -    ENABLE/CLEAR
  219.  *  (int)    n    -    Number of lines to skip
  220.  *
  221.  * DESCRIPTION
  222.  *  Set skip perforation.  Skip n lines at bottom of page: prskip(SET,12) 
  223.  *  will print to 54th line on 66 line page, then skip the remainder
  224.  */
  225. void GF_CONV prskip(ctrl,n)
  226. int ctrl,n;
  227. {
  228.     prx((char)ESC);
  229.     if(ctrl==ON||ctrl==SET) {
  230.         prx((char)'N');
  231.         prx((char)n);
  232.     } else 
  233.         prx((char)'O');
  234. }
  235.  
  236. /*
  237.  *  void
  238.  * prbufclr(void)
  239.  *
  240.  * ARGUMENT
  241.  *  (none)
  242.  *
  243.  * DESCRIPTION
  244.  *  Clear printer buffer
  245.  */
  246. void GF_CONV prbufclr()
  247. {
  248.     prx((char)0x18);
  249. }
  250.  
  251. /*
  252.  *  void
  253.  * prselect(ctrl)
  254.  *
  255.  * ARGUMENT
  256.  *  (int)    ctrl    -    select/deselect
  257.  *
  258.  * DESCRIPTION
  259.  *  This function sends select/deselect code to printer.
  260.  */
  261. void GF_CONV prselect(ctrl)
  262. int ctrl;
  263. {
  264.     if(ctrl==ON||ctrl==SET)
  265.         prx((char)0x11);
  266.     else 
  267.         prx((char)0x13);    
  268. }
  269.  
  270. /*
  271.  *  void
  272.  * prbell(void)
  273.  *
  274.  * ARGUMENT
  275.  *  (none)
  276.  *
  277.  * DESCRIPTION
  278.  *  Sound BELL on printer.
  279.  */
  280. void GF_CONV prbell()
  281. {
  282.     prx((char)0x07);
  283. }
  284.  
  285. /*
  286.  *  int
  287.  * prsetflen(ctrl,n)
  288.  *
  289.  * ARGUMENT
  290.  *  (int)    ctrl        LINES/INCHES
  291.  *  (int)    n        LINES/INCHES per page
  292.  * DESCRIPTION
  293.  *  Set Form length in printer.
  294.  *
  295.  * RETURNS
  296.  *  ERROR if argument error, else OK
  297.  */
  298. int GF_CONV prsetflen(ctrl,n)
  299. int ctrl;
  300. int n;
  301. {
  302.     if(ctrl==LINES) {
  303.         if(n>=1&&n<=127) {
  304.             prx((char)ESC);
  305.             prx((char)'C');
  306.             prx((char)n);
  307.             return OK;
  308.         } else 
  309.             return ERROR;
  310.     } else if(ctrl==INCHES) {
  311.         if(n>=1 && n<=22) {
  312.             prx((char)ESC);
  313.             prx((char)'C');
  314.             prx((char)0);
  315.             prx((char)n);
  316.             return OK;
  317.         } else 
  318.             return ERROR;
  319.     } else 
  320.         return ERROR;
  321. }
  322.  
  323. /*
  324.  *  void
  325.  * prhtabset(ctrl,tabarray)
  326.  *
  327.  * ARGUMENT
  328.  *  (int)    ctrl    -    OFF/CLEAR, ON/SET
  329.  *  (int *)    tabarray -    Points to array of tabsettings, must be
  330.  *                NULL terminated.
  331.  *
  332.  * DESCRIPTION
  333.  *  Set up to 112 horizontal Tabs on the printer, or clear all tabs.
  334.  */
  335. void GF_CONV prhtabset(ctrl,tabarray)
  336. int ctrl;
  337. int *tabarray;
  338. {
  339.     if(ctrl==OFF||ctrl==CLEAR)
  340.         prsetht(tabs);
  341.     else if(ctrl==ON||ctrl==SET)
  342.         prsetht(tabarray);
  343. }
  344.  
  345. /*
  346.  *  void
  347.  * prsetht(ptab)
  348.  *
  349.  * ARGUMENT
  350.  *  (int *)    ptab    -    Points to tabstop to set
  351.  *
  352.  * DESCRIPTION
  353.  *  This function sets a horizontal tab stop as specified by *ptab;
  354.  *  worker for prhtabset().
  355.  */
  356. void GF_CONV prsetht(ptab)
  357. int *ptab;
  358. {
  359.     int tabstop;
  360.     prx((char)ESC);
  361.     prx((char)'D');
  362.     while (1) {
  363.         tabstop = *ptab++;
  364.         if(tabstop==0)
  365.             break;
  366.         else 
  367.             prx((char)tabstop);
  368.     }
  369.     prx((char)0);
  370. }
  371.  
  372. /*
  373.  *  void
  374.  * prvtabset(ctrl,tabarray)
  375.  *
  376.  * ARGUMENT
  377.  *  (int)    ctrl    -    set/clear tabs
  378.  *  (int *)    tabarray -    points to a NULL terminated array of
  379.  *                tab stops.
  380.  *
  381.  * DESCRIPTION
  382.  *  Set up to 64 vertical tabs or reset tabs.
  383.  */
  384. void GF_CONV prvtabset(ctrl,tabarray)
  385. int ctrl;
  386. int *tabarray;
  387. {
  388.     if(ctrl==OFF||ctrl==CLEAR)
  389.         prsetvt(tabs);
  390.     else if(ctrl==ON||ctrl==SET)
  391.         prsetvt(tabarray);
  392. }
  393.  
  394. /*
  395.  *  void
  396.  * prsetvt(tabarray)
  397.  *
  398.  * ARGUMENT
  399.  *  (int *)    tabarray    
  400.  *
  401.  * DESCRIPTION
  402.  *  worker for prvtabset()
  403.  */
  404. void GF_CONV prsetvt(tabarray)
  405. int *tabarray;
  406. {
  407.     int tabstop;
  408.  
  409.     prx((char)ESC);
  410.     prx((char)'B');
  411.     while (1) {
  412.         tabstop = *tabarray++;
  413.         if (tabstop==0)
  414.             break;
  415.         else 
  416.             prx((char)tabstop);
  417.     }
  418.     prx((char)0);
  419. }
  420.  
  421. /*
  422.  *  void
  423.  * prputc(c)
  424.  *
  425.  * ARGUMENT
  426.  *  (char)    c    -    character to print
  427.  *
  428.  * DESCRIPTION
  429.  *  Print a single character
  430.  */
  431. void GF_CONV prputc(c)
  432. char c;
  433. {
  434.     prx((char)c);
  435. }
  436.  
  437. /*
  438.  *  void
  439.  * prs(string)
  440.  *
  441.  * ARGUMENT
  442.  *  (char *)    string    -    Print a NULL terminated string.
  443.  *
  444.  * DESCRIPTION
  445.  *  This function prints a null terminated string, expanding tabs to
  446.  *  eight spaces.
  447.  */
  448. void GF_CONV prs(str)
  449. char *str;
  450. {
  451.     char c;
  452.     int i;
  453.  
  454.     i=0;
  455.     while (1) {
  456.         c = *str;
  457.         if(!c)
  458.             break;
  459.         if(c=='\t') {
  460.             do 
  461.                 prputc(BLANK);
  462.             while(++i % 8);
  463.             ++str;
  464.         } else {
  465.             prputc(c);
  466.             ++i;
  467.             ++str;
  468.         }
  469.     }
  470. }
  471.  
  472. /*
  473.  *  void
  474.  * prputl(string)
  475.  *
  476.  * ARGUMENT
  477.  *  (char *)    string    -    points to null terminated string to print
  478.  *
  479.  * DESCRIPTION
  480.  *  This function prints a null terminated string then prints a CR/LF
  481.  */
  482. void GF_CONV prputl(str)
  483. char *str;
  484. {
  485.     prs(str);
  486.     prcrlf();
  487. }
  488.  
  489. /*
  490.  *  void
  491.  * prputcr(void)
  492.  *
  493.  * ARGUMENT
  494.  *  (none)
  495.  *
  496.  * DESCRIPTION
  497.  *  Print carriage return character on printer.
  498.  */
  499. void GF_CONV prputcr()
  500. {
  501.     prx((char)CR);
  502. }
  503.  
  504. /*
  505.  *  void
  506.  * prputlf(void)
  507.  *
  508.  * ARGUMENT
  509.  *  (none)
  510.  *
  511.  * DESCRIPTION
  512.  *  Print line feed character on printer.
  513.  */
  514. void GF_CONV prputlf()
  515. {
  516.     prx((char)LF);
  517. }
  518.  
  519. /*
  520.  *  void
  521.  * prcrlf(void)
  522.  *
  523.  * ARGUMENT
  524.  *  (none)
  525.  *
  526.  * DESCRIPTION
  527.  *  Print carriage return/line feed sequence on printer
  528.  */
  529. void GF_CONV prcrlf()
  530. {
  531.     prx((char)CR);
  532.     prx((char)LF);
  533. }
  534.  
  535. /*
  536.  *  void
  537.  * prblanks(n)
  538.  *
  539.  * ARGUMENT
  540.  *  (int)    n    -    Number of blanks to print
  541.  *
  542.  * DESCRIPTION
  543.  *  Print (n) blanks on printer.
  544.  */
  545. void GF_CONV prblanks(n)
  546. int n;
  547. {
  548.     int i;
  549.  
  550.     for(i=1;i<=n;i++)
  551.         prx((char) ' ' );
  552. }
  553.  
  554. /*
  555.  *  void
  556.  * prhtab(void)
  557.  *
  558.  * ARGUMENT
  559.  *  (none)
  560.  *
  561.  * DESCRIPTION
  562.  *  Print a Horizontal Tab character on printer.
  563.  */
  564. void GF_CONV prhtab()
  565. {
  566.     prx((char)0x09);
  567. }
  568.  
  569. /*
  570.  *  void
  571.  * prvtab(void)
  572.  *
  573.  * ARGUMENT
  574.  *  (none)
  575.  *
  576.  * DESCRIPTION
  577.  *  Print a Vertical Tab character.
  578.  */
  579. void GF_CONV prvtab()
  580. {
  581.     prx((char)0x0B);
  582. }
  583.  
  584. /*
  585.  *  void
  586.  * formfeed(void)
  587.  *
  588.  * ARGUMENT
  589.  *  (none)
  590.  *
  591.  * DESCRIPTION
  592.  *  Send a formfeed to the line printer.
  593.  */
  594. void GF_CONV formfeed()
  595. {
  596.     prx((char)FF);
  597. }
  598.  
  599. /*
  600.  *  void
  601.  * prunidir(control)
  602.  *
  603.  * ARGUMENT
  604.  *  (int)    control    -    Enable/Disable Unidirectional mode
  605.  *
  606.  * DESCRIPTION
  607.  *  This function sends the codes to enable/disable unidirectional mode
  608.  *  on the Graphics printer.
  609.  */
  610. void GF_CONV prunidir(ctrl)
  611. int ctrl;
  612. {
  613.     prx((char)ESC);
  614.     prx((char)'U');
  615.     if(ctrl==ON||ctrl==SET)
  616.         prx((char)1);
  617.     else 
  618.         prx((char)0);
  619. }
  620.  
  621. /*
  622.  *  void
  623.  * prunder(control)
  624.  *
  625.  * ARGUMENT
  626.  *  (int)    prunder    -    Set/Clear option
  627.  *
  628.  * DESCRIPTION
  629.  *  Set or Clear Underline mode (Graphics Printer Only)
  630.  */
  631. void GF_CONV prunder(ctrl)
  632. int ctrl;
  633. {
  634.     prx((char)ESC);
  635.     prx((char)'-');
  636.     if(ctrl==ON||ctrl==SET)
  637.         prx((char)1);
  638.     else 
  639.         prx((char)0);
  640. }
  641.  
  642. /*
  643.  *  void
  644.  * prsub(ctrl)
  645.  *
  646.  * ARGUMENT
  647.  *  (int)    ctrl    -    option SET/CLEAR
  648.  *
  649.  * DESCRIPTION
  650.  *  This function sends codes to the printer to set or clear subscript
  651.  *  mode. (print tiny characters below the line)
  652.  */
  653. void GF_CONV prsub(ctrl)
  654. int ctrl;
  655. {    
  656.     prx((char)ESC);
  657.     if(ctrl==ON) {
  658.         prx((char)'S');
  659.         prx((char)1);
  660.     } else 
  661.         prx((char)'T');        /* clear subscript */
  662. }
  663.  
  664. /*
  665.  *  void
  666.  * prsuper(ctrl)
  667.  *
  668.  * ARGUMENT
  669.  *  (int)    ctrl    -    Enable/disable
  670.  *
  671.  * DESCRIPTION
  672.  *  This function sends codes to the printer that will enable superscript
  673.  *  mode. (tiny characters above line).
  674.  */
  675. void GF_CONV prsuper(ctrl)
  676. int ctrl;
  677. {    
  678.     prx((char)ESC);
  679.     if(ctrl==ON) {
  680.         prx((char)'S');
  681.         prx((char)0);
  682.     } else 
  683.         prx((char)'T');    /* clear superscript */
  684. }
  685.  
  686. /*
  687.  *  void
  688.  * prhome(void)
  689.  *
  690.  * ARGUMENT
  691.  *  (none)
  692.  *
  693.  * DESCRIPTION
  694.  *  Home the print head (graphics printer only)
  695.  */
  696. void GF_CONV prhome()
  697. {
  698.     prx((char)ESC);
  699.     prx((char)'<');
  700. }
  701.  
  702. /*
  703.  *  void
  704.  * prstop(ctrl)
  705.  *
  706.  * ARGUMENT
  707.  *  (int)    ctrl    -    option  stop=ON, ignore=(OFF)
  708.  *
  709.  * DESCRIPTION
  710.  *  Set printer to stop on end of paper switch or ignore it.
  711.  */
  712. void GF_CONV prstop(ctrl)
  713. int ctrl;
  714. {
  715.     prx((char)ESC);
  716.     if(ctrl==ON)
  717.         prx((char)'9');
  718.     else 
  719.         prx((char)'8'); 
  720. }
  721.  
  722. /*
  723.  *  void
  724.  * prfont(font)
  725.  *
  726.  * ARGUMENT
  727.  *  (int)    font    -    font select, 1/2
  728.  *
  729.  * DESCRIPTION
  730.  *  Character Set (font) select (graphics printer only). 
  731.  */
  732. void GF_CONV prfont(font)
  733. int font;
  734. {
  735.     if(font<1||font>2)
  736.         return;    /* only 2 fonts recognized */
  737.     prx((char)ESC);
  738.     if(font==1)
  739.         prx((char)'7');
  740.     else if(font==2)
  741.         prx((char)'6');
  742. }
  743.  
  744. /*
  745.  *  int
  746.  * prbits(density,length,bitarray)
  747.  *
  748.  * ARGUMENT
  749.  *  (int)    density    -    density 480,960 etc.
  750.  *  (int)    length    -    length in bytes of bitarray
  751.  *  (char *)    bitarray -    graphics bit image data
  752.  *
  753.  *
  754.  * DESCRIPTION
  755.  *  Graphics bit image print from array.
  756.  *
  757.  * RETURNS
  758.  *  ERROR if length is too long for density.
  759.  */
  760. int GF_CONV prbits(density,length,bitarray)
  761. int density,length;
  762. char *bitarray;
  763. {
  764.     char *p;
  765.     int i,n1,n2;
  766.  
  767.     n1=length % 256;
  768.     n2=length/256;
  769.     p=bitarray;
  770.     prx((char)ESC);
  771.     switch (density) {
  772.     default:
  773.     case 480:
  774.         if(length<1||length>480)
  775.             return ERROR;
  776.         else 
  777.             prx((char)'K');
  778.         break;
  779.     case 960:
  780.         if(length<1||length>960)
  781.             return ERROR;
  782.         else 
  783.             prx((char)'L');
  784.         break;
  785.     case FAST:
  786.         if(length<1||length>960)
  787.             return ERROR;
  788.         else 
  789.             prx((char)'Y');
  790.         break;
  791.     case 1920:
  792.         if(length<1||length>1920)
  793.             return ERROR;
  794.         else 
  795.             prx((char)'Z');
  796.         break;
  797.     }
  798.     prx((char)n1);
  799.     prx((char)n2);        /* send 2 length bytes        */
  800.     for(i=1;i<=length;i++)
  801.         prx(*p++);    /* send bit array content    */
  802.     return(OK);
  803. }
  804.  
  805. /*
  806.  *  int
  807.  * prx(data)
  808.  *
  809.  * ARGUMENT
  810.  *  (char)    data    -    data to print
  811.  *
  812.  * DESCRIPTION
  813.  *  Primitive to send a byte of data to the currently selected printer.
  814.  *  Note: we switch on _LPTMODE: if 1 use int 17h, if 0 use bdos(5,,,)
  815.  *
  816.  * RETURNS
  817.  *  Printer status if using int 17h, otherwise 0.
  818.  */
  819. int GF_CONV prx(data)
  820. char data;
  821. {
  822.     struct GFREGS in,out;
  823.  
  824.     if (_lptmode==1) {
  825.         in.ax = (int)(data&0x00FF);
  826.         in.dx = curr_printer;
  827.         sysint(0x17, &in, &out );
  828.         return((int)((out.ax&0xFF00)>>8));
  829.     } else {
  830.         bdos(5,data,0);
  831.         return 0;
  832.     }
  833. }
  834.  
  835. /*
  836.  *  void
  837.  * pruse(n)
  838.  *
  839.  * ARGUMENT
  840.  *  (int)    n    -    Printer to use, 0=LPT1, 1=LPT2 etc.
  841.  *
  842.  * DESCRIPTION
  843.  *  printer selection primitive.
  844.  */
  845. void GF_CONV pruse(n)
  846. int n;
  847. {
  848.     curr_printer=n;
  849. }
  850.  
  851. /*
  852.  *  void
  853.  * prmode(mode)
  854.  *
  855.  * ARGUMENT
  856.  *  (int)    mode    - 0 = use MS-DOS, 1 = use ROM-BIOS
  857.  *
  858.  * DESCRIPTION
  859.  *  Printer I/O mode selection, this function determines which mode
  860.  *  will be used to output data to the printer.
  861.  */
  862. void GF_CONV prmode(mode)
  863. int mode;
  864. {
  865.     if(mode<0||mode>1)
  866.         return;
  867.     else 
  868.         _lptmode=mode;
  869. }
  870.  
  871. /*
  872.  *  int
  873.  * prreset(n)
  874.  *
  875.  * ARGUMENT
  876.  *  (int)    n    -    printer number to reset
  877.  *
  878.  * DESCRIPTION
  879.  *  Sends reset sequence to specified printer.
  880.  *
  881.  * SIDE EFFECTS
  882.  *  printer is reset to power up condition
  883.  */
  884. int GF_CONV prreset(n)
  885. int n;
  886. {
  887.     struct GFREGS in, out;
  888.  
  889.     in.ax = 0x0100;
  890.     in.dx = n&0x0003;
  891.     sysint(0x17,&in,&out);
  892.     return((out.ax&0x00FF)>>8);    /* return status    */
  893. }
  894.  
  895. /*
  896.  *  void
  897.  * prscreen(void)
  898.  *
  899.  * ARGUMENT
  900.  *  (none)
  901.  *
  902.  * DESCRIPTION
  903.  *  does software interrupt #5 print screen
  904.  */
  905. void GF_CONV prscreen()
  906. {
  907.     struct GFREGS in,out;
  908.     sysint(5,&in,&out);
  909. }
  910.  
  911. /*
  912.  *  int
  913.  * prstatus(n)
  914.  *
  915.  * ARGUMENT
  916.  *  (int)    n    -    which printer.
  917.  *
  918.  * DESCRIPTION
  919.  *  This function calls the ROM-BIOS returning the printer status.
  920.  *
  921.  * RETURNS
  922.  *
  923.  *  Status bits:
  924.  * 
  925.  *    0 - TimeOut    1,2 - Unused        3 - I/O Error
  926.  *    4 - Selected      5 - Out of Paper    6 - Acknowledge
  927.  *    7 - Not Busy
  928.  */
  929. int GF_CONV prstatus(n)
  930. int n;
  931. {
  932.     struct GFREGS in,out;
  933.  
  934.     in.ax=0x0200;
  935.     in.dx=n;
  936.     sysint(0x17,&in,&out);
  937.     return((int)((out.ax&0xFF00)>>8));
  938. }
  939.