home *** CD-ROM | disk | FTP | other *** search
/ Crawly Crypt Collection 1 / crawlyvol1.bin / tt / vmem11 / vmemdemo / show_img.c < prev    next >
C/C++ Source or Header  |  1993-08-30  |  10KB  |  465 lines
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4. #include <ext.h>
  5. #include <tos.h>
  6. #include <aes.h>
  7. #include <vdi.h>
  8. #include "vmem.h"
  9.  
  10. #define    MOUSEOFF    graf_mouse (256, NULL);
  11. #define    MOUSEON        graf_mouse (257, NULL);
  12.  
  13. #define ULONG    unsigned long
  14. #define WORD    unsigned int
  15. #define CHAR    unsigned char
  16.  
  17. #define BREITE    64
  18. #define    HOEHE    64
  19.  
  20. /* Funktionsprototypen der Unterprogramme */
  21.  
  22. void    decrunch    (CHAR *source, V_ADR virtmem);
  23.  
  24. int    work_in [12],    /* Globale Parameterfelder für Workstation-Aufrufe */
  25.     work_out [57],
  26.     gl_apid,        /* Applikationsnummer */
  27.     vdihandle;        /* Nr. der VDI-Workstation */
  28.  
  29.  
  30. /* Ausgabe einer Fehlermeldung: */
  31.  
  32. void error (char *meldung)
  33. {
  34.     printf ("\n%s", meldung);
  35.     getch ();
  36.     v_clsvwk (vdihandle);
  37.     wind_update (END_MCTRL);
  38.     MOUSEON;
  39.     appl_exit ();
  40.     exit (1);
  41. }
  42.  
  43.  
  44. /* Darstellung und Scrollen des Bildschirms: */
  45.  
  46. int display (V_ADR virtmem, int breite, int hoehe)
  47. {
  48.     int        x, y, max_x, max_y;
  49.     int        mx, my, button, key;
  50.     int        flag;
  51.     long    window;
  52.     char    *data;
  53.     V_ADR    virt;
  54.     int        pxarray [8];
  55.     MFDB    mfdb_src, mfdb_dest;
  56.  
  57. /* Startposition setzen */
  58.  
  59.     x = y = 0;
  60.  
  61. /* Überbreite und Überlänge ermitteln */
  62.  
  63.     max_x = breite - 80;
  64.     if (hoehe >= 400)
  65.     {
  66.         max_y = hoehe - 400;
  67.         hoehe = 400;
  68.     }
  69.     else
  70.         max_y = 0;
  71.  
  72.     pxarray [0] = pxarray [4] = 0;
  73.     pxarray [1] = pxarray [5] = 0;
  74.     pxarray [2] = pxarray [6] = 639;
  75.     pxarray [3] = pxarray [7] = 399;
  76.  
  77.     vs_clip (vdihandle, 1, pxarray);
  78.  
  79.     mfdb_src.fd_addr = NULL;
  80.     mfdb_src.fd_w = breite << 3;
  81.     mfdb_src.fd_h = hoehe;
  82.     mfdb_src.fd_wdwidth = breite >> 1;
  83.     mfdb_src.fd_stand = 1;
  84.     mfdb_src.fd_nplanes = 1;
  85.     mfdb_src.fd_r1 = mfdb_src.fd_r2 = mfdb_src.fd_r3 = 0;
  86.  
  87.     mfdb_dest.fd_addr = NULL;
  88.  
  89. /* Größe des Zugriffsfensters berechnen */
  90.     
  91.     window = (400L) * (ULONG) breite;
  92.  
  93.     flag = 1;
  94.     MOUSEON;
  95.  
  96.     for (;;)
  97.     {
  98.  
  99. /* Falls flag gesetzt ist, dann neuen Bildausschnitt darstellen */
  100.  
  101.         if (flag)
  102.         {
  103.             flag = 0;
  104.  
  105. /* Position innerhalb des virtuellen Speichers berechnen */
  106.  
  107.             virt = virtmem + (ULONG) y * (ULONG) breite + (ULONG) x;
  108.  
  109. /* Fenster anfordern */
  110.  
  111.             data = vm_address (virt, &window, READ_MODE);
  112.             mfdb_src.fd_addr = data;
  113.             if ((long) data < 0)
  114.             {
  115.                 printf ("\033E\n");
  116.                 switch ((int) data)
  117.                 {
  118.                     case ILLEGAL_ADDRESS:
  119.                         printf ("Fehler: VM_ADDRESS erhielt eine illegale Adresse");
  120.                         return (0);
  121.                     case ILLEGAL_COUNT:
  122.                         printf ("Fehler: VM_ADDRESS wurde mit einer illegalen Windowgröße aufgerufen");
  123.                         return (0);
  124.                     case ILLEGAL_MODE:
  125.                         error ("Fehler: VM_ADDRESS wurde mit einem fehlerhaften Zugriffsmodus aufgerufen");
  126.                         return (0);
  127.                     default:
  128.                         printf ("Fehler: VM_ADDRESS liefert eine unbekannte Fehlernummer: %ld", data);
  129.                         return (0);
  130.                 }
  131.             }
  132.  
  133.  
  134. /* Darstellung des Ausschnitts */
  135.  
  136.             MOUSEOFF;
  137.             vro_cpyfm (vdihandle, 3, pxarray, &mfdb_src, &mfdb_dest);
  138.             MOUSEON;
  139.         }
  140.  
  141. /* Beide Mausknöpfe abfragen */
  142.  
  143.         evnt_button (257, 3, 0, &mx, &my, &button, &key);
  144.  
  145. /* rechte Maustaste gedrückt ?? */
  146.  
  147.         if (button & 2)
  148.         {
  149.             MOUSEOFF;
  150.  
  151. /* Status der Sondertasten (Control, Alternate und Shift) zurückliefern */
  152.  
  153.             return (key & 0x0f);
  154.         }
  155.  
  156. /* befindet sich der Mauszeiger im rechten Scrollabschnitt ?? */
  157.  
  158.         if ((mx >= (639 - BREITE)) && (x < max_x))
  159.         {
  160.             x += 2;            /* 16 Bit nach links scrollen */
  161.             flag = 1;
  162.         }
  163.  
  164. /* befindet sich der Mauszeiger im linken Scrollabschnitt ?? */
  165.  
  166.         if ((mx < BREITE) && (x > 0))
  167.         {
  168.             x -= 2;            /* 16 Bit nach rechts scrollen */
  169.             flag = 1;
  170.         }
  171.  
  172. /* befindet sich der Mauszeiger im unteren Scrollabschnitt ?? */
  173.         
  174.         if ((my >= (400 - HOEHE)) && (y < max_y))
  175.         {
  176.             y += 16;        /* 16 Zeilen nach oben */
  177.             if (y > max_y)
  178.                 y = max_y;
  179.             flag = 1;
  180.         }
  181.  
  182. /* befindet sich der Mauszeiger im oberen Scrollabschnitt ?? */
  183.         
  184.         if ((my < HOEHE) && (y > 0))
  185.         {
  186.             y -= 16;        /* 16 Zeilen nach unten */
  187.             if (y < 0)
  188.                 y = 0;
  189.             flag = 1;
  190.         }
  191.     }
  192. }
  193.  
  194.  
  195. /* Einlesen der IMG-Datei, Aufruf der Scrollroutine, Sichern der BLD-Datei */
  196.  
  197. int mainrout (void)
  198. {
  199.     int        handle, button, ret_code;
  200.     ULONG    size;
  201.     ULONG    hoehe, breite;
  202.     int        hoehe2, breite2;
  203.     CHAR    *source;
  204.     V_ADR    virtmem;
  205.     TAB        parameter;
  206.     char    pfad [128], name [128];        /* .IMG - Datei */
  207.     char    pfad2 [128], name2 [128];    /* .BLD - Datei */
  208.     char    filename [256], *position;
  209.  
  210. /* Virtuellen Speicher konfigurieren: */
  211.  
  212.     parameter.version = 0x100;            /* Version 1.00 */
  213.     parameter.count_page = 512;            /* max. 512 virtuelle Seiten */
  214.     parameter.cache_size = 6;            /* 6 Cache-Seiten */
  215.     parameter.page_type = SIZE_32768;    /* 1 Seite = 32768 Bytes */
  216.     parameter.fill_value = 0x0;            /* mit 0 initialisieren */
  217.     parameter.drive_no = 3;        /* mit Laufwerk C arbeiten */
  218.  
  219.     ret_code = vm_config (¶meter);
  220.  
  221.     if ((ret_code < 0) && (ret_code > -256))
  222.     {
  223.         printf ("\nAchtung: Der Versuch, die temporäre Datei anzulegen, ging schief !!");
  224.         printf ("\nVermutliche Ursache: freier Speicher auf der Platte reicht nicht");
  225.         error ("oder das Directory des gewählten Laufwerks ist voll !!");
  226.     }
  227.     else
  228.     {
  229.         switch (ret_code)
  230.         {
  231.             case OK:
  232.                 break;
  233.             case NO_LIST:
  234.                 error ("Es befindet sich keine Cookiejar-Liste im Speicher");
  235.             case NOT_FOUND:
  236.                 error ("VMEM ist noch nicht installiert worden");
  237.             case WRONG_CACHE_SIZE:
  238.                 error ("Die gewählte Cache-Größe ist zu klein");
  239.             case WRONG_PAGE_TYPE:
  240.                 error ("PAGE_TYPE enthält einen illegalen Wert");
  241.             case OUT_OF_MEMORY:
  242.                 printf ("\nDer zur Verfügung stehende freie Speicher reicht nicht aus");
  243.                 error ("Dieses Demo benötigt mindestens 200 KByte Speicher");
  244.             case ILLEGAL_DRIVE:
  245.                 error ("Das gewünschte Laufwerk existiert nicht");
  246.             case ILLEGAL_FATSIZE:
  247.                 error ("Fehler: das gewünschte Laufwerk verwendet eine FAT, die von VMEM nicht unterstützt wird");
  248.             default:
  249.                 printf ("\nEin unbekannter Fehler ist aufgetreten: %d", ret_code);
  250.                 exit (1);
  251.         }
  252.     }
  253.  
  254. /* Pfadnamen und Filenamen initialisieren */
  255.  
  256.     strcpy (pfad, "C:\\*.IMG");
  257.     strcpy (pfad2, "C:\\*.BLD");
  258.     name [0] = name2 [0] = '\0';
  259.  
  260.     for (;;)
  261.     {
  262.  
  263. /* Quell-Datei (IMG) ermitteln */
  264.  
  265.         MOUSEON;
  266.         fsel_input (pfad, name, &button);
  267.         MOUSEOFF;
  268.         v_clrwk (vdihandle);        /* Bildschirm löschen */
  269.  
  270.         if (button == 0)            /* Abbruch - Knopf gewählt ?? */
  271.         {
  272.             vm_close ();            /* dann virtuellen Speicher entfernen */
  273.             return (0);                /* und Unterprogramm beenden */
  274.         }
  275.  
  276. /* Filenamen und Pfad zusammensetzen */
  277.  
  278.         strcpy (filename, pfad);
  279.         position = strrchr (filename, '\\') + 1;
  280.         strcpy (position, name);
  281.  
  282. /* Datei öffnen */
  283.  
  284.         handle = Fopen (filename, 0);
  285.         if (handle < 0)
  286.         {
  287.             printf ("\033E\nFehler: Datei <%s> nicht gefunden !!");
  288.             return (2);
  289.         }
  290.  
  291. /* Dateigröße ermitteln */
  292.  
  293.         size = Fseek (0, handle, 2);
  294.         Fseek (0, handle, 0);
  295.  
  296. /* Pufferspeicher anfordern */
  297.     
  298.         source = (CHAR *) Malloc (size);
  299.         if (source == NULL)
  300.         {
  301.             printf ("\033E\nFehler: Puffer (%ld Bytes) kann nicht angelegt werden wegen Speichermangel", size);
  302.             return (3);
  303.         }
  304.  
  305. /* Datei in den Puffer einlesen */
  306.     
  307.         if (Fread (handle, size, source) != size)
  308.         {
  309.             printf ("\033E\nLese-Fehler: Datei eventuell defekt !!");
  310.             return (4);
  311.         }
  312.  
  313. /* Datei schließen */
  314.         
  315.         Fclose (handle);
  316.     
  317. /* Daten ausgeben: */
  318.     
  319.         printf ("\033EGepackt:  %lu Bytes", size);
  320.     
  321.         breite = ((ULONG) (*(source + 12))) * 256;
  322.         breite += (ULONG) (*(source + 13));
  323.     
  324.         hoehe = ((ULONG) (*(source + 14))) * 256;
  325.         hoehe += (ULONG) (*(source + 15));
  326.     
  327.         printf ("\nHöhe:     %lu Pixel", hoehe);
  328.         printf ("\nBreite:   %lu Pixel", breite);
  329.  
  330. /* Pixel-Breite auf volle WORD-Größe erweitern */
  331.  
  332.         breite = ((breite - 1) | 0x0f) + 1;
  333.         size = (breite >> 3) * hoehe;
  334.     
  335.         printf ("\nEntpackt: %lu Bytes", size);
  336.  
  337.         printf ("\n\nAnforderung von %ld Bytes virtuellem Speicher", size);
  338.  
  339. /* virtuellen Speicher anfordern: */
  340.  
  341.         virtmem = vm_alloc (size);
  342.  
  343. /* konnte Speicher angelegt werden ?? */
  344.  
  345.         if (virtmem == _NULL)
  346.         {
  347.             printf ("\033E\nFehler: nicht genügend Platz auf der Platte");
  348.             printf ("\nDieses Bild benötigt %ld Bytes freien Speicher", size);
  349.             return (5);
  350.         }
  351.  
  352.         else
  353.  
  354. /* Bild in den virtuellen Speicher entpacken: */
  355.  
  356.         {
  357.             printf ("\n\nEntpacke das Bild...");
  358.             decrunch (source, virtmem);
  359.         }
  360.  
  361. /* Freigeben des physikalischen Speichers: */
  362.  
  363.         Mfree (source);
  364.  
  365.         printf ("\033E");
  366.  
  367. /* Darstellen des Bildes: */
  368.  
  369.         if (display (virtmem, (int) (breite  >> 3), (int) hoehe))
  370.         {
  371.  
  372. /* Pfad und Namen der BLD-Datei ermitteln */
  373.  
  374.             MOUSEON;
  375.             fsel_input (pfad2, name2, &button);
  376.             MOUSEOFF;
  377.             v_clrwk (vdihandle);
  378.  
  379. /* OK - Button gewählt ?? */
  380.         
  381.             if (button)
  382.             {
  383.  
  384. /* Dateinamen zusammensetzen */
  385.  
  386.                 strcpy (filename, pfad2);
  387.                 position = strrchr (filename, '\\') + 1;
  388.                 strcpy (position, name2);
  389.  
  390. /* Datei anlegen */
  391.  
  392.                 handle = Fcreate (filename, 0);
  393.                 if (handle < 0)
  394.                 {
  395.                     printf ("\033E\nFehler: konnte Datei <%s> nicht anlegen !!", filename);
  396.                     return (6);
  397.                 }
  398.  
  399. /* Höhe und Breite des Bildes berechnen */
  400.             
  401.                 breite2 = (int) breite;
  402.                 hoehe2 = (int) (hoehe - 1);
  403.  
  404. /* Format-Daten schreiben */
  405.             
  406.                 Fwrite (handle, 2, &breite2);
  407.                 Fwrite (handle, 2, &hoehe2);
  408.  
  409. /* Bild-Daten schreiben (ungepackt !!) */
  410.             
  411.                 if (vm_write (handle, size, virtmem) != size)
  412.                 {
  413.                     printf ("\033E\nFehler: konnte das entpackte Bild (%ld Bytes) nicht schreiben", size);
  414.                     printf ("\nVermutliche Ursache: Platz auf der Platte reicht nicht");
  415.                 }
  416.                 else
  417.  
  418. /* Datei schließen */
  419.             
  420.                     Fclose (handle);
  421.             }
  422.         }
  423.  
  424. /* Virtuellen Speicher freigeben: */
  425.  
  426.         vm_free (virtmem);
  427.  
  428. /* Cache neu initialisieren: */
  429.  
  430.         vm_clrcache ();
  431.     }
  432. }
  433.  
  434.  
  435. int main (void)
  436. {
  437.     int    retcode, i, dummy;
  438.  
  439. /* Initialisierung der Applikation und der Workstation */
  440.     
  441.     gl_apid = appl_init ();
  442.     for (i = 1; i < 10; work_in [i++] = 0)
  443.         ;
  444.     work_in [10] = 2;
  445.     work_in [0] = vdihandle = graf_handle (&dummy, &dummy, &dummy, &dummy);
  446.     MOUSEOFF;
  447.     wind_update (BEG_MCTRL);
  448.     v_opnvwk (work_in, &vdihandle, work_out);
  449.     printf ("\033E");
  450.  
  451. /* Aufruf der Unterroutine */
  452.  
  453.     if ((retcode = mainrout ()) != 0)
  454.         getch ();
  455.  
  456. /* Schließen der Workstation und Beenden der Applikation */
  457.  
  458.     v_clsvwk (vdihandle);
  459.     wind_update (END_MCTRL);
  460.     MOUSEON;
  461.     appl_exit ();
  462.  
  463.     return (retcode);
  464. }
  465.