home *** CD-ROM | disk | FTP | other *** search
/ The Fred Fish Collection 1.5 / ffcollection-1-5-1992-11.iso / ff_progs / libs / plotlib.lha / Plot_1.lzh / Demo / Farben.c < prev    next >
Encoding:
C/C++ Source or Header  |  1990-02-18  |  14.2 KB  |  385 lines
  1. /****************************************************************
  2.  *                                                                                                                            *
  3.  * Filename : Farben.c                                                                                    *
  4.  *                                                                                                                            *
  5.  ****************************************************************
  6.  *                                                                                                                            *
  7.  *    Comment : Dieses File beinhaltet alle nötigen Routinen            *
  8.  *                        für das Handling der Farben.                                            *
  9.  *                        eigene Fehlerbehandlung.                                                    *
  10.  *                                                                                                                            *
  11.  *                        Folgende Routinen sind enthalten:                                    *
  12.  *                                                                                                                            *
  13.  *                         - SetzeFarben()                                                                    *
  14.  *                         - HoleFarben()                                                                        *
  15.  *                         - LadeFarben()                                                                        *
  16.  *                         - FarbenLaden()                                                                    *
  17.  *                         - FarbenSichern()                                                                *
  18.  *                                                                                                                            *
  19.  *            Rev : V1.0                                                                                            *
  20.  *                                                                                                                            *
  21.  *    History : V1.0 erstellen dieses Files                            01.07.89    *
  22.  *                                                                                                                            *
  23.  *         Bugs : keine bekanneten                                                                    *
  24.  *                                                                                                                            *
  25.  *        Autor : Oesch Silvano                                                                            *
  26.  *                                                                                                                            *
  27.  *        Datum : 01.07.89                                                                                    *
  28.  *                                                                                                                            *
  29.  ****************************************************************/
  30.  
  31. /****************************************************************
  32.  *                                                                                                                            *
  33.  * allgemeine Includedateien                                                                        *
  34.  *                                                                                                                            *
  35.  ****************************************************************/
  36.  
  37. #include <ctype.h>
  38. #include <string.h>
  39. #include <stdlib.h>
  40. #include <stdio.h>
  41. #include <math.h>
  42. #include <fcntl.h>
  43. #include <exec/alerts.h>
  44. #include <exec/types.h>
  45. #include <exec/io.h>
  46. #include <intuition/intuition.h>
  47. #include <intuition/intuitionbase.h>
  48. #include <libraries/dos.h>
  49. #include <exec/libraries.h>
  50. #include <libraries/dosextens.h>
  51. #include <libraries/reqbase.h>
  52. #include <proto/reqproto.h>
  53.  
  54. /****************************************************************
  55.  *                                                                                                                            *
  56.  * programmspezifische Includedateien                                                        *
  57.  *                                                                                                                            *
  58.  ****************************************************************/
  59.  
  60. #include "Definitions.h"                        /* allgemeine Definitionen    */
  61. #include "Farben.h"                                    /* def. FarbenFilestruktur    */
  62.  
  63. /****************************************************************
  64.  *                                                                                                                            *
  65.  * globale Definitionen                                                                                    *
  66.  *                                                                                                                            *
  67.  ****************************************************************/
  68.  
  69. /****************************************************************
  70.  * Definition der Standartfarben inkl. Fileheader                                *
  71.  * Die Struktur ist kompatibel zum IFF Format von EA                        *
  72.  * Diese Definition kann kopiert und direkt                                            *
  73.  * gespeichert werden sowie als Vergleichsobjekt                                *
  74.  * dienen.                                                                                                            *
  75.  ****************************************************************/
  76.  
  77. struct FarbenFile                                        /* Strukturtyp                            */
  78. deffarben =                                                    /* Variablenname                        */
  79.     {
  80.         FORM,                                                        /* IFF Header                                */
  81.         (long)sizeof(struct FarbenFile),
  82.                                                                         /* Grösse der Datei                    */
  83.         ID_ILBM,                                                /* IFF ID                                        */
  84.         ID_CMAP,                                                /* IFF Kennzeichnung                */
  85.         ( long )FARBENANZAHL<<2,                /* Anzahl Farbregister * 4    */
  86.         0x0,0x0,0x0,                                        /* Farbregister 0 Schwarz        */
  87.         0xD,0xD,0xD,                                        /* Farbregister 1 Weiss            */
  88. #if BITPLANE > 1
  89.         0x0,0x7,0xD,                                        /* Farbregister 2 Orange        */
  90.         0xF,0x8,0x3,                                        /* Farbregister 3 Hellblau    */
  91. #if BITPLANE > 2
  92.         0xF,0x0,0x0,                                        /* Farbregister 4 Rot                */
  93.         0x0,0xF,0x0,                                        /* Farbregister 5 Grün            */
  94.         0x0,0x0,0xF,                                        /* Farbregister 6 Blau            */
  95.         0x8,0x8,0x8                                            /* Farbregister 7 Grau            */
  96. #endif
  97. #endif
  98.     };
  99.  
  100. /****************************************************************
  101.  *                                                                                                                            *
  102.  * externe Definitionen                                                                                    *
  103.  *                                                                                                                            *
  104.  ****************************************************************/
  105.  
  106. extern struct ReqBase *ReqBase;
  107. extern struct FileRequester mfr;
  108. extern struct ViewPort *Vp;                    /*                 "                                */
  109. extern char filename[];                            /* in Main.c                                */
  110. extern char laden[];
  111. extern char sichern[];
  112.  
  113. /****************************************************************
  114.  *                                                                                                                            *
  115.  * Funktion : SetzeFarben()                                                                            *
  116.  *                                                                                                                            *
  117.  ****************************************************************
  118.  *                                                                                                                            *
  119.  *     Input : Pointer auf FarbenFile                                                            *
  120.  *                                                                                                                            *
  121.  *    Output : None                                                                                                *
  122.  *                                                                                                                            *
  123.  ****************************************************************
  124.  *                                                                                                                            *
  125.  * Comment : Diese Routine setzt die Farben die in dem                    *
  126.  *                     Farbenfile angegeben sind. Die Routine sorgt für     *
  127.  *                     ihre eigene Fehlerbehandlung.                                            *
  128.  *                     Die globale Variable Vp ( ViewPort ) muss                    *
  129.  *                     initialisiert sein.                                                                *
  130.  *                                                                                                                            *
  131.  *         Rev : V1.0                                                                                                *
  132.  *                                                                                                                            *
  133.  * History : V1.0 erstellen dieses Files                            01.07.89    *
  134.  *                                                                                                                            *
  135.  *        Bugs : keine bekanneten                                                                        *
  136.  *                                                                                                                            *
  137.  *     Autor : Oesch Silvano                                                                            *
  138.  *                                                                                                                            *
  139.  *     Datum : 01.07.89                                                                                        *
  140.  *                                                                                                                            *
  141.  ****************************************************************/
  142.  
  143. void SetzeFarben (file)
  144.     struct FarbenFile *file;                    /* Inputpointer Farbenfile    */
  145.     {
  146.         int i;                                                    /* globaler Zähler                    */
  147.         for (i=0;i<FARBENANZAHL;i++)        /* Setze alle Farbregister    */
  148.             SetRGB4(Vp,i,file->colorregister[i].red,
  149.                                      file->colorregister[i].green,
  150.                                      file->colorregister[i].blue);
  151.     }
  152.  
  153. /****************************************************************
  154.  *                                                                                                                            *
  155.  * Funktion : HoleFarben()                                                                            *
  156.  *                                                                                                                            *
  157.  ****************************************************************
  158.  *                                                                                                                            *
  159.  *     Input : None                                                                                                *
  160.  *                                                                                                                            *
  161.  *    Output : None                                                                                                *
  162.  *                                                                                                                            *
  163.  ****************************************************************
  164.  *                                                                                                                            *
  165.  * Comment : Diese Routine holt die aktuellen Farben,                        *
  166.  *                     speichert sie in der deffarben Struktur. Diese            *
  167.  *                     Routine hat eine eigene Fehlerbehandlung.                    *
  168.  *                     Die globale Variable Vp ( ViewPort ) muss                    *
  169.  *                     initialisiert sein.                                                                *
  170.  *                                                                                                                            *
  171.  *         Rev : V1.0                                                                                                *
  172.  *                                                                                                                            *
  173.  * History : V1.0 erstellen dieses Files                            01.07.89    *
  174.  *                                                                                                                            *
  175.  *        Bugs : keine bekanneten                                                                        *
  176.  *                                                                                                                            *
  177.  *     Autor : Oesch Silvano                                                                            *
  178.  *                                                                                                                            *
  179.  *     Datum : 01.07.89                                                                                        *
  180.  *                                                                                                                            *
  181.  ****************************************************************/
  182.  
  183. void HoleFarben()
  184.     {
  185.         int i,                                                    /* globaler Zähler                    */
  186.                 rgb;                                                /* Speicher für RGB                    */
  187.         for (i=0;i<FARBENANZAHL;i++)        /* hole alle Farbregister        */
  188.             {
  189.                 rgb=GetRGB4(Vp->ColorMap,i);
  190.                                                                         /* zwischenspeichern des        */
  191.                                                                         /* Registerwertes                        */
  192.                                                                         /* Aufbau : 0x0RGB                    */
  193.                                                                         /* setzen der Werte in die    */
  194.                                                                         /* IFF-strukturierte                */
  195.                                                                         /* defaultvariablen                    */
  196.                 deffarben.colorregister[i].red = ROT(rgb);
  197.                 deffarben.colorregister[i].green = GRUEN(rgb);
  198.                 deffarben.colorregister[i].blue = BLAU(rgb);
  199.             }
  200.     }
  201.  
  202. /****************************************************************
  203.  *                                                                                                                            *
  204.  * Funktion : LadeFarben()                                                                            *
  205.  *                                                                                                                            *
  206.  ****************************************************************
  207.  *                                                                                                                            *
  208.  *     Input : Adresse auf Filenamen                                                            *
  209.  *                                                                                                                            *
  210.  *    Output : Integer für laden                                                                    *
  211.  *                                                                                                                            *
  212.  ****************************************************************
  213.  *                                                                                                                            *
  214.  * Comment : Diese Routine lädt ein IFF ColorMap in den                    *
  215.  *                     Speicher.                                                                                    *
  216.  *                     Der Integerwert gibt den erfolg des ladens an.            *
  217.  *                     Wenn Return = NULL dann war das laden                            *
  218.  *                     erfolgreich.                                                                                *
  219.  *                     Sonst wird ein Wert >0 zurückgegeben. Der                    *
  220.  *                     Rückgabewert sagt nichts über den Fehler aus.            *
  221.  *                     Wenn es ein ColorMap File ist, werden die                    *
  222.  *                     geladenen Farben auf dem Screen gesetzt.                        *
  223.  *                     Diese Routine hat keine eigene Fehlerbehandlung.        *
  224.  *                     Mögliche auftrettende Fehler :                                            *
  225.  *                            -> Speicherallozierung                                                    *
  226.  *                            -> öffnen der Datei                                                            *
  227.  *                            -> lesen der Datei                                                            *
  228.  *                            -> schliessen der Datei                                                    *
  229.  *                            -> keine IFF-Datei                                                            *
  230.  *                            -> Speicherdeallozierung                                                *
  231.  *                                                                                                                            *
  232.  *         Rev : V1.0                                                                                                *
  233.  *                                                                                                                            *
  234.  * History : V1.0 erstellen dieses Files                            01.07.89    *
  235.  *                                                                                                                            *
  236.  *        Bugs : keine bekannten                                                                        *
  237.  *                                                                                                                            *
  238.  *     Autor : Oesch Silvano                                                                            *
  239.  *                                                                                                                            *
  240.  *     Datum : 01.07.89                                                                                        *
  241.  *                                                                                                                            *
  242.  ****************************************************************/
  243.  
  244. int LadeFarben(filename)
  245.     char *filename;                                        /* Input Filename                        */
  246. {
  247.     struct FarbenFile *file;
  248.     int fnr,                                                    /* Filenummer                                */
  249.     erfolg,                                                        /* allgemeiner Rückgabewert    */
  250.     count,                                                        /* Bytezähler Rückgabewert    */
  251.     error = NULL;                                            /* Fehlerzähler                            */
  252.  
  253.     file = (struct FarbenFile *)malloc(sizeof(struct FarbenFile));
  254.     if (file)
  255.     {
  256.         fnr=open(filename,O_RDONLY);
  257.         if (fnr == -1)
  258.             error ++;
  259.         else
  260.         {
  261.             count = read(fnr,file,sizeof(struct FarbenFile));
  262.             if (count != sizeof(struct FarbenFile))
  263.                 error ++;
  264.             erfolg = close (fnr);                    /* schliessen der Datei            */
  265.             if (erfolg)                                        /* Fehler beim schliessen        */
  266.                 error ++;                                        /* Ja, Error setzen                    */
  267.             if ((file->kopf != FORM)||
  268.                     (file->id != ID_ILBM)||
  269.                     (file->colormapheader != ID_CMAP))
  270.                 error ++;                                        /* kein IFF Error setzen        */
  271.             if (file->anzahl>>2 < FARBENANZAHL)
  272.                 error ++;                                        /* Nicht genug Farben                */
  273.             if (!error)                                        /* wenn alles ohne Fehler        */
  274.                 SetzeFarben(file);                    /* setzen der Farben                */
  275.         }
  276.         free(file);                                            /* Erfolgreich : erfolg=0        */
  277.     }
  278.     else                                                            /* kein Speicher bekommen        */
  279.         error ++;                                                /* Fehler setzen!                        */
  280.     return (error);                                        /* Return mit Summe aller        */
  281. }                                                                        /* Fehler.                                    */
  282.  
  283. /****************************************************************
  284.  *                                                                                                                            *
  285.  * Funktion : FarbenLaden()                                                                            *
  286.  *                                                                                                                            *
  287.  ****************************************************************
  288.  *                                                                                                                            *
  289.  *     Input : None                                                                                                *
  290.  *                                                                                                                            *
  291.  *    Output : None                                                                                                *
  292.  *                                                                                                                            *
  293.  ****************************************************************
  294.  *                                                                                                                            *
  295.  * Comment : Es wird nach einem Dateinamen gefragt.                            *
  296.  *                     Diese    Datei wird in den Speicher geladen.                    *
  297.  *                     Danach wird die Datei auf IFF ( Interchange File     *
  298.  *                     Format ) untersucht und entsprechend dem                        *
  299.  *                     positiven Resultat geladen.                                                *
  300.  *                     Diese Routine hat eine eigene Fehlerbehandlung.        *
  301.  *                                                                                                                            *
  302.  *         Rev : V1.0                                                                                                *
  303.  *                                                                                                                            *
  304.  * History : V1.0 erstellen dieses Files                                                *
  305.  *                                                                                                        26.06.89    *
  306.  *        Bugs : keine bekannten                                                                        *
  307.  *                                                                                                                            *
  308.  *     Autor : Oesch Silvano                                                                            *
  309.  *                                                                                                                            *
  310.  *     Datum : 26.06.89                                                                                        *
  311.  *                                                                                                                            *
  312.  ****************************************************************/
  313.  
  314. void FarbenLaden()
  315. {
  316.     int erfolg;
  317.  
  318.     mfr.Title = "Laden";
  319.     erfolg = FileRequester(&mfr);
  320.     if (erfolg)
  321.     {
  322.         erfolg = LadeFarben(filename);
  323.         if (erfolg) SimpleRequest(laden);
  324.     }
  325. }
  326.  
  327.  
  328. /****************************************************************
  329.  *                                                                                                                            *
  330.  * Funktion : FarbenSichern()                                                                        *
  331.  *                                                                                                                            *
  332.  ****************************************************************
  333.  *                                                                                                                            *
  334.  *     Input : None                                                                                                *
  335.  *                                                                                                                            *
  336.  *    Output : None                                                                                                *
  337.  *                                                                                                                            *
  338.  ****************************************************************
  339.  *                                                                                                                            *
  340.  * Comment : Die eingestelleten Farben in ColorMap werden als     *
  341.  *                     IFF ( Interchange File Format ) gesichert. Die            *
  342.  *                     auftrettenden Fehler werden addiert, und erst am     *
  343.  *                     Schluss ausgewertet.                                                                *
  344.  *                     Diese Routine hat eine eigene Fehlerbehandlung.        *
  345.  *                                                                                                                            *
  346.  *         Rev : V1.0                                                                                                *
  347.  *                                                                                                                            *
  348.  * History : V1.0 erstellen dieses Files                            26.06.89    *
  349.  *                                                                                                                            *
  350.  *        Bugs : keine bekannten                                                                        *
  351.  *                                                                                                                            *
  352.  *     Autor : Oesch Silvano                                                                            *
  353.  *                                                                                                                            *
  354.  *     Datum : 26.06.89                                                                                        *
  355.  *                                                                                                                            *
  356.  ****************************************************************/
  357.  
  358. void FarbenSichern()
  359. {
  360.     int erfolg,
  361.             fnr,
  362.             count,
  363.             error = NULL;
  364.  
  365.     mfr.Title = "Sichern unter ..";
  366.     erfolg = FileRequester(&mfr);
  367.     if (erfolg)
  368.     {
  369.         HoleFarben();
  370.         fnr = open(filename,O_WRONLY+O_CREAT);
  371.         if (fnr == -1)
  372.             error ++;
  373.         else
  374.         {
  375.             count = write(fnr,&deffarben,sizeof(struct FarbenFile));
  376.             if (count != sizeof(struct FarbenFile))
  377.                 error ++;
  378.             erfolg = close(fnr);
  379.             if (erfolg)
  380.                 error ++;
  381.         }
  382.         if (error) SimpleRequest(sichern);
  383.     }
  384. }
  385.