home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 13 / AACD13.ISO / AACD / Utilities / ACDPlay / src / V1.5 / convert.c.BAK < prev    next >
Text File  |  1997-04-03  |  5KB  |  229 lines
  1. /* Jetzt in C: Das Konvertierungsprogramm für ACDPlay-Konfigurationsdateien */
  2.  
  3. #include <clib/dos_protos.h>
  4. #include <clib/exec_protos.h>
  5. #include <dos/dos.h>
  6. #include <exec/exec.h>
  7.  
  8. #include "string.h"
  9.  
  10. #define ACD1 0x41434431
  11. #define ACD2 0x41434432
  12. #define ACD3 0x41434433
  13.  
  14. #define SIZE_CONFIG     192
  15. #define ANZ_WINDOWS     10
  16. #define SIZE_WINDOW     18
  17. #define STD_FLAG_MAIN     127
  18.  
  19. char * OpenFile(char *);
  20. BOOL SaveFile(char *, char *, LONG);
  21.  
  22. int main(int argc, char *argv[])
  23. {
  24.     ULONG returnval = RETURN_FAIL;
  25.  
  26.     struct RDArgs *rda;
  27.  
  28.     /* Dateiname rausfinden */
  29.     if (rda = AllocDosObject(DOS_RDARGS, NULL))
  30.     {
  31.         LONG vec[1];
  32.         char fullname[257];
  33.  
  34.         rda->RDA_ExtHelp =    "ACDPlay 1.5 config file converter\n"
  35.                             "FILE:   old ACDPlay configuration file\n\n"
  36.                             "Enter parameters";
  37.  
  38.         if (ReadArgs("F=FILE/A", vec, rda))
  39.         {
  40.             char *oldbuf, *newbuf;
  41.  
  42.             FreeArgs(rda);
  43.             strncpy(fullname, (char *)vec[0], 256);
  44.  
  45.             /* Datei laden */
  46.             if (oldbuf = OpenFile(fullname))
  47.             {
  48.                 if (newbuf = AllocVec(SIZE_CONFIG, MEMF_ANY))
  49.                 {
  50.                     WORD *oldoffset = (WORD *)oldbuf;
  51.                     WORD *newoffset = (WORD *)newbuf;
  52.                     LONG id = *(LONG *)oldbuf;
  53.                     
  54.                     /* Variablen zum Speichern der Werte */
  55.                     WORD position_min[ANZ_WINDOWS * 4];
  56.                     WORD position_max[ANZ_WINDOWS * 4];
  57.                     WORD bools[ANZ_WINDOWS];
  58.                     LONG flag_main;
  59.                     
  60.                     int i, j, usedwindows;
  61.                     BOOL write = FALSE;
  62.  
  63.                     /* Datei bearbeiten */
  64.                     switch (id)
  65.                     {
  66.                         case ACD1:
  67.                             /* Hierbei handelt es sich um das ganz alte
  68.                                Konfig-File. Die Daten sind vollkommen anders
  69.                                strukturiert.
  70.                                Da es zwischen den Konfig-Files von V1.0 und V1.1
  71.                                auch noch Unterschiede gibt, werden nur die
  72.                                am Anfang der Datei befindlichen Fensterpositionen
  73.                                gerettet. */
  74.                                                         
  75.                             oldoffset += 16;
  76.                             
  77.                             /* Die Sachen erstmal in ein Array schreiben */
  78.                             for (i = 0; i < 8; i++)
  79.                             {
  80.                                 bools[i] = *(oldoffset++);
  81.                             }
  82.                             
  83.                             for (i = 0; i < 8 * 4; i++)
  84.                             {
  85.                                 position_min[i] = *(oldoffset++);
  86.                             }
  87.                             for (i = 0; i < 8 * 4; i++)
  88.                             {
  89.                                 position_max[i] = *(oldoffset++);
  90.                             }
  91.                             
  92.                             flag_main = STD_FLAG_MAIN;
  93.                             
  94.                             write = TRUE;
  95.                             usedwindows = 8;
  96.                             
  97.                             break;
  98.                         
  99.                         case ACD2:
  100.                             /* Hier ist wohl ein Fenster dazugekommen */
  101.                             
  102.                             oldoffset += 4;
  103.                             
  104.                             for (i = 0; i < 9; i++)
  105.                             {
  106.                                 for (j = 0; j < 4; j++)
  107.                                     position_min[4 * i + j] = *(oldoffset++);
  108.                                 for (j = 0; j < 4; j++)
  109.                                     position_max[4 * i + j] = *(oldoffset++);
  110.  
  111.                                 bools[i] = *(oldoffset++);
  112.                             }
  113.                             
  114.                             flag_main = *(LONG *)oldoffset;
  115.                             
  116.                             write = TRUE;
  117.                             usedwindows = 9;
  118.                             
  119.                             break;
  120.                     }
  121.                     
  122.                     if (write)
  123.                     {
  124.                         /********************************/
  125.                         /* Eintragen von Standardwerten */
  126.                         /********************************/
  127.                         
  128.                         /* Standardwerte für fehlende Fenster   */
  129.                         /* Die Anzahl der verbleibenden Fenster */
  130.                         /* wird aus 'usedwindows' ermittelt     */
  131.                         
  132.                         for (i = 8; i < ANZ_WINDOWS; i++)
  133.                         {
  134.                             bools[i] = FALSE;
  135.                         }
  136.                         for (i = 8 * 4; i < ANZ_WINDOWS * 4; i++)
  137.                         {
  138.                             position_min[i] = 100;
  139.                             position_max[i] = 100;
  140.                         }
  141.                         
  142.                         /************************************/
  143.                         /* Erstellen der neuen Konfig-Datei */
  144.                         /************************************/
  145.                         
  146.                         (*(LONG *)newoffset) = ACD3;        /* ID setzen */
  147.                         newoffset += 2;
  148.                         
  149.                         *(newoffset++) = ANZ_WINDOWS;
  150.                         *(newoffset++) = SIZE_WINDOW;
  151.                         
  152.                         /* Jetzt eintragen */
  153.                         for (i = 0; i < ANZ_WINDOWS; i++)
  154.                         {
  155.                             for (j = 0; j < 4; j++)
  156.                                 *(newoffset++) = position_min[4 * i + j];
  157.                             for (j = 0; j < 4; j++)
  158.                                 *(newoffset++) = position_max[4 * i + j];
  159.                             
  160.                             *(newoffset++) = bools[i];
  161.                         }
  162.                         
  163.                         *(LONG *)newoffset = flag_main;
  164.                         
  165.                         if (SaveFile(fullname, newbuf, SIZE_CONFIG))
  166.                         {
  167.                             SetProtection(fullname, FIBF_EXECUTE);
  168.                             returnval = RETURN_OK;
  169.                         }
  170.                     }
  171.                     
  172.                     FreeVec(newbuf);
  173.                 }
  174.                 FreeVec(oldbuf);
  175.             }
  176.         }
  177.         FreeDosObject(DOS_RDARGS, rda);
  178.     }
  179.  
  180.     return (returnval);
  181. }
  182.  
  183. char * OpenFile(char * name)
  184. {
  185.     BPTR filehandle;
  186.     struct FileInfoBlock *fib;
  187.     APTR buffer = NULL;
  188.  
  189.     /* Datei öffnen */
  190.     if (filehandle = Open(name, MODE_OLDFILE))
  191.     {
  192.         if (fib = (struct FileInfoBlock *)AllocDosObject(DOS_FIB, NULL))
  193.         {
  194.             /* FileInfoblock auslesen, für Dateigröße */
  195.             if (ExamineFH(filehandle, fib) == DOSTRUE)
  196.             {
  197.                 if (fib->fib_Size)
  198.                 {
  199.                     /* Speicher reservieren */
  200.                     if (buffer = (char *)AllocVec(fib->fib_Size, MEMF_ANY))
  201.                     {
  202.                         /* Datei in Speicher schreiben */
  203.                         if (Read(filehandle, buffer, fib->fib_Size) != fib->fib_Size)
  204.                             buffer = NULL;
  205.                     }
  206.                 }
  207.             }
  208.             FreeDosObject(DOS_FIB, (APTR)fib);
  209.         }
  210.         /* Datei schließen */
  211.         Close(filehandle);
  212.     }
  213.     return ((char *)buffer);
  214. }
  215.  
  216. BOOL SaveFile(char *name, char *buffer, LONG bufferlen)
  217. {
  218.     BPTR filehandle;
  219.     BOOL success = FALSE;
  220.  
  221.     if (filehandle = Open(name, MODE_NEWFILE))
  222.     {
  223.         if (Write(filehandle, (APTR)buffer, bufferlen) == bufferlen)
  224.             success = TRUE;
  225.         Close(filehandle);
  226.     }
  227.  
  228.     return (success);
  229. }