home *** CD-ROM | disk | FTP | other *** search
/ Computer Club Elmshorn Atari PD / CCE_PD.iso / pc / 0600 / CCE_0657.ZIP / CCE_0657.PD / 24NADEL.C next >
Text File  |  1993-06-24  |  5KB  |  215 lines
  1. /*************************************************************************
  2. ****    Kern des universellen 24-Nadeltreibers                                                    ****
  3. ****    Sollte von Headerdatei aufgerufen werden                                                ****
  4. *************************************************************************/
  5.  
  6. #include <portab.h>
  7. #include <mintbind.h>
  8. #include <stdlib.h>
  9. #include <string.h>
  10.  
  11. #include "treiber.h"
  12.  
  13.  
  14. #ifndef STEP_360
  15. #error "Bitte diese Datei nur per #include lesen!"
  16. #endif
  17.  
  18.  
  19. UBYTE     *INIT             = "\033@\033x\1";
  20. UBYTE     *GRAFIK_180 = "\033*\047\0";
  21. UBYTE     *GRAFIK_360 = "\033*\050\0";
  22. UBYTE     *STEP_180     = "\033\063";
  23.  
  24.  
  25.  
  26.  
  27. VOID    block_out( UBYTE *dest, UBYTE *src, WORD ende, LONG offset, WORD hoehe )
  28. {
  29.     WORD        i, j, k;
  30. #if 0
  31.     if(  hoehe != 0  && hoehe < 8)
  32.     {
  33.         /* Nur wenn es wirklich nötig ist die langsame Bitpfriemelei */
  34.         for(    i=0;    i<=ende;    i++  )
  35.         {
  36.             /* Byte-Pfriemeln */
  37.             for(    j=7;    j>=0;  j--    )
  38.             {
  39.                 *dest = 0;
  40.                 for(    k=0;    k<hoehe;    k++  )
  41.                     *dest |= ((src[0+k*offset]>>j)&1)<<(7-k);
  42.             }
  43.             dest++;
  44.             src++;
  45.         }
  46.         return;
  47.     }
  48. #endif
  49.     /* So ist wesentlich schneller */
  50.     for(    i=0;    i<=ende;    i++  )
  51.     {
  52.         /* Byte-Pfriemeln */
  53.         for(    j=7;    j>=0;  j--    )
  54.         {
  55.             *dest = 0;
  56.             *dest |= ((src[0]>>j)&1)<<7;
  57.             *dest |= ((src[offset]>>j)&1)<<6;
  58.             *dest |= ((src[offset*2]>>j)&1)<<5;
  59.             *dest |= ((src[offset*3]>>j)&1)<<4;
  60.             *dest |= ((src[offset*4]>>j)&1)<<3;
  61.             *dest |= ((src[offset*5]>>j)&1)<<2;
  62.             *dest |= ((src[offset*6]>>j)&1)<<1;
  63.             *dest |= (src[offset*7]>>j)&1;
  64.             dest++;
  65.             *dest |= ((src[offset*8]>>j)&1)<<7;
  66.             *dest |= ((src[offset*9]>>j)&1)<<6;
  67.             *dest |= ((src[offset*10]>>j)&1)<<5;
  68.             *dest |= ((src[offset*11]>>j)&1)<<4;
  69.             *dest |= ((src[offset*12]>>j)&1)<<3;
  70.             *dest |= ((src[offset*13]>>j)&1)<<2;
  71.             *dest |= ((src[offset*14]>>j)&1)<<1;
  72.             *dest |= (src[offset*15]>>j)&1;
  73.             dest++;
  74.             *dest |= ((src[offset*16]>>j)&1)<<7;
  75.             *dest |= ((src[offset*17]>>j)&1)<<6;
  76.             *dest |= ((src[offset*18]>>j)&1)<<5;
  77.             *dest |= ((src[offset*19]>>j)&1)<<4;
  78.             *dest |= ((src[offset*20]>>j)&1)<<3;
  79.             *dest |= ((src[offset*21]>>j)&1)<<2;
  80.             *dest |= ((src[offset*22]>>j)&1)<<1;
  81.             *dest |= (src[offset*23]>>j)&1;
  82.             dest++;
  83.         }
  84.         src++;
  85.     }
  86. }
  87. /* 20.1.93 */
  88.  
  89.  
  90.  
  91. /* Zur Zeit wird fast nicht optimiert; Zum einen sollte jetzt fast jeder
  92.  * Drucker arbeiten; Zum anderen habe ich keinen 24-Nadeldrucker zum Testen
  93.  * Bastler sind hier zur Arbeit aufgefordert!
  94.  */
  95. static UBYTE    tmp[8192];
  96.  
  97. WORD    drucke( UBYTE *p, LONG weite, LONG max_zeile, LONG h_dpi, LONG v_dpi )
  98. {
  99.     UBYTE v_modus, *v_step, *grafik;
  100.     LONG    max_spalte, zeile, lz, links, linker_rand, rechts;
  101.     LONG    h_len, len, i;
  102.     WORD    th;
  103.  
  104.     th = (WORD)get_tempfile( "n24" );
  105.     if(  th<0  )
  106.         return -1;
  107.  
  108.     grafik = GRAFIK_360;
  109.     v_step = STEP_360;
  110.     if(  h_dpi<200    )
  111.     {
  112.         grafik = GRAFIK_180;
  113.         h_dpi = 180;
  114.     }
  115.     else
  116.         h_dpi = 360;
  117.  
  118.     if(  v_dpi<200    )
  119.     {
  120.         v_step = STEP_180;
  121.         v_dpi = 180;
  122.     }
  123.     else
  124.         v_dpi = 360;
  125.  
  126.         /* Ab hier wird es ernst */
  127.     if(  weite<WEITE*h_dpi/360L  ) /* Für DINA3 vergrößern! */
  128.         max_spalte = (weite+7)/8;
  129.     else
  130.         max_spalte = WEITE*h_dpi/(360*8L);
  131.  
  132.         /* Diverse Variablen initialisieren */
  133.     zeile = 0;
  134.     weite = (weite+15L)/16L;
  135.     weite *= 2;
  136.     p += weite*OBEN + LINKS;    /* Nicht druckbare Ränder*/
  137.     max_zeile -= OBEN;
  138.     if(  HOEHE>0    &&    max_zeile>HOEHE  )
  139.         max_zeile = HOEHE;
  140.     lz = 0;
  141.     v_modus = v_dpi/180;
  142.     linker_rand = 0;
  143.  
  144.     Fwrite( th, strlen(INIT), INIT ); /* Reset + LQ-Mode */
  145.  
  146.     /* Endlich drucken */
  147.     max_zeile--;
  148.     while(    zeile<max_zeile )
  149.     {
  150.         /* Leerzeilen überspringen */
  151.         for(    ;  ist_leerzeile( p, max_spalte )  &&  zeile<(max_zeile-1);  lz++, zeile++    )
  152.             p += weite;
  153.  
  154.         while(    lz>0    )
  155.         {
  156.             Fwrite( th, 2L, v_step );
  157.             if(  lz>255  )
  158.                 Fwrite( th, 1L, "\xFF" );
  159.             else
  160.                 Fwrite( th, 1L, (&lz)+3 );    /* Long = 4 Bytes! */
  161.             Fwrite( th, 1L, "\xA" );
  162.             lz -= 255;
  163.         }
  164.         if(  zeile==max_zeile  )
  165.             break;
  166.  
  167.             /* Ränder feststellen */
  168.         for(    rechts=max_spalte-1;    ist_next_leer( p+rechts, weite, v_modus*24 )    &&    rechts>linker_rand;  rechts--  )
  169.             ;
  170.         rechts++;
  171.         links = 0;
  172.         len = rechts;
  173.         h_len = 5;
  174.         strcpy( tmp, grafik );
  175.         tmp[3] = (UBYTE)(8*(rechts-links) % 256);
  176.         tmp[4] = (UBYTE)(8*(rechts-links) / 256);
  177.         if(  len>0    )
  178.             memset( tmp+h_len, 0, 24*len );
  179.  
  180.         /* Oder auch weniger bei geringerer Auflösung */
  181.         for(    lz=0;  lz<v_modus;    zeile++  )
  182.         {
  183.             i = (max_zeile - 1 - zeile)/v_modus;
  184.             i = 24-i;
  185.             if(  i<0    )
  186.                 i = 0;
  187.             block_out( tmp+h_len, p+links, (WORD)(rechts-links), weite*v_modus, (WORD)i );
  188.             Fwrite( th, h_len+24*(rechts-links), tmp );
  189.             Fwrite( th, 1L, "\xD" );
  190.             p += weite;
  191.  
  192.             if(  ++lz<v_modus  )
  193.             {
  194.                 Fwrite( th, 2L, v_step );
  195.                 Fwrite( th, 2L, "\1\xA" );
  196.             }
  197.         }
  198.         lz = 1+23*v_modus;    /* +eine Zeile mehr überspringen */
  199.         p += (weite*lz);
  200.         zeile += lz;
  201.  }
  202.  
  203.         /* Ende Seite */
  204.     if(  1!=Fwrite( th, 1L, "\xC" )  )
  205.     {
  206.         /* Platz reichte nicht aus */
  207.         Fclose( th );
  208.         return -1;
  209.     }
  210.     return th;
  211. }
  212. /* 17.1.93 */
  213. /* Viele kleine Fehler gefunden und gefixt. 6.5.93 Marcus Haebler */
  214.  
  215.