home *** CD-ROM | disk | FTP | other *** search
/ Gold Fish 3 / goldfish_volume_3.bin / files / text / tex / pastex / source / driver / print / landscap.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-05-20  |  6.0 KB  |  181 lines
  1. /* *** landscap.c *** */
  2.  
  3.  
  4. #include "defines.h"
  5.  
  6. #ifndef AMIGA
  7. #  define __stdargs
  8. #endif
  9.  
  10. #include <stdio.h>
  11. #include <exec/types.h>
  12. #include <stdlib.h>
  13.  
  14. #ifdef ATARI
  15. #  include <tos.h>
  16. #  define Chk_Abort()        /* hope this works */
  17. #endif
  18.  
  19. #ifdef AMIGA
  20. #  include <dos.h>
  21. #endif
  22.  
  23. #include "globals.h"
  24. #include "bitmap.h"
  25. #include "prhelp.h"
  26.  
  27. #include "globals.i"
  28.  
  29. #define BITS   7                      /* höchste vorkommende Bit-Position */
  30.  
  31. static UBYTE Mask[8] ={               /* zum ausmaskieren der einzelnen   */
  32.                0x80,0x40,0x20,0x10,   /* Bits, müßte bei größerem BITS    */
  33.                0x08,0x04,0x02,0x01};  /* erweitert werden, bringt nichts  */
  34.  
  35. /*
  36.   Querdruck dreht die übergebene Bitmap um 90 Grad gegen den Uhrzeigersinn
  37.   Aus Speicherplatzgründen wird nur Streifenweise gearbeitet. Dieser Streifen
  38.   wird als Bitmap der Druckfunktion weitergereicht.
  39.  
  40.   *bmap    Zeiger auf die zu drehende Bitmap-Struktur
  41.   lineno   Breite des Streifens (in Bildpunkte) Minimum 8, 24, 48 je nach
  42.            Drucker und Auflösung, damit immer eine Druckzeile voll wird
  43.   draft    wird an Druckfunktion weitergereicht (hat nur für HP_DeskJet
  44.            Bedeutung)
  45.  
  46.   *Druck_Bitimage   Zeiger auf die zu verwendende Hardcopy-Funktion
  47.                     (aus kompatibilitäts Gründen alle mit drei Argumenten)
  48.  
  49.   __stdargs  Die Funktion wird nur einmal aufgerufen!
  50. */
  51.  
  52. void __stdargs Querdruck(struct bitmap *bmap, long lineno, int draft,
  53.                  void (*Druck_Bitimage) (struct bitmap *bmap, long lineno,
  54.                  int draft))
  55. {
  56.  
  57.   /*
  58.     Nach Einsicht in den Code vom Global Optimizer würde ich sagen:
  59.     'besser so'
  60.     Ansonsten einfach mal drauf ansetzen und messen was passiert.
  61.   */
  62.   register int i, j, k;
  63.   int lbit, rbit;
  64.   register UBYTE dNull, dEins;
  65.   long Bwidth;                   /* wenn UBYTE Bwidth => 8*255/(360/in) = 5.7in maximale Breite ?? */
  66.   UBYTE *ptrbuf, *block, *spalte;
  67.   register UBYTE *ptr, *ende;
  68.  
  69.   // bm_width_rounded gibt die gerundede Breite der Bitmap in *Pixel* an
  70.   const int bm_width_rounded = ((bmap->height + (WP_GROESSE-1)) / WP_GROESSE) * WP_GROESSE;
  71.   // round_value gibt an, um wieviel Bytes die Map groesser wird, als wenn WP_GROESSE 8 waere
  72.   const int round_value      = (bm_width_rounded - bmap->height) / 8;    // (abrunden)
  73.  
  74.   struct bitmap Vmap;            /* Bitmap-Struktur für Gedrehtes */
  75.   long l_count = 0;              /* Streifenzähler                */
  76.   
  77.  
  78.   lineno >>=3;                   /* in Bytes */
  79.   if (lineno < 1) {lineno = 1;}  /* nur für den Fall */
  80.  
  81.                                  /* Speicherplatz für gedrehte Bitmap */
  82.   Vmap.pixptr = (long *) xmalloc(lineno * bm_width_rounded);
  83.  
  84.   Vmap.width  = bm_width_rounded;            /* umdrehen und auf ganze */
  85.   Vmap.height = bmap->width;                /* Bytes runden           */
  86.  
  87.   Bwidth = (long)(bmap->width>>3);          /* Breite in Bytes */
  88.   ptrbuf = (UBYTE *)Vmap.pixptr;            /* Zeiger Ablage Anfang */
  89.  
  90.   /*
  91.     Das Bitimage wird Spaltenweise von hinten abgearbeitet, nur
  92.     so ist es nach Drehung um 90 Grad gegen den Uhrzeigersinn
  93.     auch seitenrichtig.
  94.     Eine Spalte ist dabei 8 Bit breit, eine Bildzeile muß also
  95.     Byte-Bündig sein!
  96.     Ein Block sind 8 Byte im Bitimage der Seite untereinander,
  97.     haben also im Speicher einen Abstand von Bwidth.
  98.     Es wird im Block zuerst das letzte Bit bearbeitet, dann der
  99.     nächste Block in der Spalte angesprungen, das letzte Bit ... ,
  100.     bis alle Blöcke durch sind. Dann geht es im ersten Block der
  101.     letzten Spalte mit dem vorletzten Bit weiter.
  102.     So hangelt man sich bit- und spaltenweise nach vorne
  103.   */
  104.  
  105.   for (spalte = (UBYTE *)bmap->pixptr+(Bwidth-1),   /* Spalte im Bitimage */
  106.        ende   = (UBYTE *)bmap->pixptr+(Bwidth*bmap->height)-1;
  107.        spalte >= (UBYTE *)bmap->pixptr;
  108.        spalte--, ende--) {
  109.  
  110.     /*
  111.       ende muß gemerkt werden, da die Höhe der Ausgangs-Bitmap
  112.       nicht immer in Byte-Grenzen passen wird
  113.     */
  114.  
  115.     Chk_Abort();
  116.  
  117.     for (i=BITS; i>=0; i--) {        /* Bit in der Spalte */
  118.       for (k=0,block=spalte; k<bmap->height; k+=8,block+=Bwidth<<3) {
  119.                                      /* Block in der Spalte */
  120.  
  121.         lbit = i;                    /* Ausgangswert Links-Schieber */
  122.         rbit = BITS-i;               /* Ausgangswert Rechts-Schieber */
  123.         dEins = 0;
  124.         ptr  = block;                /* Init */
  125.  
  126.         /*
  127.           holen, ausmaskieren für alles was links geschoben
  128.           werden muß
  129.         */
  130.         for (j=lbit; (j>0 && ptr <= ende); j--, ptr+=Bwidth){
  131.           dNull = *ptr & Mask[i];
  132.           dNull <<= j;
  133.           dEins |= dNull;
  134.         }
  135.  
  136.         /*
  137.           s.o. ohne schieben
  138.         */
  139.         if (ptr <= ende) {
  140.           dNull = *ptr & Mask[i];
  141.           dEins |= dNull;
  142.           ptr+=Bwidth;
  143.         }
  144.  
  145.         /*
  146.           s.o. rechts schieben
  147.         */
  148.         for (j=1; (j<=rbit && ptr <= ende); j++, ptr+=Bwidth){
  149.           dNull = *ptr & Mask[i];
  150.           dNull >>= j;
  151.           dEins |= dNull;
  152.         }
  153.  
  154.         *ptrbuf = dEins;                   /* hinein in die Ablage */
  155.         ptrbuf++;
  156.       }  /* Block in der Spalte */
  157.  
  158.       // da mittels WP_TYP die Bitmap Breite gerundet wurde und so groesser geworden
  159.       // sein kann (als bei Rundung durch char), muss nun der Rest noch dazu addiert werden.
  160.       ptrbuf += round_value;    // ptrbuf muss char * sein!
  161.  
  162.     }  /* Bit in der Spalte */
  163.     /* jetzt ist die gesamte Spalte durch, ab zum drucken */
  164.  
  165.   
  166.     l_count++;                                /* Spalte ein Byte breiter */
  167.     if (l_count == lineno) {                  /* Spaltenbreite zusammen? */
  168.       Druck_Bitimage(&Vmap,lineno*8, draft);
  169.       l_count = 0;
  170.       ptrbuf = (UBYTE *)Vmap.pixptr;          /* Zeiger Ablage Anfang    */
  171.     }
  172.  
  173.   }  /* Spalte im Bitimage */
  174.  
  175.   if (l_count > 0) {                        /* noch eine unvollständige */
  176.     Druck_Bitimage(&Vmap,l_count*8, draft); /* Spalte übrig ? Muß auch  */
  177.   }                                         /* gedruckt werden          */
  178.  
  179.   xfree(Vmap.pixptr);                       /* weg damit */
  180. }
  181.