home *** CD-ROM | disk | FTP | other *** search
/ Gold Fish 3 / goldfish_volume_3.bin / files / text / tex / pastex / source / driver / show / amiga / fullpage.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-06-07  |  7.5 KB  |  281 lines
  1. /* fullpage.c */
  2.  
  3. #include "defines.h"
  4.  
  5.  
  6. /* #define DOS_DOSASL_H */
  7.  
  8. #include <sprof.h>
  9.  
  10. #include <stdio.h>
  11. #include <signal.h>
  12. #include <dos.h>
  13.  
  14.  
  15. #include <exec/types.h>
  16. #include <intuition/intuition.h>
  17.  
  18. #ifdef AZTEC_C
  19. #  include <functions.h>
  20. #endif
  21.  
  22. #include "globals.h"
  23.  
  24. #ifdef ANSI
  25. #  include <string.h>
  26. #  include <stdlib.h>
  27. #endif
  28.  
  29. #include <clib/intuition_protos.h>
  30. #include <clib/graphics_protos.h>
  31.  
  32. #include <pragmas/intuition_pragmas.h>
  33. #include <pragmas/diskfont_pragmas.h>
  34.  
  35. #include "version.h"
  36. #include "amscreen.h"
  37.  
  38. extern struct BitMap    BitMapWin;    // amscreen.c
  39.  
  40.  
  41. #include "globals.i"
  42.  
  43. /*
  44.  * Fuer die locale-Library:
  45.  *
  46.  * Hier duerfen *nur* die MSG_#? Nummern eingebunden werden!
  47.  * Achtung:
  48.  * Es muss/sollte 'multiple-include' erlaubt sein!
  49.  */
  50. #include "local.i"
  51.  
  52. #undef  CATCOMP_ARRAY
  53. #undef  CATCOMP_BLOCK
  54. #undef  CATCOMP_STRINGS
  55. #define CATCOMP_NUMBERS
  56. #include "localstr.h"
  57.  
  58.  
  59. #define FPAGE_ABS HeightWinTitle
  60.  
  61. void make_full_page(struct RastPort *rp, int xk, int yk,
  62.             int p_width, int p_height, unsigned short *fpage)
  63. {
  64.   register unsigned long mask, erg;
  65.   long j, bitpos, mask_anf, mask_width;
  66.   long k, i, adr;
  67.   int weite_x, rest_weite_x, weite_y, rest_weite_y, merk_rest_weite_x;
  68.   int vert_rest_x, vert_rest_y, hilf_vert_x, hilf_vert_y;
  69.   long zeilenlaenge;
  70.   unsigned short *zeile, *anf_zeile, copy_mask, *write_pointer, *start_showmap;
  71.   int start_row, akt_row, length_row;
  72.   int yskip, xskip, add_y /*, add_x*/;
  73.   /* int zeilen = 0; */    /* fuer DEBUG Zwecke... */
  74.  
  75.   if (p_width == 0) Fatal(20,MSG_INTERNAL_ERROR);
  76.  
  77.   weite_x = wx / p_width;
  78.   merk_rest_weite_x = rest_weite_x = (wx % p_width);
  79.  
  80.   if (rest_weite_x > p_width/2) {
  81.     merk_rest_weite_x = rest_weite_x = p_width * (weite_x+1) - wx;
  82.     xskip = 1;        /* Rest entspricht der wegzulassenden Spalten */
  83.     weite_x++;
  84.   }
  85.   else {
  86.     xskip = 0;        /* Rest entspricht der hinzuzufuegenden Spalten */
  87.   }
  88.   if (rest_weite_x == 0) {
  89.     vert_rest_x = (p_width << 7);        /* KEIN -128 da eigentlich p_width+1 */
  90.   }
  91.   else {
  92.     vert_rest_x = (p_width << 7) / rest_weite_x - 128;
  93.   }
  94.  
  95.   if (p_height == 0) Fatal(20,MSG_INTERNAL_ERROR);
  96.  
  97.   weite_y = wy / p_height;
  98.   rest_weite_y = (wy % p_height);
  99.  
  100.   if (rest_weite_y > p_height/2) {
  101.     rest_weite_y = p_height * (weite_y+1) - wy;
  102.     yskip = 1;        /* Rest entspricht der wegzulassenden Zeilen */
  103.   }
  104.   else {
  105.     yskip = 0;        /* Rest entspricht der hinzuzufuegenden Zeilen */
  106.   }
  107.   if (rest_weite_y == 0) {
  108.     vert_rest_y = (p_height << 7);        /* KEIN -128 da eigentlich p_height+1 */
  109.   }
  110.   else {
  111.     vert_rest_y = (p_height << 7) / rest_weite_y - 128;        /* immer mit Faktor 100 rechnen */
  112.   }
  113.   hilf_vert_y = 64;    /* Heuristik, bin mir nicht sicher ob's besser als 0 ist...?? */
  114.  
  115. /**
  116.   add_x = (x_win_i_width - p_width) / 2;
  117.   add_y = FPAGE_ABS + (x_win_i_height - p_height) / 2;
  118. **/
  119.  
  120. #if 0
  121.   start_row = ((x_win_i_width - p_width) / 2) % 16;    /* Um wieviele Pixel muss der Anfang verschoben werden */
  122.   length_row = rp->BitMap->BytesPerRow / 2;
  123.  
  124.   add_y = (yk+win2->BorderTop) * length_row + xk / 16;
  125.   start_showmap = ((unsigned short *)(rp->BitMap->Planes[0]));
  126.   write_pointer = start_showmap + add_y;
  127. #else
  128.   start_row = 0;
  129.   length_row = (p_width + 15) / 16;
  130.  
  131.   add_y = 0;
  132.   start_showmap = fpage;
  133.   write_pointer = start_showmap + add_y;
  134. #endif
  135.  
  136.  
  137.   anf_zeile = (unsigned short *)(BitMapWin.Planes[0]);
  138.   zeilenlaenge = wx >> 4;
  139.   zeile = (unsigned short *)xmalloc((unsigned)(zeilenlaenge * sizeof(unsigned short)));
  140.   
  141. #ifdef DEBUG
  142.   if (DeBug) { 
  143.     printf("make_full_page: weite x,y: %d,%d ;rest x,y: %d,%d\n",
  144.             weite_x, weite_y, rest_weite_x, rest_weite_y);
  145.     printf("\tvert_rest_x,y: %d,%d\n",vert_rest_x,vert_rest_y);
  146.     printf("\tadd_y: %d, p_width,height: %d,%d\n", add_y,p_width,p_height);
  147.     printf("\tzeilenlaenge: %d yskip: %d, xskip: %d\n", zeilenlaenge,yskip, xskip);
  148.     printf("\ttotal page size: %d,%d\n",wx,wy);
  149.   }
  150. #endif
  151.  
  152.  
  153.   /**************** Schleife ueber die y-Werte ****************/
  154.   for(i=0; i<p_height; i++) {        /* Anzahl der Zeilen des Bildes */
  155.  
  156.     for (j=0; j<zeilenlaenge; j++) {
  157.       zeile[j] = anf_zeile[j];        /* erste zeile in Zwischensp. kopieren */
  158.     }
  159.      /* zeilen++; */
  160.     
  161.     anf_zeile += zeilenlaenge;
  162.     for (k=1; k<weite_y; k++) {        /* Rest bis weite_y einodern */
  163.       for (j=0; j<zeilenlaenge; j++) {
  164.         zeile[j] |= anf_zeile[j];
  165.       }
  166.       anf_zeile += zeilenlaenge;
  167.       /* zeilen++; */
  168.     }
  169.     if (hilf_vert_y < 128) {    /* selten */
  170.       /* existiert ein Rest, davon auch einen nehmen */
  171.       if (!yskip && rest_weite_y > 0) {
  172.         for (j=0; j<zeilenlaenge; j++) {
  173.           zeile[j] |= anf_zeile[j];
  174.         }
  175.         anf_zeile += zeilenlaenge;
  176.         /* zeilen++; */
  177.       }
  178.       else {
  179.         if (yskip && (rest_weite_y <= 0)) {
  180.           for (j=0; j<zeilenlaenge; j++) {
  181.             zeile[j] |= anf_zeile[j];
  182.           }
  183.           anf_zeile += zeilenlaenge;
  184.           /* zeilen++; */
  185.         }
  186.       }
  187.       rest_weite_y--;
  188.       hilf_vert_y += vert_rest_y;    /* Addition, damit ich den rest immer mitbekome */
  189.     }
  190.     else {            /* oefters */
  191.       if (yskip) {
  192.         for (j=0; j<zeilenlaenge; j++) {
  193.           zeile[j] |= anf_zeile[j];
  194.         }
  195.         anf_zeile += zeilenlaenge;
  196.         /* zeilen++; */
  197.       }
  198.       hilf_vert_y -= 128;        /* Immer Faktor 128 abziehen */
  199.     }
  200.  
  201.     // Rand vor dem folgenden Test loeschen
  202.     
  203.     zeile[0] &= 0x7FFF;            // erstes (Rand) Bit loeschen
  204.     zeile[zeilenlaenge-1] &= 0xFFFE;    // letztes (Rand) Bit loeschen (ist immer am Word Ende)
  205.  
  206.  
  207.     // testen ob die Zeile leer ist
  208.     
  209.     j = 0;        /* suche erstes Wort != 0 */
  210.     while (zeile[j] == 0 && j < zeilenlaenge) {
  211.       j++;
  212.     }
  213.  
  214.     // wieder den Rand setzen
  215.  
  216.     *write_pointer |= 0x8000;                      // linkes Rand Bit setzen
  217.     *(write_pointer+length_row-1) |= 1<<(length_row*16)-p_width;  // rechtes Rand Bit setzen
  218.  
  219.  
  220.     if (j < zeilenlaenge) {        /* ab j nicht alles gleich 0 */
  221.     
  222.       bitpos = 0;
  223.       rest_weite_x = merk_rest_weite_x;
  224.       hilf_vert_x = 64;        /* fang ma mal mit der Haelfte an (Heuristik...?? */
  225.  
  226.       akt_row = 16-start_row;        /* Anfang der Zeile */
  227.       copy_mask = 0;
  228.       
  229.       /**************** Schleife ueber die x-Werte ****************/
  230.       for (k=0; k<p_width; k++) {        /* Schleife ueber die x Werte */
  231.         adr = bitpos>>4;            /* Wortweise vorgehen */
  232.         mask_anf = 32 - (bitpos & 15);    /* Die Maske ist aber 32 Bit gross */
  233.         mask_width = weite_x;        /* Dadurch darf die Maske 16Bit gross sein */
  234.         bitpos += weite_x;
  235.         if (hilf_vert_x < 128 && rest_weite_x > 0) {
  236.           hilf_vert_x += vert_rest_x;    /* um soviel soll jetzt nichts gemacht werden */
  237.           if (xskip) {
  238.             rest_weite_x--;
  239.             bitpos--;
  240.             mask_width--;
  241.           }
  242.           else {
  243.         /* Rest gleichmaesig verteilen */
  244.             rest_weite_x--;
  245.         bitpos++;
  246.         mask_width++;
  247.       }
  248.         }
  249.         else {
  250.           hilf_vert_x -= 128;
  251.         }
  252.         mask = ((1L<<mask_width)-1) << (mask_anf-mask_width);
  253.         erg = (*((long *)((short *)zeile+adr))) & mask;
  254.         akt_row--;
  255.         if (erg != 0) {
  256.           copy_mask |= (unsigned short)(1 << akt_row);
  257.         }
  258.         if (akt_row == 0) {
  259.           akt_row = 16;
  260.       *write_pointer |= copy_mask;
  261.       write_pointer++;
  262.       copy_mask = 0;
  263.         }
  264.       }        /* end for k; Schleife ueber die x Werte */
  265.       /**********************/
  266.       if (copy_mask != 0) {
  267.     *write_pointer |= copy_mask;
  268.       }
  269.     }        /* end if ==zeilenlaenge */
  270.  
  271.     add_y += length_row;
  272.     write_pointer = start_showmap + add_y;
  273.     
  274.   }        /* end for i; Schleife ueber die y Werte */
  275.   
  276.   /* printf("zeilen: %d, wy: %d\n", zeilen, wy); */
  277.  
  278.   xfree((char *)zeile);
  279. }
  280.  
  281.