home *** CD-ROM | disk | FTP | other *** search
/ ftp.barnyard.co.uk / 2015.02.ftp.barnyard.co.uk.tar / ftp.barnyard.co.uk / cpm / walnut-creek-CDROM / BEEHIVE / UTILITYS / PUDD.ARC / PUDD-04.PAS < prev    next >
Pascal/Delphi Source File  |  1991-08-11  |  15KB  |  422 lines
  1. {**************************************************************************
  2.     Print is the procedure used to print the screen to a dot matrix
  3.     printer.  It is commented more extensively to help you modify it
  4.     for your own printer.  It will run without modification on an MX-80
  5.        Concepts:
  6.             Each dot on the screen is repesented by a bit. There are
  7.         8 bits in a byte.  Each horizontal row has 640 dots which
  8.         means 80 bytes.  The procedure GetLine will return a 80 byte
  9.         array from the specified horizontal row.  Since the Epson
  10.         printer uses 8 vertical dots for each graphic line, the
  11.         procedure uses groups of 8 rows to form each line for the
  12.         printer.  In pascal, this means I have used an array of
  13.         array.  That is each screen line is an 80 byte array and
  14.         each printer line is an array of 8 screen lines.
  15.  
  16.         Once a group of screen lines is built a group of 8 bytes
  17.         arranged vertically, are taken off.  This grouping is better
  18.         thought of as an 8x8 bit array.  At this point each byte
  19.         represents a horizontal series of 8 dots.  The printer has
  20.         a vertical set of wires to print 8 dots and must have the
  21.         information passed as a byte representing 8 dots in a vertical
  22.         series.  For this reason the 8x8 array must be turned 90 degrees.
  23.         The initial group of 8 bytes is the var TempBlock.  As TempBlock
  24.         is passed into PrintHead it is turned 90 degrees.  At this point
  25.         PrintHead has info that is all ready for the printer.  It would
  26.         make sense to say
  27.            for i := 1 to 8
  28.              write(lst,PrintHead[i]);
  29.         except Turbo thinks of PrintHead[i] as a number and therefore will
  30.         send ascii digits to the printer which will represent a number.
  31.         Remember (ascii 8) <> 8 in hex or decimal or anything else.  To
  32.         get this information in a raw form to the printer it must be done
  33.         like
  34.             for i := 1 to 8
  35.               write(lst,chr(PrintHead[i]);
  36.  
  37.         After 80 PrintHeads are done, the entire NextLine has been printed.
  38.         At that point a new NextLine is created. Since there are 240 screen
  39.         lines and 8 screen line in each NextLine, the loop printing NextLine
  40.         will repeat 30 times.
  41.  
  42.         The only other thing worth mentioning is that the Epson needs this
  43.         info preceeded by a command which tells it to print a graphic
  44.         row and exactly how long that row will be.  I have also added some
  45.         blanks ahead of each line to center the picture.
  46.  
  47.         I almost forgot, ReadByte is used to look into a byte.  It returns
  48.         a charactor string of 0's and 1's which directly represent the
  49.         byte in question.  This is slower than creating an assembly
  50.         language routine to do the same thing but a lot easier to
  51.         use. With ReadByte you can analize bits using regular pascal
  52.         string procedures.
  53.  
  54.  
  55. ******************************************************************************}
  56. procedure print1;
  57. type EpsonLine = array[1..8] of ScanLine; {............ 8 horiz rows to print }
  58. var  i,j        :integer;
  59.      y          :integer;
  60.      block,column,offset,rowset,rowsingle :integer;
  61.      command    :string[5];   {........a command to send to the printer       }
  62.      NextLine   :EpsonLine;   {.........the printer line, an array of array   }
  63.      PrintHead  :array[1..8] of byte; { a 8x8 or byte by byte block of points }
  64.      TempBlock  :array[1..8] of byte;
  65.      readout    :Blist;
  66.      response   :char;    {.......used to dump out of procedure/ }
  67. begin
  68.  command := #27 + #65 + #8; {.................................set line height }
  69.  writeln(lst,command);
  70.  y := 239;
  71.  rowset := 0;
  72.  repeat
  73.   rowset := rowset + 1;    {...................rows are groups of 8 pixel rows}
  74.                            {           there are 30 rows starting at y := 239 }
  75.  
  76.    offset := 1;
  77.  
  78. {...........................what follows is the part that builds the NextLine }
  79.    for i := 1 to 8 do
  80.       begin
  81.        GetLine(y,ByteList);
  82.        NextLine[i] := ByteList;
  83.        y := y - 1;
  84.       end;   {......NextLine is ready }
  85.  
  86.    command := #27 + #76 + #32 + #3;  {.................set graphic mode }
  87.    write(lst,command);
  88.  
  89.    {......................................................center the picture  }
  90.     for i := 1 to 160 do     {.......................by sending 160 blank dots }
  91.     begin
  92.      write(lst,chr(0));
  93.     end;
  94.  
  95. {.................................what follows will print one entire NextLine }
  96.    for block := 1 to 80 do  {........... 80 horz blocks of 8 dots in each row }
  97.     begin
  98.        for rowsingle := 1 to 8 do {....................build an 8x8 bit array }
  99.         begin
  100.          TempBlock[rowsingle] := NextLine[rowsingle,offset];
  101.         end;
  102.        offset := offset + 1;
  103.  
  104.        {.........what follows will turn the TempBlock 1/4 turn into PrintHead }
  105.        for i := 1 to 8 do
  106.         PrintHead[i] := 0;  {............................initialize printhead }
  107.        for i := 1 to 8 do
  108.         begin
  109.          ReadByte(TempBlock[i],readout); {...................look into a byte }
  110.          for j := 1 to 8 do
  111.           begin
  112.            if copy(readout,j,1) = '1' then    {.......... if any bits are set }
  113.            SetBitB(8-i,PrintHead[j]);         {   then set corresponding bits }
  114.           end;
  115.         end;     {.........................now printhead has 8 bytes to print }
  116.  
  117.      {.....................................................sending to printer }
  118.      for j := 8 downto 1 do
  119.         begin
  120.          write(lst,chr(PrintHead[j]));
  121.         end;
  122.  
  123.     end;   {...........................................horizontal block loop}
  124.    writeln(lst); {.............................bumps paper up for next line }
  125.  delay(300); {....delay needed to pick up keypressed }
  126.        {..the software will still run faster than the printer despite delay }
  127. until (rowset = 30) or (keypressed);
  128.            {......................row loop, another NextLine bites the ink  }
  129.       {..............................................while loop to dump out }
  130.  writeln(lst);
  131.  headline;    {.......restores the menu screen }
  132.  command := #27 + #65 + #9; {..........you should always put your toys back }
  133.  writeln(lst,command);      {                      the way you found them ! }
  134.                             {...ie: restore printer to default line height  }
  135.  
  136. end; {................................................................print }
  137.  
  138.  
  139.  
  140.  
  141. {*****************************************************************************
  142. *  print2 will take print to an Epson MX-80 or similar.  The printout will   *
  143. *  be about 8.89" x 6.67".  The aspect ratio is corrected by using every     *
  144. *  3rd dot 4 times and all other dots 3 times.  This shows up as a slight    *
  145. *  bumpyness in diagnal lines.  The short line width is much less than the   *
  146. *  long line width.                                                          *
  147. *****************************************************************************}
  148. procedure print2;
  149. var  i,j        :integer;
  150.      printcycle :integer;
  151.      point      :integer;
  152.      screenrow  :integer;
  153.      screenlist :ScanLine;
  154.      printline  :array[1..800] of byte absolute $20E3;
  155.      command    :string[4];
  156. begin
  157.  command := #27 + #65 + #8; {.................................set line height }
  158.  writeln(lst,command);
  159.  printcycle := 0;
  160.  repeat
  161.   printcycle := printcycle + 1;
  162.   point := 1;
  163.   for screenrow := 0 to 239 do
  164.    begin
  165.     GetLine(screenrow,screenlist);
  166.     if screenrow mod 3 = 0 then
  167.      begin
  168.       for i := 1 to 4 do
  169.        begin
  170.         printline[point] := screenlist[printcycle];
  171.         point := point + 1;
  172.        end;
  173.      end
  174.     else
  175.      begin
  176.       for i := 1 to 3 do
  177.        begin
  178.         printline[point] := screenlist[printcycle];
  179.         point := point + 1;
  180.        end
  181.      end;
  182.    end;  {screenrow}
  183.    command := #27 + #76 + #32 + #3;  {.................set graphic mode }
  184.    write(lst,command);
  185.    for i := 1 to 800 do
  186.     begin
  187.      write(lst,chr(Printline[i]));
  188.     end;
  189.    writeln(lst);
  190.   delay(180);
  191.  until (printcycle = 80) or (keypressed);
  192.  command := #12;       {.....put paper to top of form }
  193.  write(lst,command);
  194.  command := #27 + #65 + #12; {.....reset the line height to default }
  195.  write(lst,command);
  196. end;
  197.  
  198.  
  199. {*****************************************************************************
  200. *  print3 will take print to an Epson MX-80 or similar.  The printout will   *
  201. *  be centered on 8.5 x 11 paper and will form a 7.5 x 10 image.  With this  *
  202. *  size each dot is a 1/32" x 1/64" rectangle.  The width of the dots comes  *
  203. *  from the fact that each row is printed twice with a 1/72" offset.         *
  204. *  The 7.5" dimension is derived from using each 4th dot 3 times and all     *
  205. *  other dots 4 times.  This is done in the screenrow mod 4 statement.       *
  206. *    The printout takes so long that is is assumed the operator has gone     *
  207. *  to get a beer from the fridge or some such thing.  For this reason the    *
  208. *  bell is rung when the print is finally done.                              *
  209. *****************************************************************************}
  210. procedure print3;
  211. var  i,j        :integer;
  212.      printcycle :integer;
  213.      point      :integer;
  214.      screenrow  :integer;
  215.      screenlist :ScanLine;
  216.      printline  :array[1..900] of byte absolute $20E3;
  217.      command    :string[4];
  218. begin
  219.  command := #27 + #65 + #8; {.................................set line height }
  220.  writeln(lst,command);
  221.  for i := 1 to 2 do         {.....center on the long dimension }
  222.   writeln(lst);
  223.  printcycle := 0;
  224.  repeat
  225.   printcycle := printcycle + 1;
  226.   point := 1;
  227.   for screenrow := 0 to 239 do
  228.    begin
  229.     GetLine(screenrow,screenlist);
  230.     if screenrow mod 4 = 0 then
  231.      begin
  232.       for i := 1 to 3 do
  233.        begin
  234.         printline[point] := screenlist[printcycle];
  235.         point := point + 1;
  236.        end;
  237.      end
  238.     else
  239.      begin
  240.       for i := 1 to 4 do
  241.        begin
  242.         printline[point] := screenlist[printcycle];
  243.         point := point + 1;
  244.        end
  245.      end;
  246.    end;  {screenrow}
  247.    write(lst,'  ');                {.......center on the short dimension }
  248.    command := #27 + #76 + #132 + #3;  {.................set graphic mode }
  249.    write(lst,command);
  250.    for i := 1 to 900 do
  251.     begin
  252.      write(lst,chr(Printline[i]));
  253.     end;
  254.    command := #27 + #65 + #1;       {...........set line height to 1/72" }
  255.    write(lst,command);                                {...........move up}
  256.    writeln(lst);
  257.    write(lst,'  ');                {.......center on the short dimension }
  258.    command := #27 + #76 + #132 + #3;  {.................set graphic mode }
  259.    write(lst,command);
  260.    for i := 1 to 900 do {.....rewrite the same line over again }
  261.     begin
  262.      write(lst,chr(Printline[i]));
  263.     end;
  264.    command := #27 + #65 + #8; {..........................set line height }
  265.    write(lst,command);
  266.    writeln(lst);
  267.    delay(180);             {......this is needed to catch the keypressed }
  268.  until (printcycle = 80) or (keypressed);
  269.  command := #12;                          {.....put paper to top of form }
  270.  write(lst,command);
  271.  command := #27 + #65 + #12;      {.....reset the line height to default }
  272.  write(lst,command);
  273.  command := #7;                                 {......#7 rings the bell }
  274.  for i := 1 to 5 do
  275.   write(lst,command);
  276. end;
  277.  
  278.  
  279. procedure print;
  280.  var response :char;
  281. begin
  282.  clrscr;
  283.  gotoXY(0,10);
  284.  writeln('                  Please select print style.....  ');
  285.  writeln;
  286.  writeln('                    1) Small, horizontal with 17% aspect ratio error');
  287.  writeln;
  288.  writeln('                    2) Large, vertical with correct aspect ratio');
  289.  writeln;
  290.  writeln('                    3) Large, vertical.  Exactly 8.5" x 10" centered');
  291.  writeln('                        on the page.  Correct aspect ratio and');
  292.  writeln('                        fractional representation.');
  293.  repeat
  294.   read(kbd,response);
  295.  until (response = '1') or (response = '2') or (response = '3');
  296.  clrscr;
  297.  gotoXY(10,10);
  298.  write('Make sure printer is on-line');
  299.  gotoXY(10,12);
  300.  write('to cancel print press and hold any key........');
  301.  case response of
  302.   '1': print1;
  303.   '2': print2;
  304.   '3': print3;
  305.  end; {......case }
  306.  HeadLine;
  307. end;
  308.  
  309.  
  310.  
  311.  
  312.  
  313. {****************************************************************************}
  314. {* Display will display a section of text from the stated file              *}
  315. {****************************************************************************}
  316. procedure Display(var fileName:textfile;section:integer);
  317. var line  :string[80];
  318.     i,j   :integer;
  319.     temp  :string[2];
  320.     found :boolean;
  321.     quit  :boolean;
  322. begin
  323.  clrscr;
  324.  found := false;
  325.  quit := false;
  326.  reset(filename);
  327.  repeat
  328.     if EOF(filename) then
  329.      begin
  330.       gotoXY(24,12);
  331.       write('Section requested not found !');
  332.       write(^G);
  333.       delay(2000);
  334.       found := true;
  335.       quit := true;
  336.      end
  337.     else
  338.      begin
  339.       Readln(filename,line);
  340.        if copy(line,1,7) = 'Section' then
  341.         begin
  342.          temp := copy(line,9,3);
  343.          val(temp,i,j);
  344.          delete(line,1,10);
  345.          if section = i then
  346.           found := true
  347.         end;
  348.      end;
  349.   until found;
  350.   i := 0;
  351. if not(quit) then
  352.  begin
  353.   if section <> 0 then
  354.     writeln(line);
  355.   repeat
  356.    repeat
  357.     i := i + 1;
  358.     if not(EOF(filename)) then
  359.       readln(filename,line);
  360.     if not(copy(line,1,7) = 'Section') then
  361.       writeln(line);
  362.     if i = 22 then
  363.      begin
  364.       gotoXY(14,24);
  365.       write('-------------- press key to continue ---------------');
  366.       repeat until keypressed;
  367.       gotoXY(1,24);
  368.       clreol;
  369.       i := 0;
  370.      end;
  371.    until (copy(line,1,7) = 'Section') or EOF(filename);
  372.   until (copy(line,1,7) = 'Section') or EOF(filename);
  373.   if section <> 0 then
  374.    begin
  375.     gotoXY(14,24);
  376.     write('-------------- press key to continue ---------------');
  377.     repeat until keypressed;
  378.     gotoXY(1,24);
  379.     clreol;
  380.    end;
  381.  end;
  382. end; {....................................display }
  383.  
  384.  
  385. {****************************************************************************}
  386. {* Help will use the doc file for on-line help.  To work the doc file must  *}
  387. {* be a normal text file with each catagory starting "Section nn"           *}
  388. {****************************************************************************}
  389. procedure Help;
  390. var DocFile     :textfile;
  391.     i,j         :integer;
  392.     line        :string[81];
  393.     sectionNum  :integer;
  394.     temp        :string[2];
  395. begin    {.........help }
  396.  if Exist('PUDD.DOC') then
  397.   begin
  398.    assign(DocFile,'PUDD.DOC');
  399.    reset(DocFile);
  400.    repeat
  401.      clrscr;
  402.      Display(DocFile,0);
  403.      gotoXY(1,24);
  404.      write('       Enter the section number of your choice......');
  405.      read(temp);
  406.      sectionNum := 0;
  407.      val(temp,SectionNum,i);
  408.      if SectionNum <> 0 then
  409.         Display(DocFile,SectionNum);
  410.     until sectionNum = 0;
  411.   end
  412.  else
  413.   begin
  414.     clrscr;
  415.     gotoXY(24,12);
  416.     write('file PUDD.DOC not found !');
  417.     write(^G);
  418.     delay(2000);
  419.   end;
  420. end;
  421.  
  422.