home *** CD-ROM | disk | FTP | other *** search
/ Computer Club Elmshorn Atari PD / CCE_PD.iso / pc / 0600 / CCE_0657.ZIP / CCE_0657.PD / HP_90.C < prev    next >
C/C++ Source or Header  |  1993-09-06  |  5KB  |  242 lines
  1. /*********************************************************************
  2. ****    Universaltreiber für HP-kompatible Drucker                ****
  3. *********************************************************************/
  4.  
  5. /* Siehe auch Datei JP350WS.C */
  6.  
  7. #include <portab.h>
  8. #include <mintbind.h>
  9. #include <atarierr.h>
  10.  
  11. #include <stdlib.h>
  12. #include <string.h>
  13.  
  14. #include <treiber.h>
  15.  
  16.  
  17. /********************************************************************/
  18. /* Setzt die freien Werte auf Standartwerte */
  19.  
  20. #ifndef OBEN    /* Wenn noch kein oberer Rand definiert */
  21. #define OBEN 0L
  22. #endif
  23.  
  24. #ifndef LINKS    /* Wenn noch kein linker Rand definiert */
  25. #define LINKS 0L
  26. #endif
  27.  
  28. #ifndef MAX_DPI    /* Wenn keine maximale Auflösung definiert */
  29. #define MAX_DPI 1200L
  30. #endif
  31.  
  32. #ifndef BREITE    /* druckbare Breite (in Pixel) */
  33. #define BREITE ((2336L*MAX_DPI)/300L)
  34. #endif
  35.  
  36. #ifndef HOEHE        /* druckbare Höhe (in Pixel) */
  37. #define HOEHE ((3386L*MAX_DPI)/300L)
  38. #endif
  39.  
  40. #ifdef FAST_PRN#define WRITE(i,j) ((th>0)?(Fwrite(th,i,j)):(print_block(i,j)))#endif
  41. /********************************************************************/
  42.  
  43.  
  44.  
  45. /* Findet entweder Wiederholung (TRUE) oder nichts */
  46. WORD    find_next_same( WORD *rep, UBYTE *p, LONG limit )
  47. {
  48.     WORD    i;
  49.  
  50.         /* Spezialfälle */
  51.     if(  limit<1  )
  52.     {
  53.         *rep = 1;
  54.         return FALSE;
  55.     }
  56.     if( limit<2  &&  p[0]==p[1]  )
  57.     {
  58.         *rep = 2;
  59.         return TRUE;
  60.     }
  61.  
  62.         /* Sonst getrennt */
  63.     if(  p[0]==p[1]  &&  p[1]==p[2]  )
  64.     {
  65.         /* Abstand zum nächsten Ungleichen... */
  66.         i = 3;
  67.         while(  i<128  &&  i<limit  &&  p[0]==p[i]  )
  68.             i++;
  69.         *rep = i;
  70.         return TRUE;
  71.     }
  72.     else
  73.     {
  74.         /* ... bzw. Gleichen ermitteln */
  75.         i = 0;
  76.         while(  i<128  &&  i<limit  &&  !(p[i]==p[i+1]  &&  p[i]==p[i+2])  )
  77.             i++;
  78.         *rep = i;
  79.         return FALSE;
  80.     }
  81. }
  82. /* 17.1.93 */
  83.  
  84.  
  85. static UBYTE    druckzeile[1024];
  86.  
  87.  
  88. WORD    drucke( UBYTE *p, LONG weite, LONG max_zeile, LONG h_dpi, LONG v_dpi )
  89. {
  90.     UBYTE    tmp1[50], tmp2[(BREITE+15)/7];
  91.     LONG    rechts, i, j, x, v_hoehe, v_weite;
  92.     WORD    th, rep, modus=0/* Komprimiert oder nicht? */;
  93.     extern char    tmp_file[256]; /* In Datei drucken? */
  94.  
  95. #ifdef FAST_PRN    /* Für viel Geschwindigkeit = sinnvoll großer Puffer */    if(  tmp_file[0]>0  ||  open_printer()<0  )#endif        th = (WORD)get_tempfile( "hpq" );    if(  th<0  )        return -1;    if(  h_dpi>700  )
  96.         h_dpi = 1200;
  97.     else if(  h_dpi>350  )
  98.         h_dpi = 600;
  99.     else if(  h_dpi>175  )
  100.         h_dpi = 300;
  101.     else if(  h_dpi>110  )
  102.         h_dpi = 150;
  103.     else if(  h_dpi>80  )
  104.         h_dpi = 100;
  105.     else
  106.         h_dpi = 75;
  107.  
  108.         /* Unsinnige Werte werden als Maximum angenommen */
  109.     if(  h_dpi<=0  ||  h_dpi>MAX_DPI  )
  110.         h_dpi = MAX_DPI;
  111.  
  112.     i = (OBEN*h_dpi)/MAX_DPI;
  113.     p += ((weite+15)/16)*2*i;    /* Nicht druckbare Ränder*/
  114.  
  115.     v_weite = weite;
  116.     if(  v_weite>(HOEHE*h_dpi)/MAX_DPI  )
  117.         v_weite = (HOEHE*h_dpi)/MAX_DPI;
  118.     weite = ((weite+15)/16)*2;
  119.  
  120.     max_zeile = max_zeile-i-1;
  121.     v_hoehe = max_zeile;
  122.     if(  v_hoehe>(BREITE*h_dpi)/MAX_DPI  )
  123.         v_hoehe = (BREITE*h_dpi)/MAX_DPI;
  124.     max_zeile = v_hoehe;
  125.  
  126.         /* Ränder feststellen */
  127.     for(  x=0;  x*8<v_hoehe  &&  ist_next_leer( p+x, weite, max_zeile );  x++  )
  128.         ;
  129.  
  130.     x *= 8;
  131.     if(  x>=v_hoehe  )
  132.     {
  133.         /* Seite leer */
  134.         WRITE( 5L, " \33*rB\14" ); /*FF*/
  135.         flush_block();
  136.         return 0;
  137.     }
  138.  
  139.         /* In die obere Ecke */
  140.     WRITE( 26, " \33*p0Y\33*p-300Y\33*p0X\33*p-300X" );
  141.         /* Grafikdruck Anfang */
  142.     strcpy( tmp1, "\33&100L\33*rB\33*t" );
  143.         /* Grafikauflösung festlegen */
  144.     ltoa( h_dpi, tmp1+13, 10 );
  145.     strcat( tmp1, "R\33*r" );
  146.     WRITE( strlen(tmp1), tmp1 );
  147.         /* Grafikweite festlegen */
  148.     ltoa( v_hoehe, tmp1, 10 );
  149.     v_hoehe = (v_hoehe+7)/8+1;
  150.     strcat( tmp1, "s0A" );
  151.     WRITE( strlen(tmp1), tmp1 );
  152.  
  153.  
  154.     if(  x-LINKS>0  )
  155.     {
  156.         strcpy( tmp1, "\33*b" );
  157.         ltoa( x, tmp1+3, 10 );
  158.         strcat( tmp1, "Y" );
  159.         WRITE( strlen(tmp1), tmp1 );
  160.     }
  161.     else
  162.         x = LINKS;
  163.     rechts = 0;
  164.  
  165.     while(  x<v_weite  )
  166.     {
  167.         if(  x%8==0  )
  168.         {
  169.             UBYTE    *q=p+(x/8);
  170.  
  171.             i = 0;
  172.             while(  i<max_zeile  &&  *q==0  )
  173.             {
  174.                 i++;
  175.                 q += weite;
  176.             }
  177.             if(  i>=max_zeile  )
  178.             {
  179.                 WRITE( 5, "\33*b8Y" );
  180.                 x += 8;
  181.                 continue;
  182.             }
  183.             rechts = 0;
  184.             if(  i>7  )
  185.                 rechts = (i/8)-1;
  186.         }
  187.         drehe_90( p+rechts*8*weite, tmp2, weite, v_hoehe-rechts, x );
  188.  
  189.         /* Wir komprimieren */
  190.         for(  i=0, j=0;  i<v_hoehe-rechts  &&  j<v_hoehe-rechts;  /*Nichts*/  )
  191.         {
  192.             if(  find_next_same( &rep, tmp2+i, v_hoehe-i-rechts )  )
  193.             {
  194.                 /* Gleiche */
  195.                 druckzeile[j++] = 1-rep;
  196.                 druckzeile[j++] = tmp2[i];
  197.                 i += rep;
  198.             }
  199.             else
  200.             {
  201.                 /* Ungleiche */
  202.                 druckzeile[j++] = rep-1;
  203.                 while(  rep-->0  )
  204.                     druckzeile[j++] = tmp2[i++];
  205.             }
  206.         }
  207.  
  208.             /* Und nun den interessanten Rest */
  209.         if(  j<v_hoehe-rechts  )
  210.         {
  211.             /* Komprimieren brachte etwas */
  212.             strcpy( tmp1, "\33*b2m" );
  213.             ltoa( j, tmp1+5-modus, 10 );
  214.             strcat( tmp1, "W" );
  215.             WRITE( strlen(tmp1), tmp1 );
  216.             WRITE( j, druckzeile );
  217.             modus = 2;
  218.         }
  219.         else
  220.         {
  221.             /* Komprimieren brachte nichts */
  222.             j = v_hoehe-rechts;
  223.             strcpy( tmp1, "\33*b0m" );
  224.             ltoa( j, tmp1+3+modus, 10 );
  225.             strcat( tmp1, "W" );
  226.             WRITE( strlen(tmp1), tmp1 );
  227.             WRITE( j, tmp2 );
  228.             modus = 0;
  229.         }
  230.  
  231.         x++;    /* Nächste Zeile */
  232.     }
  233.  
  234.     /* Ende Grafikmodus */
  235.     /* Ende Seite */    if(  5!=WRITE( 5L, "\33*rB\14" )  )
  236.     {        /* Platz reichte nicht aus */        if(  th>0  )            Fclose( th );        th = -1;    }    if(  tmp_file[0]==0  )        flush_block();
  237.     return 0;
  238. }
  239. /* 22.1.93 */
  240.  
  241.  
  242.