home *** CD-ROM | disk | FTP | other *** search
/ Gold Fish 3 / goldfish_volume_3.bin / files / text / tex / pastex / source / driver / util / bitmap.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-04-16  |  15.4 KB  |  764 lines
  1. /*
  2. **    This file generated by localize 2.9 (AmigaDOS 2.1) from util/bitmap.c
  3. */
  4. /** bitmap.c **/
  5.  
  6. #include "defines.h"
  7. #include <stdio.h>
  8.  
  9. #include "globals.h"
  10.  
  11. #define NEW_SAVE_IFF_METHOD 1
  12.  
  13. #ifdef ANSI
  14. #  include <stdlib.h>
  15. #  include <string.h>
  16. #  include <stddef.h>
  17. #endif
  18.  
  19. #include "bitmap.h"
  20.  
  21. #include "globals.i"
  22.  
  23. #ifdef ATARI
  24. #  include "dvihand.i"
  25. #  include "atscreen.i"
  26. #endif
  27.  
  28. #ifdef DISPLAY
  29. #  ifdef AMIGA
  30. #    include "amscreen.i"
  31. #  endif
  32. #  include "sbitmap.i"
  33. #else
  34. #  include "prhelp.h"
  35. #  ifdef AMIGA
  36. #    include <clib/exec_protos.h>
  37. #    include <pragmas/exec_pragmas.h>
  38. #    include <graphics/gfx.h>
  39. #    include <graphics/view.h>
  40. #    if !defined(NEW_SAVE_IFF_METHOD)
  41. #     include "iff.h"
  42. #    endif
  43. #    include "amprint.i"
  44. #  endif
  45. #  include "newhard.i"
  46. #  include "bitmap.i"
  47. #  include "prhelp.i"
  48. #endif
  49.  
  50. #define MAX(a,b)    (((a) > (b)) ? (a) : (b))
  51. #define MIN(a,b)    (((a) < (b)) ? (a) : (b))
  52.  
  53.  
  54.  
  55. /*
  56.  * Fuer die locale-Library:
  57.  *
  58.  * Hier duerfen *nur* die MSG_#? Nummern eingebunden werden!
  59.  * Achtung:
  60.  * Es muss/sollte 'multiple-include' erlaubt sein!
  61.  */
  62. #include "local.i"
  63.  
  64. #undef  CATCOMP_ARRAY
  65. #undef  CATCOMP_BLOCK
  66. #undef  CATCOMP_STRINGS
  67. #define CATCOMP_NUMBERS
  68. #include "localstr.h"
  69.  
  70.  
  71.  
  72.  
  73. struct bitmap map;
  74. int PassNo;
  75. long upper_limit;
  76. long lower_limit;
  77. int word_width;
  78. int Pass;        // gibt es in dviprint.c noch *lokal*. Global wird es in special.c gebraucht.
  79. long map_length;
  80.  
  81. #ifdef AMIGA
  82. #  ifdef DISPLAY
  83. #    define NO_GETMEM
  84. #  endif
  85. #endif
  86.  
  87. /** #if !defined(AMIGA) | !defined(DISPLAY) **/
  88.  
  89. #ifndef NO_GETMEM
  90.  
  91. static void GetMemory        Args((int max_length,
  92.                                  int max_width,
  93.                                  long **mem_begin,
  94.                                  int *mem_length,
  95.                               int *divisor));
  96.  
  97.  
  98. #ifndef DISPLAY
  99.   extern short print_width;    /* => DOTS * PASSPERLINE        */
  100.   extern short full_page_in_ram;    /* must the whole page-bitmap into ram?    */
  101.   extern long landscape;        /* print in landscape modus?        */
  102.   extern long iffprint;        /* print to iff-file            */
  103.  
  104.   extern long CurrentPage;    /* the current page number        */
  105.  
  106.   /* wird fuer das IFF-Speichern benoetigt: */
  107.   static UWORD           bw_ctable[2] = { 0x0FFF, 0x0000 };
  108. # if defined(NEW_SAVE_IFF_METHOD)
  109. #  include "iff/ilbmapp.h"
  110.    static struct ILBMInfo ilbm;
  111. # endif
  112. #endif
  113.  
  114.  
  115. static void GetMemory (int max_length, int max_width, long **mem_begin, 
  116.             int *mem_length, int *divisor)
  117. {
  118. #ifndef DISPLAY
  119.   int h;
  120.   unsigned long mem;
  121. #endif
  122.  
  123.   *divisor = 1;
  124.  
  125.   *mem_length = max_length;
  126.   *mem_begin = NULL;
  127.  
  128. #ifndef DISPLAY
  129.   if (
  130. #    ifdef ATARI
  131.       ((Printer->pp_flags & PF_PRINTER) != SLM804) &&
  132. #    endif
  133.       !full_page_in_ram) {
  134.  
  135.     mem = (unsigned long)(*mem_length) * (unsigned long)max_width;    /* memory in bytes */
  136.  
  137.     if (maxbitmapsize != 0L && mem > maxbitmapsize)
  138.      {
  139.       *divisor = (int)((int)(mem / (unsigned long)maxbitmapsize)+1);
  140.      }
  141.  
  142.     while ( *mem_begin == NULL && *mem_length != print_width )
  143.      {
  144.       h =  (max_length / (*divisor)++);
  145.       *mem_length =  h - (h % print_width) + print_width;
  146.       *mem_length = MAX(print_width, *mem_length) ;
  147.  
  148. #endif /* !DISPLAY */
  149.  
  150.       /* hier kein xmalloc, da NULL als Ret. moeglich sein muss! */
  151.       *mem_begin = (long *)malloc((size_t)((size_t)(*mem_length) * (size_t)max_width));
  152.  
  153. #ifndef DISPLAY
  154.      }
  155.  
  156.     (*divisor)--;
  157.   }
  158.   else {
  159.     /* hier kein xmalloc, da NULL als Ret. moeglich sein muss! */
  160.     *mem_begin = (long *)malloc((size_t)((size_t)(*mem_length) * (size_t)max_width));
  161.   }
  162. #endif
  163.  
  164.   if (*mem_begin == NULL)
  165.    {
  166. #ifndef DISPLAY
  167.     if (full_page_in_ram)
  168.      {
  169.       Warning(MSG_DVIP_WHOLE_BITMAP_IN_RAM);
  170.      }
  171. #endif
  172.     Fatal(9, MSG_CANT_ALLOC_BITMAP);    /* special Returncode!!!! */
  173.    }
  174.  
  175. #ifdef DEBUG
  176.   if (DeBug) {
  177.     WarningStr("Allocated %ld bytes for bitmap", (unsigned long)(*mem_length) * (unsigned long)max_width);
  178.   }
  179. #endif
  180. }
  181.  
  182. #endif  /* (NO_GETMEM) !defined(AMIGA) | !defined(DISPLAY) */
  183.  
  184.  
  185. void ClearBitmap(void)
  186. {
  187. #ifdef AMIGA
  188. # ifdef DISPLAY
  189.    clear_bild();
  190. # else
  191.    memset((char *)map.pixptr,(int)0,(unsigned)(map.height*(map.width>>3)));
  192. # endif
  193. #else
  194.   clrbm ((void *)map.pixptr, (int)map.width, (int)map.height);
  195. #endif
  196. }
  197.  
  198.  
  199.  
  200.  
  201. int InitBitmap(int pix_length, int pix_width)
  202. {
  203.   int map_width;
  204.   long *bitmap_ptr;
  205.   int bitmap_length;
  206. #ifdef ATARI
  207. # ifdef DISPLAY
  208.    int flag = 0;
  209. # endif
  210. #endif
  211. #ifdef AMIGA
  212. # ifdef DISPLAY
  213.    AddXpixel = 0;    /* das wird sonst erst nach dem ersten Gebrauch von SAVETY_BITS_X gesetzt! */
  214. # endif
  215. #endif
  216.  
  217.   /* SAVETY_BITS: Sicherheitsrand gegen "Overfull hbox" */
  218.  
  219.   // Das ist etwas hacky, da SAVETY_BITS_X als (hconvresolution+AddXpixel) definiert ist!
  220.   // Daher muss AddXpixel vorher unbedingt auf 0 gesetzt werden.
  221.   // Danach entspricht SAVETY_BITS_X dem Sicherheitsabstand plus dem Rundungsfaktor!!
  222.  
  223.   word_width = (pix_width+SAVETY_BITS_X+31) / 32;        /* (hes) */
  224.   pix_length += SAVETY_BITS_Y; 
  225.   
  226. #ifdef DISPLAY
  227.   AddXpixel = word_width*32 - pix_width - SAVETY_BITS_X;
  228.   /* wieviele Pixel kommen auf Alignment-Gruende hinzu... */
  229. #endif
  230.  
  231.   map_width =  word_width * bytesperlong;
  232. #ifdef ATARI
  233. # ifdef DISPLAY
  234.    if (map.pixptr != NULL) 
  235.     {                    /* we are changing the dvi file */
  236.      xfree(map.pixptr);
  237.      flag = 1;
  238.     }
  239. # endif
  240.    GetMemory (pix_length, map_width, &bitmap_ptr, &bitmap_length, &PassNo);
  241. #endif        /* ATARI */
  242. #ifdef AMIGA
  243. # ifdef DISPLAY
  244.    bitmap_ptr = Init_all (pix_length, map_width);
  245.    bitmap_length = pix_length;
  246.    PassNo = 1;
  247. # else
  248.    if (map.pixptr != NULL) 
  249.     {                    /* we are changing the dvi file */
  250.      xfree(map.pixptr);
  251.      map.pixptr = NULL;
  252.     }
  253.    GetMemory (pix_length, map_width, &bitmap_ptr, &bitmap_length, &PassNo);
  254. # endif
  255. #endif
  256.  
  257.   map.pixptr = bitmap_ptr;
  258.   map.width = map_width * 8;
  259.   map.height = bitmap_length;
  260.  
  261. #ifdef ATARI
  262. # ifdef DISPLAY
  263.    if (flag != 1)
  264.     {
  265.      Init_all(&map);
  266.     }
  267.    else
  268.     {
  269.      Init_some(&map);
  270.     }
  271. # else
  272.    Init_all(&map);
  273. # endif
  274. #endif
  275.  
  276.   upper_limit = 0L;
  277.   lower_limit = (long) bitmap_length;
  278.   ClearBitmap();
  279.   Pass=1;
  280.   map_length = (long)pix_length;
  281.  
  282. #ifdef DEBUG
  283.  
  284.   if (DeBug)
  285.    {
  286.     Warning("Passes: %d, Mem-Length: %d, Mem-Width: %d (in Bytes)",
  287.             PassNo, bitmap_length, map_width);
  288.    }
  289.  
  290. #endif
  291.  
  292. #ifndef DISPLAY
  293.   if (Stats) {
  294.     Logging(MSG_DVIP_PARTS,PassNo);
  295.   }
  296. #endif
  297.  
  298.   return(PassNo);
  299. }
  300.  
  301. #ifdef ATARI
  302.  
  303. static int imgversion;
  304. static int headlength;
  305. static int nrplanes;
  306. static int patlen;
  307. static int pixelwidth;
  308. static int pixelheight;
  309. static int scpixwidth;
  310. static int sclinenr;
  311. static int scbytewidth;
  312.  
  313. static char *muster = NULL;
  314.  
  315. void ReadHeader(FILE *fp)
  316. {
  317.  int i;
  318.  
  319.  imgversion  = (int)NoSignExtend(fp, 2);
  320.  headlength  = (int)NoSignExtend(fp, 2);
  321.  nrplanes    = (int)NoSignExtend(fp, 2);
  322.  patlen      = (int)NoSignExtend(fp, 2);
  323.  pixelwidth  = (int)NoSignExtend(fp, 2);
  324.  pixelheight = (int)NoSignExtend(fp, 2);
  325.  scpixwidth  = (int)NoSignExtend(fp, 2);
  326.  sclinenr    = (int)NoSignExtend(fp, 2);
  327.  
  328.  if (headlength >8)
  329.   {
  330.    Warning("Headlength (%d) too long",headlength);
  331.    for (i=8; i<= headlength; i++)
  332.     {
  333.      fgetc(fp);
  334.     }
  335.   }
  336.  scbytewidth = (scpixwidth+7)/8;
  337.  if (muster != NULL)
  338.   { 
  339.    xfree(muster);
  340.   }
  341.  muster = (char *)xmalloc((size_t) (patlen+2));
  342.  if (muster == NULL)
  343.   {
  344.    Fatal(10, "Not enough memory for pattern");
  345.   }
  346. }
  347.  
  348. #ifdef DEBUG
  349. void PrintHeader(void)
  350. {
  351.  Warning("imgversion: %d",imgversion);
  352.  Warning("headlength: %d",headlength);
  353.  Warning("nrplanes: %d",nrplanes);
  354.  Warning("patlen: %d",patlen);
  355.  Warning("pixelwidth: %d",pixelwidth);
  356.  Warning("pixelheight: %d",pixelheight);
  357.  Warning("scpixwidth: %d",scpixwidth);
  358.  Warning("sclinenr: %d",sclinenr);
  359.  Warning("scbytewidth: %d",scbytewidth);
  360. }
  361. #endif
  362.  
  363. static int xmin, ymin;
  364. static int xmax, ymax;
  365. static char *imgptr;
  366. static int bmwidth;
  367.  
  368. void PutByte(int px, int py, char cont)
  369. {
  370.  if ((px < xmax) && (py <= ymax))
  371.   {
  372.    *(imgptr+((long)bmwidth*((long)py)+(long)px)) = cont;
  373.   }
  374. }
  375.  
  376. char GetByte(int gx, int gy)
  377. {
  378.  if ((gx < xmax) && (gy <= ymax))
  379.   { 
  380.    return(*(imgptr+((long)bmwidth*((long)gy)+(long)gx)));
  381.   }
  382.  else
  383.   {
  384.    return(0);
  385.   }
  386. }
  387.  
  388. void readimg(FILE *imgfile)
  389. {
  390.  int value;
  391.  int bytes;
  392.  int nrlines;
  393.  int rx, ry;
  394.  int i, k;
  395.  
  396.  rx = xmin;
  397.  ry = ymin;
  398.  bytes = 0;
  399.  nrlines=0;
  400.  
  401.  while ((ry <= sclinenr+ymin) && (ry<=ymax))
  402.   {
  403.    if (bytes >= scbytewidth)
  404.     {
  405.      ry++;
  406.      rx = xmin;
  407.      bytes = 0;
  408.      if (nrlines>0)
  409.       {
  410.        for (i=1; i<= scbytewidth; i++)
  411.         {
  412.          PutByte(rx,ry, GetByte( rx, ry-1));
  413.          rx++;
  414.          bytes++;
  415.         }
  416.        nrlines--;
  417.        continue;
  418.       }
  419.     }
  420.          
  421.    value = (int)NoSignExtend(imgfile, 1);
  422.    switch (value)
  423.     {
  424.      case 0x00:
  425.       value = (int)NoSignExtend(imgfile, 1);
  426.       switch (value)
  427.        {
  428.         case 0x00:
  429.          if ((int)NoSignExtend(imgfile, 1) == 0xff)
  430.           {
  431.            nrlines = NoSignExtend(imgfile, 1)-1;
  432.           }
  433.          rx = xmin;
  434.          bytes = 0;
  435.          break;
  436.         default:
  437.          bytes += value*patlen;
  438.          for (i=1; i<=patlen; i++)
  439.           {
  440.            *(muster+i) = (char)NoSignExtend(imgfile,1);
  441.           }
  442.          for (k=1; k<= value; k++)
  443.           {
  444.            for (i=1; i<= patlen; i++)
  445.             {
  446.              PutByte(rx,ry, *(muster+i));
  447.              rx++;
  448.             }
  449.           }
  450.          break;
  451.        }
  452.       break;
  453.      case 0x80:
  454.       value = (int)NoSignExtend(imgfile, 1);
  455.       bytes += value;
  456.       for (i=1; i<= value; i++)
  457.        {
  458.         PutByte(rx,ry,(char)NoSignExtend(imgfile,1));
  459.         rx++;
  460.        }
  461.       break;
  462.      default:
  463.       if (value & 128)
  464.        {
  465.         value -= 128;
  466.         for (i=1; i<=value; i++)
  467.          {
  468.           PutByte(rx,ry, 255);
  469.           rx++;
  470.          }
  471.         bytes += value;
  472.        }
  473.       else
  474.        {
  475.         for (i=1; i<=value; i++)
  476.          {
  477.           PutByte(rx,ry,0);
  478.           rx++;
  479.          }
  480.          bytes += value;
  481.        }
  482.       break;
  483.     }      
  484.   }
  485. } 
  486.    
  487. void PaintImage(char *pfilename, long xakt, long yakt, int maxwidth, int maxheight)
  488. {
  489.  FILE *imgfile;
  490.  int i;
  491.  char *pfn;
  492.  
  493.  pfn = pfilename;
  494.  if (pfn != NULL)
  495.   {
  496.    while (*pfn)
  497.     {
  498.      switch (*pfn)
  499.       {
  500.        case '/':
  501.         *pfn = '\\';
  502.         break;
  503.        case ';':
  504.         *pfn = ':';
  505.         break;
  506.       }
  507.      pfn++;
  508.     }
  509.   }
  510.  Warning( "IMG filename: %s",pfilename);
  511.  imgfile = fopen(pfilename,"rb");
  512.  if (imgfile == NULL)
  513.   {
  514.    Warning( "Can't open IMG file");
  515.    return;
  516.   }
  517.  ReadHeader(imgfile);
  518.  imgptr = (char *)map.pixptr;
  519.  bmwidth = ((int)map.width)/8;
  520.  xmin = (MIN((int)xakt, (int)map.width))/8;
  521.  if (maxwidth !=0)
  522.   {
  523.    xmax = MIN((xmin + maxwidth), ((int)map.width/8));
  524.   }
  525.  else
  526.   {
  527.    xmax = ((int)map.width)/8;
  528.   }
  529.  ymin = MIN((int)yakt, (int)map.height);
  530.  if (maxheight !=0)
  531.   {
  532.    ymax = MIN((ymin + maxheight), (int)map.height);
  533.   }
  534.  else
  535.   {
  536.    ymax = (int)map.height;
  537.   }
  538.  
  539. #ifdef DEBUG
  540.  if (DeBug)
  541.   {
  542.    PrintHeader();
  543.  
  544.    Warning( "xmax: %d ymax: %d",xmax, ymax);
  545.    Warning( "xmin: %d ymin: %d",xmin, ymin);
  546.    Warning( "bmwidth: %d map.width: %ld",bmwidth,map.width);
  547.    Warning( "map.pixptr: %ld map.height: %ld",map.pixptr, map.height);
  548.    Warning( "imgptr: %ld",imgptr);
  549.   }
  550. #endif
  551.  
  552.  readimg(imgfile);
  553.  if (muster != NULL)
  554.   { 
  555.    xfree(muster);
  556.   }
  557.  fclose(imgfile);
  558. }
  559. #endif
  560.  
  561. #ifdef SLOW
  562. void CopyBitArray (long x, long y, int w, int h, unsigned short *p)
  563.                        /* x,y upper left corner (pixels)           */
  564.                        /* w,h height / width of character (pixels) */
  565.                        /* p   pointer to bitmap */
  566. { 
  567. #ifndef ATARI
  568.   int words, sf, of, cmin, cmax, lmin, lmax;
  569.   register int c;
  570.   register int l;
  571.   register long mask;
  572.   register unsigned long item;
  573.   long *addr, *itaddr;
  574. #endif
  575.  
  576. #ifdef DEBUG
  577. /*
  578.   if (DeBug) 
  579.    {
  580.     Message ("CopyBitArray(%ld,%ld,%d,%d,%lX)",x,y,w,h,p);
  581.     Message ("upper limit = %ld, lower limit = %ld",
  582.              upper_limit, lower_limit);
  583.    }
  584. */
  585. #endif
  586.  
  587.   x += hoffset;
  588.   y += voffset;
  589.  
  590. /*
  591.   if (x+(long)w < 0L || x > map.width) 
  592. */
  593.  
  594. #if 0
  595.   if (x < 0L || x+(long)w > map.width) 
  596.    {
  597.     return;
  598.    }
  599. #endif
  600.   if (y >= lower_limit || y+(long)h < upper_limit) 
  601.    {
  602.     return;
  603.    }
  604.  
  605. #ifdef ATARI
  606.  
  607.   AtCopyBitArray(x,y-upper_limit,w,h,p);
  608.  
  609. #else
  610.  
  611.   words = (w + bitsperlong - 1) / bitsperlong;
  612.   sf = x % bitsperlong;
  613.   of = x / bitsperlong;
  614.   lmin = 0; lmax = h;
  615.   cmin = 0; cmax = words;
  616.  
  617.   if (y - upper_limit < 0) 
  618.    {
  619.     lmin = upper_limit - y;
  620.    }
  621.  
  622.   if (y+h >= lower_limit)
  623.    {
  624.     lmax = lower_limit - y;
  625.    }
  626.  
  627.   for (l=lmin; l<lmax; l++)
  628.    {
  629.     addr = map.pixptr + (y - upper_limit + l) * word_width + of;
  630.     itaddr = p + l * words;
  631.     mask = 0;
  632.     for (c=cmin; c<cmax; c++)
  633.      {
  634.       if (p == NULL)
  635.        {
  636.         item = -1;
  637.         if (c == words-1 && w % bitsperlong)
  638.          {
  639.           item <<= (bitsperlong - w % bitsperlong);
  640.          }
  641.        }
  642.       else
  643.        {
  644.         item = *(itaddr + c);
  645.        }
  646.       mask |= item >> sf;
  647.       *(addr + c) |= mask;
  648.       mask = item << (bitsperlong - sf);
  649.      }
  650.     *(addr + c) |= mask;
  651.    }
  652. #endif
  653. }
  654. #endif
  655.  
  656. #ifndef DISPLAY
  657. int PrintPage(void)
  658. {
  659.  if (iffprint) {
  660.    char *ptr;
  661.    int clip = FALSE;
  662.    struct BitMap bmap;
  663.    char iffname[PATHLEN];
  664.  
  665.    if (output_file_name) { /* use the output_file_name as destination */
  666. #if defined(NEW_SAVE_IFF_METHOD)
  667.      clip = *output_file_name == 'C' && output_file_name[1] == 'L' 
  668.         && output_file_name[2] == 'I' && output_file_name[3] == 'P';
  669. #endif
  670.      if (clip) {
  671.        strcpy(iffname, output_file_name);
  672.      }
  673.      else {
  674.        strcpy(iffname, output_file_name);
  675.        ptr = &iffname[strlen(iffname)];        /* append extension */
  676.      }
  677.    }
  678.    else {
  679.      strcpy(iffname, filename);
  680.      ptr = strrchr(iffname, '.');    /* we know there's the .dvi */
  681.    }
  682.  
  683.    if (!clip) sprintf(ptr,".p%d", CurrentPage);
  684.  
  685.    bmap.BytesPerRow = map.width / 8;
  686.    bmap.Rows        = map.height;
  687.    bmap.Flags       = 0;
  688.    bmap.Depth       = 1;
  689.    bmap.Planes[0]   = (PLANEPTR)map.pixptr;
  690.  
  691.    if (clip) {
  692.      Message(MSG_DVIP_SAVE_CLIP, CurrentPage, filename, iffname);
  693.    }
  694.    else {
  695.      Message(MSG_DVIP_SAVE_IFF, CurrentPage, filename, iffname);
  696.    }
  697.  
  698. #if !defined(NEW_SAVE_IFF_METHOD)
  699.    //if (IFFBase == NULL) FatalStr(20, "internal error: IFFBase == NULL!?!");
  700.  
  701.    if (!SaveBitMap(iffname,&bmap,&(bw_ctable[0]),1L)) {
  702.      WarningStr( "Can't write page to iff-file \"%s\"!", iffname);
  703.    }
  704. #else
  705.  
  706.    /*
  707.     * Nun neue IFF-Save Methode die ohne die iff.library auskommt.
  708.     */
  709.    memset(&ilbm, 0, sizeof(ilbm));
  710.    ilbm.ParseInfo.iff = AllocIFF();
  711.    if (!ilbm.ParseInfo.iff) {
  712.      Fatal(10, MSG_NO_MEM);
  713.    }
  714.    if (saveilbm(&ilbm, &bmap, DEFAULT_MONITOR_ID|HIRESLACE_KEY, 
  715.         map.width, map.height, map.width, map.height,
  716.         bw_ctable, 2, 4, 0, 0, NULL, NULL, iffname)) {
  717.      Warning( MSG_DVIP_CANT_SAVE_IFF, iffname);
  718.    }
  719.    FreeIFF(ilbm.ParseInfo.iff);
  720. #endif
  721.    ClearBitmap();
  722.    return 1;
  723.  }
  724.  else {
  725.    if (Pass==PassNo) {
  726.  
  727.      // Drucke Pass Nr. 'Pass'
  728.  
  729.      Hardcopy(&map, (long)(map_length-upper_limit), (Pass == 1), TRUE);        /* last pass */
  730.  
  731.      if (Printer->pp_special & SPECIAL_PREFS) {
  732.        WaitForPrinterOK();    /* warte bis der Streifen fertig gedruckt ist     */
  733.                     /* definiert in amprint.c, wartet auch auf CTRL-C */
  734.      }
  735.  
  736.      ClearBitmap();
  737.  
  738.      Pass=1;
  739.      upper_limit=0L;
  740.      lower_limit=map.height;
  741.      return(1);
  742.    }
  743.    else {
  744.  
  745.      // Drucke Pass Nr. 'Pass'
  746.  
  747.      Hardcopy(&map, map.height, (Pass == 1), FALSE);        /* FALSE : not last pass */
  748.  
  749.      if (Printer->pp_special & SPECIAL_PREFS) {
  750.        WaitForPrinterOK();    /* warte bis der Streifen fertig gedruckt ist     */
  751.                     /* definiert in amprint.c, wartet auch auf CTRL-C */
  752.      }
  753.  
  754.      ClearBitmap();
  755.      Pass++;
  756.      upper_limit += (map.height);
  757.      lower_limit += (map.height);
  758.      return(0);
  759.     }
  760.   }
  761. }
  762. #endif
  763.  
  764.