home *** CD-ROM | disk | FTP | other *** search
/ Computer Club Elmshorn Atari PD / CCE_PD.iso / pc / 0600 / CCE_0657.ZIP / CCE_0657.PD / EPSON9.C < prev    next >
C/C++ Source or Header  |  1993-10-08  |  5KB  |  203 lines
  1. #include <portab.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4.  
  5. #include "mintbind.h"
  6. #include "treiber.h"
  7.  
  8. /***************************/
  9. /* Version 1.0 von 10.2.93 */
  10. /* Markus Pristovsek       */
  11. /* Nur 240*216 dpi         */
  12. /***************************/
  13. /* Version 1.1 von 1.3.93  */
  14. /* Alle Auflösungen, d.h.  */
  15. /* hor.: 240,120,90,80,72  */
  16. /* ver.: 216,144,72 dpi    */
  17. /***************************/
  18. /* Version 1.2 von 23.8.93 */
  19. /* Drehen per Assembler    */
  20. /***************************/
  21.  
  22. #define BITS_PER_CHAR    20    /* Elite-Dichte! */
  23. #define COMPRESSION 2    /* Von 2 bis 0 (so lassen) */
  24. #define MAX_DPI    240L
  25. #define WEITE 1920
  26.  
  27. #ifdef FAST_PRN
  28. #define WRITE(i,j) ((th>0)?(Fwrite(th,i,j)):(print_block(i,j)))
  29. #endif
  30.  
  31. static UBYTE    dpi_modus[]={ 240, '3', 120, '1', 72, '5' };
  32. static UBYTE    tmp[4096];
  33. static UBYTE    *INIT="\33@\33M\33\63\1";
  34. static UBYTE    *V_STEP="\033f\001x";
  35.  
  36.  
  37.  
  38. void write_compressed( WORD th, UBYTE *tmp, LONG len, long bpc )
  39. {
  40.     LONG    i, j;
  41.  
  42.     if(  len<=0  )
  43.     {
  44.         WRITE( 2L, "\015\012" );
  45.         return;
  46.     }
  47. #if COMPRESSION==2
  48. /* Schneidet nur links und rechts ab */
  49. /* Diese Routine sollte mit nahezu jedem Drucker gehen! */
  50. /* wenn man BITS_PER_CHAR (bpc) kennt! */
  51.  
  52.     for(  i=0;  i<len  &&  tmp[5+i]==0;  i++  )
  53.         ;
  54.     while(  tmp[len+4]==0  &&  len>i  )
  55.         len--;
  56.     if(  i>=len  )
  57.         WRITE( 2L, "\015\012" );
  58.     else
  59.     {
  60.         for(  j=0;  j<i/bpc;  j++  )
  61.             WRITE( 1L, " " );
  62.         j *= bpc;
  63.         len -= j;
  64.         tmp[3] = (UBYTE)(len % 256);
  65.         tmp[4] = (UBYTE)(len / 256);
  66.         WRITE( 5L, tmp );
  67.         WRITE( len, tmp+5+j );
  68.         WRITE( 2L, "\015\012" );
  69.     }
  70. #elif COMPRESSION==1
  71. /* Schneidet nur rechts ab */
  72.     for(  i=len;  i>0  && tmp[i+5]==0;  i--  )
  73.         ;
  74.     len--;
  75.     if(  i==0  )
  76.         WRITE( 2L, "\015\012" );
  77.     else
  78.     {
  79.         len = i;
  80.         tmp[3] = (UBYTE)(len % 256);
  81.         tmp[4] = (UBYTE)(len / 256);
  82.         WRITE( 5L+len, tmp );
  83.         WRITE( 2L, "\015\012" );
  84.     }
  85. #else
  86.     WRITE( 5L+len, tmp );
  87.     WRITE( 2L, "\015\012" );
  88. #endif
  89. }
  90.  
  91.  
  92. WORD    drucke( UBYTE *p, LONG weite, LONG max_zeile, LONG h_dpi, LONG v_dpi )
  93. {
  94.     extern char    tmp_file[256]; /* In Datei drucken? */
  95.  
  96.     LONG    modus, v_modus;
  97.     LONG    max_spalte, zeile, lz, links, linker_rand, rechts;
  98.     LONG    h_len, len, i;
  99.     WORD    th;
  100.  
  101. #ifdef FAST_PRN
  102.     /* Für viel Geschwindigkeit */
  103.     if(  tmp_file[0]>0  ||  open_printer()<0  )
  104. #endif
  105.         th = (WORD)get_tempfile( "n9" );
  106.     if(  th<0  )
  107.         return -1;
  108.  
  109.         /* Auflösung feststellen */
  110.     for(  i=4;  i>0  &&  h_dpi>dpi_modus[i];  i-=2  )
  111.         ;
  112.     modus = dpi_modus[i+1];
  113.     h_dpi = dpi_modus[i];
  114.     if(  v_dpi>175  )
  115.         v_modus = 3;    /* Hochauflösend */
  116.     else if(  v_dpi>110  )
  117.         v_modus = 2;    /* naja... */
  118.     else
  119.         v_modus = 1;    /* und Klötzchengraphic */
  120.  
  121.         /* Ab hier wird es ernst */
  122.     if(  weite<WEITE*h_dpi/MAX_DPI  ) /* Für DINA3 vergrößern! */
  123.         max_spalte = (weite+7)/8;
  124.     else
  125.         max_spalte = (WEITE*h_dpi)/(8*MAX_DPI);
  126.  
  127.     zeile = 0;
  128.     weite = (weite+15L)/16L;
  129.     weite *= 2;
  130.     WRITE( 7L, INIT ); /* Reset + Elite-Dichte + Zeilenabstand 1/216 */
  131.  
  132.     /* Linken Rand festlegen */
  133.     for(  lz=0;  ist_next_leer( p+lz, weite, max_zeile )  &&   lz<max_spalte;  lz++  )
  134.         ;
  135.     linker_rand = lz;
  136.     links = 0;
  137.  
  138.     /* Endlich drucken */
  139.     while(  zeile<max_zeile  )
  140.      {
  141.          /* Leerzeilen überspringen */
  142.          for(  lz=0;  ist_leerzeile( p, max_spalte )  &&  zeile<max_zeile;  lz++, zeile++  )
  143.              p += weite;
  144.  
  145.         lz = links+(lz+lz+lz)/v_modus;
  146.          while(  lz>0  )
  147.         {
  148.             if(  lz>255  )
  149.                 V_STEP[3] = 255;
  150.             else
  151.                 V_STEP[3] = lz;
  152.             WRITE( 4L, V_STEP );
  153.             lz -= 255;
  154.         }
  155.         if(  zeile>=max_zeile  )
  156.             break;
  157.  
  158.             /* Ränder feststellen */
  159.          for(  rechts=max_spalte-1;  ist_next_leer( p+rechts, weite, v_modus*8 )  &&  rechts>linker_rand;  rechts--  )
  160.              ;
  161.          rechts++;
  162.         /* Leerzeichen am linken Rand */
  163.         for(  links=linker_rand;  ist_next_leer( p+links, weite, v_modus*8 )  &&   links<rechts;  links++  )
  164.             ;
  165.         /*  gleichen Anfang festlegen */
  166.         tmp[0] = 27;
  167.         tmp[1] = '*';
  168.         tmp[2] = modus;
  169.         h_len = links*8;
  170.         len = 8*rechts;
  171.         if(  h_len>0  )
  172.             memset( tmp+5, 0, h_len );
  173.         tmp[3] = (UBYTE)(len % 256);
  174.         tmp[4] = (UBYTE)(len / 256);
  175.  
  176.         /* 24 Zeilen (3x Druckkopfhöhe an den Drucker! */
  177.         /* Oder auch weniger bei geringerer Auflösung */
  178.         for(  lz=0;  lz<v_modus;  lz++  )
  179.         {
  180.             block_it( tmp+5+h_len, p+links, (WORD)(rechts-links), weite*v_modus, 1 );
  181.             p += weite;
  182.             write_compressed( th, tmp, len, (h_dpi*BITS_PER_CHAR)/MAX_DPI );
  183.       }
  184.         p += weite*v_modus*7L;
  185.         zeile += (8L*v_modus);
  186.         links = 24-v_modus;
  187.  }
  188.  
  189.         /* Ende Seite */
  190.   if(  2!=WRITE( 1L, " \014" )  )
  191.   {
  192.         /* Platz reichte nicht aus */
  193.         if(  th>0  )
  194.             Fclose( th );
  195.         th = -1;
  196.   }
  197.     if(  tmp_file[0]==0  )
  198.         flush_block();
  199.     return th;
  200. }
  201. /* 17.1.93 */
  202.  
  203.