home *** CD-ROM | disk | FTP | other *** search
/ World of Shareware - Software Farm 2 / wosw_2.zip / wosw_2 / PRINTING / ISIGNS50.ZIP / PRT.PAS < prev    next >
Pascal/Delphi Source File  |  1989-10-01  |  19KB  |  439 lines
  1. PROCEDURE avail_space;
  2. VAR  pitch : REAL;
  3. BEGIN
  4.     IF given_width = 0 THEN
  5.         CASE output_device OF
  6.             printr : BEGIN
  7.                          IF block_type <> bit THEN BEGIN
  8.                              CASE prt_cpi OF
  9.                                  pica     : pitch := 10;
  10.                                  elite    : pitch := 12;
  11.                                  squeezed : pitch := 17;      {16.66 for IDS, HP}
  12.                                  tiny     : pitch := 20      {n/a on IDS printer}
  13.                              END; {case}
  14.                              IF device_size = wide THEN
  15.                                  avail_width := TRUNC(pitch * 14)
  16.                              ELSE
  17.                                  avail_width := TRUNC(pitch * 8)
  18.                              {end}
  19.                          END ELSE BEGIN
  20.                              CASE prt_type OF
  21.                                  ids : IF device_size = wide THEN
  22.                                            avail_width := 1134
  23.                                        ELSE avail_width := 672;
  24.                                   hp : CASE graphic_dens OF
  25.                                            single : avail_width := 600;
  26.                                            double : avail_width := 800;
  27.                                            triple : avail_width := 1200;
  28.                                            quad   : avail_width := 2400
  29.                                        END; {case graphic_dens}
  30.                                epson : CASE graphic_dens OF
  31.                                            single : IF device_size = wide THEN
  32.                                                         avail_width := 816
  33.                                                     ELSE avail_width := 480;
  34.                                     double,triple : IF device_size = wide THEN
  35.                                                         avail_width := 1632
  36.                                                     ELSE avail_width := 960;
  37.                                            quad   : IF device_size = wide THEN
  38.                                                         avail_width := 3264
  39.                                                     ELSE avail_width := 1920
  40.                                        END {case graphic_dens}
  41.                              END {case prt_type}
  42.                          END {if not bit}
  43.                      END;
  44.             screen : IF device_size = wide THEN
  45.                          avail_width := 131
  46.                      ELSE
  47.                          avail_width := 79;
  48.          recd_file : avail_width := Max_Length
  49.         END {case}
  50.     ELSE {width WAS given}
  51.         avail_width := given_width;
  52.     {end if width was not given}
  53.  
  54.     GOTORC(16,6); lowvideo; WRITE('Width available -> ');
  55.     highvideo; WRITE(avail_width ,'  ');
  56.     GOTORC(17,25); CLREOL; highvideo; WRITE('---') {don't know required}
  57. END;
  58.  
  59.  
  60. PROCEDURE set_up_prt; { (reset_prt : BOOLEAN) }
  61. BEGIN
  62.     IF reset_prt THEN
  63.         CASE prt_type OF
  64.            {dumb : ;  {no action}
  65.              ids : putchr(CHR(30)+CHR(27)+'B8$'+CHR(27)+'Q4$'); {12 cpi, 6 lpi, Black}
  66.               hp : putchr(CHR(27)+'E');
  67.            epson : putchr(CHR(18)+CHR(27)+'P'+CHR(27)+'2')
  68.         END {case}
  69.     ELSE
  70.         CASE prt_type OF
  71.        {dumb : ;  {no action}
  72.          ids : BEGIN
  73.                    putchr(CHR(27)+'R2$'); {Draft quality print}
  74.                    CASE prt_lpi OF
  75.                        six     : putchr(CHR(27)+'B8$');
  76.                        eight   : putchr(CHR(27)+'B6$');
  77.                        ten     : putchr(CHR(27)+'B5$');
  78.                        twelve  : putchr(CHR(27)+'B4$')
  79.                    END; {case}
  80.                    CASE prt_cpi OF
  81.                        pica     : putchr(CHR(29));
  82.                        squeezed : putchr(CHR(31));
  83.                        elite    : putchr(CHR(30));
  84.                        tiny     : putchr(CHR(30))   {20 cpi n/a on Prism, use 16.7}
  85.                    END; {case}
  86.                    CASE prt_color OF
  87.                        black    : putchr(CHR(27)+'Q4$');
  88.                        blue     : putchr(CHR(27)+'Q3$');
  89.                        green    : putchr(CHR(27)+'Q2$');
  90.                        red      : putchr(CHR(27)+'Q1$')
  91.                    END; {case}
  92.                    putchr(CHR(13));       {and a final <cr> to return head}
  93.                    {IF block_type = BIT THEN BEGIN
  94.                       graphics set-up - none required
  95.                    END;}
  96.                END;
  97.           hp : BEGIN
  98.                    CASE prt_lpi OF
  99.                        six     : putchr(CHR(27)+'&l8C');
  100.                        eight   : putchr(CHR(27)+'&l6C');
  101.                        ten     : putchr(CHR(27)+'&l5C');
  102.                        twelve  : putchr(CHR(27)+'&l4C')
  103.                    END; {case}
  104.                    CASE prt_cpi OF
  105.                        pica     : putchr(CHR(27)+'(s10H');
  106.                        elite    : putchr(CHR(27)+'(s12H');
  107.                        squeezed : putchr(CHR(27)+'(s17H');
  108.                        tiny     : putchr(CHR(27)+'(s20H')
  109.                    END; {case}
  110.                    putchr(CHR(13));      {and a final <cr> to return head}
  111.                    IF block_type = BIT THEN {graphics set-up}
  112.                        CASE graphic_dens OF
  113.                            single : putchr(CHR(27)+'*t75R'+CHR(27)+'*r0A');
  114.                            double : putchr(CHR(27)+'*t100R'+CHR(27)+'*r0A');
  115.                            triple : putchr(CHR(27)+'*t150R'+CHR(27)+'*r0A');
  116.                            quad   : putchr(CHR(27)+'*t300R'+CHR(27)+'*r0A');
  117.                        END {case graphic_dens}
  118.                    {END if graphics}
  119.                END;
  120.        epson : BEGIN
  121.                    putchr(CHR(27)+'x0'); {Draft quality print}
  122.                    CASE prt_lpi OF
  123.                        six     : putchr(CHR(27)+'2');
  124.                        eight   : putchr(CHR(27)+'0');
  125.                        ten     : putchr(CHR(27)+'1');
  126.                        twelve  : putchr(CHR(27)+'3'+chr(18))
  127.                    END; {case}
  128.                    CASE prt_cpi OF
  129.                        pica     : putchr(CHR(27)+'P'+chr(18));
  130.                        squeezed : putchr(CHR(27)+'P'+chr(15));
  131.                        elite    : putchr(CHR(27)+'M'+chr(18));
  132.                        tiny     : putchr(CHR(27)+'M'+chr(15))
  133.                    END; {case}
  134.                    putchr(CHR(13));       {and a final <cr> to return head}
  135.                    IF block_type = BIT THEN
  136.                       putchr(CHR(27)+'A'+CHR(8));  {graphics 8/72 <lf>}
  137.                    {END}
  138.                END
  139.         END {case}
  140.     {END if reset_prt}
  141. END; {procedure set_up prt}
  142.  
  143.  
  144. PROCEDURE out_char; {(ochar,ichar,action : CHAR);}
  145. VAR i : INTEGER;
  146. BEGIN
  147.     CASE action OF
  148.         'S' : BEGIN      {Start - initialize graphic lines and clear}
  149.                  FOR i := 1 TO Max_Length DO BEGIN
  150.                      gout_1.chr[i] := CHR(0);
  151.                      gout_2.chr[i] := CHR(0);
  152.                      out_line.chr[i] := CHR(0)
  153.                  END;
  154.                  gout_1.len := 0;
  155.                  gout_2.len := 0;
  156.                  out_line.len := 0
  157.               END;
  158.         'C' : BEGIN
  159.                  FOR i := 1 TO out_line.len DO out_line.chr[i] := CHR(0);
  160.                  out_line.len := 0  {Clear - clear current line}
  161.               END;
  162.         'A' : BEGIN           {Add - add passed char and inverse char to line}
  163.                   out_line.len := out_line.len + 1;
  164.                   IF (out_line.chr[out_line.len] IN [CHR(0),' ']) OR
  165.                     ((out_line.chr[out_line.len] <> ' ') AND (ochar <> ' '))
  166.                     THEN BEGIN
  167.                       out_line.chr[out_line.len] := ochar;
  168.                       out_line.ichr[out_line.len] := ichar
  169.                   END {don't overwrite non spaces}
  170.               END;
  171.     'D','E' : BEGIN         {End - line completed, output}
  172.                   IF avail_width < out_line.len+given_offset THEN
  173.                       page_offset := 0
  174.                   ELSE IF centering THEN
  175.                       page_offset := ROUND((avail_width - out_line.len)/2)
  176.                   ELSE
  177.                       page_offset := given_offset;
  178.                   {end if - determine left margin}
  179.                   IF avail_width < out_line.len THEN
  180.                       out_line.len := avail_width;
  181.                   {end - don't output chars that'll overflow}
  182.                   IF block_type = bit THEN
  183.                       IF action = 'D' THEN
  184.                           CASE prt_type OF {Done - graphic output completed.}
  185.                                ids : out_gl_ids;
  186.                                 hp : BEGIN
  187.                                          out_gl_hp;
  188.                                          putchr(CHR(27)+'*rB') {end graphics}
  189.                                      END;
  190.                              epson : out_gl_ep
  191.                           END {case}
  192.                       ELSE
  193.                           add_gline   {add graphic line to output}
  194.                   ELSE
  195.                       out_nline       {output non-graphic line}
  196.               END
  197.     END {case}
  198. END; {procedure out_char}
  199.  
  200.  
  201. PROCEDURE out_nline;
  202. VAR
  203.     i,j,strikes,os_lcv : INTEGER;
  204. BEGIN
  205.     IF inv_video THEN
  206.         FOR j := 1 TO out_line.len DO
  207.             out_line.chr[j] := out_line.ichr[j];
  208.     {END if inv_video (use inverse characters)}
  209.     IF block_type = block THEN
  210.         FOR j := 1 TO out_line.len DO
  211.             IF out_line.chr[j] <> ' ' THEN
  212.                 out_line.chr[j] := block_char;
  213.         {end}
  214.     {end inv_video (reverse sense of space)}
  215.  
  216.     IF block_type = overstrike THEN {multiple hits?}
  217.         strikes := LENGTH(Os_Strng)
  218.     ELSE
  219.         strikes := 1;
  220.     {end}
  221.     FOR os_lcv := 1 TO strikes DO BEGIN
  222.         FOR j := 1 TO page_offset DO putchr(' ');
  223.         FOR j := 1 TO out_line.len DO
  224.             IF (block_type = overstrike) AND (out_line.chr[j] <> ' ') THEN
  225.                 putchr(Os_Strng[os_lcv])
  226.             ELSE
  227.                 putchr(out_line.chr[j]);
  228.         {for each char in out_line}
  229.         putchr(CHR(13))             {<cr>}
  230.     END; {for overstrikes}
  231.     putchr(CHR(10))                 {<lf>}
  232. END; {procedure out_nline}
  233.  
  234.  
  235. PROCEDURE add_gline;
  236. VAR
  237.    add : BYTE;
  238.      i,bit_pos,byte_pos : INTEGER;
  239. BEGIN
  240.     CASE prt_type OF
  241.         ids : BEGIN
  242.                   CASE bit_cnt OF
  243.                       0 : add := 1;
  244.                       1 : add := 2;
  245.                       2 : add := 4;
  246.                       3 : add := 8;
  247.                       4 : add := 16;
  248.                       5 : add := 32;
  249.                       6 : add := 64
  250.                   END; {case}
  251.                   FOR i := 1 TO out_line.len DO
  252.                       IF out_line.chr[i] <> ' ' THEN
  253.                           gout_1.chr[i+page_offset] := {turn bit on}
  254.                              CHR(ORD(gout_1.chr[i+page_offset]) + add);
  255.                   IF out_line.len+page_offset > gout_1.len THEN
  256.                       gout_1.len := out_line.len+page_offset;  {use longest length}
  257.                   IF bit_cnt < 6 THEN
  258.                       bit_cnt := bit_cnt + 1
  259.                   ELSE BEGIN
  260.                       bit_cnt := 0;
  261.                       out_gl_ids            {dump the line}
  262.                   END
  263.               END;
  264.          hp : BEGIN
  265.                   bit_pos := 0;
  266.                   FOR i := 1 TO out_line.len DO BEGIN
  267.                       IF out_line.chr[i] <> ' ' THEN BEGIN
  268.                           byte_pos := TRUNC(0.99 + ((i+page_offset)/8));
  269.                           CASE bit_pos OF
  270.                               0 : add := 128;
  271.                               1 : add :=  64;
  272.                               2 : add :=  32;
  273.                               3 : add :=  16;
  274.                               4 : add :=   8;
  275.                               5 : add :=   4;
  276.                               6 : add :=   2;
  277.                               7 : add :=   1
  278.                           END; {case}
  279.                           gout_1.chr[byte_pos] := CHR(ORD(gout_1.chr[byte_pos]) + add)
  280.                       END;
  281.                       IF bit_pos = 7 THEN
  282.                           bit_pos := 0
  283.                       ELSE
  284.                           bit_pos := bit_pos + 1
  285.                   END; {for each char in out_line}
  286.                   gout_1.len := TRUNC(0.99 + ((out_line.len+page_offset)/8));
  287.                   out_gl_hp
  288.               END;
  289.       epson : BEGIN
  290.                   IF graphic_dens IN [single,double] THEN
  291.                       CASE bit_cnt OF
  292.                           0 : add := 128;
  293.                           1 : add := 64;
  294.                           2 : add := 32;
  295.                           3 : add := 16;
  296.                           4 : add := 8;
  297.                           5 : add := 4;
  298.                           6 : add := 2;
  299.                           7 : add := 1
  300.                       END {case}
  301.                   ELSE
  302.                       CASE bit_cnt OF
  303.                           0 : add := 128;
  304.                           1 : add := 128;
  305.                           2 : add := 64;
  306.                           3 : add := 64;
  307.                           4 : add := 32;
  308.                           5 : add := 32;
  309.                           6 : add := 16;
  310.                           7 : add := 16;
  311.                           8 : add := 8;
  312.                           9 : add := 8;
  313.                          10 : add := 4;
  314.                          11 : add := 4;
  315.                          12 : add := 2;
  316.                          13 : add := 2;
  317.                          14 : add := 1;
  318.                          15 : add := 1;
  319.                       END; {case}
  320.                   {END}
  321.                   FOR i := 1 TO out_line.len DO
  322.                       IF out_line.chr[i] <> ' ' THEN
  323.                           IF graphic_dens IN [single,double] THEN
  324.                               gout_1.chr[i+page_offset] :=
  325.                                  CHR(ORD(gout_1.chr[i+page_offset]) + add)
  326.                           ELSE BEGIN
  327.                               IF bit_cnt IN [0,2,4,6,8,10,12,14] THEN
  328.                                   gout_1.chr[i+page_offset] :=
  329.                                      CHR(ORD(gout_1.chr[i+page_offset]) + add)
  330.                               ELSE
  331.                                   gout_2.chr[i+page_offset] :=
  332.                                      CHR(ORD(gout_2.chr[i+page_offset]) + add)
  333.                               {end}
  334.                           END;
  335.                       {end if non blank}
  336.                   {end for each output char}
  337.                   IF out_line.len+page_offset > gout_1.len THEN
  338.                       gout_1.len := out_line.len+page_offset;  {use longest length}
  339.                   IF graphic_dens IN [single,double] THEN
  340.                       IF bit_cnt < 7 THEN
  341.                           bit_cnt := bit_cnt + 1
  342.                       ELSE BEGIN
  343.                           out_gl_ep;            {dump the line}
  344.                           bit_cnt := 0
  345.                       END
  346.                   ELSE
  347.                       IF bit_cnt < 15 THEN
  348.                           bit_cnt := bit_cnt + 1
  349.                       ELSE BEGIN
  350.                           out_gl_ep;            {dump the lines}
  351.                           bit_cnt := 0
  352.                       END
  353.                   {end}
  354.               END
  355.     END {case}
  356. END; {procedure add_gline}
  357.  
  358.  
  359. PROCEDURE out_gl_ids;
  360. VAR i : INTEGER;
  361. BEGIN
  362.     putchr(CHR(3));         {into graphics}
  363.     FOR i := 1 TO gout_1.len DO BEGIN
  364.         putchr(gout_1.chr[i]);
  365.         IF gout_1.chr[i] = CHR(3) THEN putchr(CHR(3))   {double all ^C's}
  366.     END;
  367.     putchr(CHR(3)+CHR(2)+CHR(14)); {out of graphics, <cr> and graphics <lf>}
  368.     FOR i := 1 TO gout_1.len DO
  369.         gout_1.chr[i] := CHR(0); {clear graphics line}
  370.     gout_1.len := 0  {reset length}
  371. END; {procedure out_gl_ids}
  372.  
  373.  
  374. PROCEDURE out_gl_hp;
  375. VAR i,err : INTEGER;
  376.     slen : STRING[4];
  377. BEGIN
  378.     STR(gout_1.len,slen);          {convert length to string}
  379.     putchr(CHR(27)+'*b'+slen+'W');
  380.     FOR i := 1 TO gout_1.len DO
  381.         putchr(gout_1.chr[i]);
  382.     FOR i := 1 TO gout_1.len DO
  383.         gout_1.chr[i] := CHR(0); {clear graphics line}
  384.     gout_1.len := 0  {reset length}
  385. END; {procedure out_gl_hp}
  386.  
  387.  
  388. PROCEDURE out_gl_ep;
  389. VAR i : INTEGER;
  390.    n1,n2 : CHAR;
  391. BEGIN
  392.     n1 := CHR(gout_1.len MOD 256);
  393.     n2 := CHR(TRUNC(gout_1.len/256));
  394.     CASE graphic_dens OF
  395.         single : BEGIN {60 dpi horz, 72 dpi vert}
  396.                      putchr(CHR(27)+'K'+n1+n2);
  397.                      FOR i := 1 TO gout_1.len DO
  398.                          putchr(gout_1.chr[i]);
  399.                      putchr(CHR(13)+CHR(10))
  400.                  END;
  401.         double : BEGIN {120 dpi horz, 72 dpi vert}
  402.                      putchr(CHR(27)+'L'+n1+n2);
  403.                      FOR i := 1 TO gout_1.len DO
  404.                          putchr(gout_1.chr[i]);
  405.                      putchr(CHR(13)+CHR(10))
  406.                  END;
  407.         triple : BEGIN {120 dpi horz, 144 dpi vert - interleaved lines}
  408.                      putchr(CHR(27)+'3'+CHR(1));      {lf=1/214"}
  409.                      putchr(CHR(27)+'L'+n1+n2);
  410.                      FOR i := 1 TO gout_1.len DO      {first line}
  411.                          putchr(gout_1.chr[i]);
  412.                      putchr(CHR(13)+CHR(10));
  413.                      putchr(CHR(27)+'3'+CHR(23));     {lf=23/214"}
  414.                      putchr(CHR(27)+'L'+n1+n2);
  415.                      FOR i := 1 TO gout_1.len DO      {second line}
  416.                          putchr(gout_2.chr[i]);
  417.                      putchr(CHR(13)+CHR(10))
  418.                  END;
  419.           quad : BEGIN {240 dpi horz, 144 dpi vert - interleaved lines}
  420.                      putchr(CHR(27)+'3'+CHR(1));      {lf=1/214"}
  421.                      putchr(CHR(27)+'Z'+n1+n2);
  422.                      FOR i := 1 TO gout_1.len DO      {first line}
  423.                          putchr(gout_1.chr[i]);
  424.                      putchr(CHR(13)+CHR(10));
  425.                      putchr(CHR(27)+'3'+CHR(23));     {lf=23/214"}
  426.                      putchr(CHR(27)+'Z'+n1+n2);
  427.                      FOR i := 1 TO gout_1.len DO      {second line}
  428.                          putchr(gout_2.chr[i]);
  429.                      putchr(CHR(13)+CHR(10))
  430.                  END
  431.     END; {case}
  432.     FOR i := 1 TO gout_1.len DO BEGIN
  433.         gout_1.chr[i] := CHR(0);
  434.         gout_2.chr[i] := CHR(0)
  435.     END;
  436.     gout_1.len := 0  {reset count}
  437. END;  {procedure out_gl_ep}
  438.  
  439.