home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 13 / AACD13.ISO / AACD / Utilities / ACDPlay / src / V1.6 / convert.c < prev    next >
C/C++ Source or Header  |  1997-04-03  |  5KB  |  230 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.                     LONG id = *(LONG *)oldbuf;
  52.                     
  53.                     /* Variablen zum Speichern der Werte */
  54.                     WORD position_min[ANZ_WINDOWS * 4];
  55.                     WORD position_max[ANZ_WINDOWS * 4];
  56.                     WORD bools[ANZ_WINDOWS];
  57.                     LONG flag_main;
  58.                     
  59.                     int i, j, usedwindows;
  60.                     BOOL write = FALSE;
  61.  
  62.                     /* Datei bearbeiten */
  63.                     switch (id)
  64.                     {
  65.                         case ACD1:
  66.                             /* Hierbei handelt es sich um das ganz alte
  67.                                Konfig-File. Die Daten sind vollkommen anders
  68.                                strukturiert.
  69.                                Da es zwischen den Konfig-Files von V1.0 und V1.1
  70.                                auch noch Unterschiede gibt, werden nur die
  71.                                am Anfang der Datei befindlichen Fensterpositionen
  72.                                gerettet. */
  73.                                                         
  74.                             oldoffset += 16;
  75.                             
  76.                             /* Die Sachen erstmal in ein Array schreiben */
  77.                             for (i = 0; i < 8; i++)
  78.                             {
  79.                                 bools[i] = *(oldoffset++);
  80.                             }
  81.                             
  82.                             for (i = 0; i < 8 * 4; i++)
  83.                             {
  84.                                 position_min[i] = *(oldoffset++);
  85.                             }
  86.                             for (i = 0; i < 8 * 4; i++)
  87.                             {
  88.                                 position_max[i] = *(oldoffset++);
  89.                             }
  90.                             
  91.                             flag_main = STD_FLAG_MAIN;
  92.                             
  93.                             write = TRUE;
  94.                             usedwindows = 8;
  95.                             
  96.                             break;
  97.                         
  98.                         case ACD2:
  99.                             /* Hier ist wohl ein Fenster dazugekommen */
  100.                             
  101.                             oldoffset += 4;
  102.                             
  103.                             for (i = 0; i < 9; i++)
  104.                             {
  105.                                 for (j = 0; j < 4; j++)
  106.                                     position_min[4 * i + j] = *(oldoffset++);
  107.                                 for (j = 0; j < 4; j++)
  108.                                     position_max[4 * i + j] = *(oldoffset++);
  109.  
  110.                                 bools[i] = *(oldoffset++);
  111.                             }
  112.                             
  113.                             flag_main = *(LONG *)oldoffset;
  114.                             
  115.                             write = TRUE;
  116.                             usedwindows = 9;
  117.                             
  118.                             break;
  119.                     }
  120.                     
  121.                     if (write)
  122.                     {
  123.                         WORD *newoffset = (WORD *)newbuf;
  124.                         
  125.                         /********************************/
  126.                         /* Eintragen von Standardwerten */
  127.                         /********************************/
  128.                         
  129.                         /* Standardwerte für fehlende Fenster   */
  130.                         /* Die Anzahl der verbleibenden Fenster */
  131.                         /* wird aus 'usedwindows' ermittelt     */
  132.                         
  133.                         for (i = 8; i < ANZ_WINDOWS; i++)
  134.                         {
  135.                             bools[i] = FALSE;
  136.                         }
  137.                         for (i = 8 * 4; i < ANZ_WINDOWS * 4; i++)
  138.                         {
  139.                             position_min[i] = 100;
  140.                             position_max[i] = 100;
  141.                         }
  142.                         
  143.                         /************************************/
  144.                         /* Erstellen der neuen Konfig-Datei */
  145.                         /************************************/
  146.                         
  147.                         (*(LONG *)newoffset) = ACD3;        /* ID setzen */
  148.                         newoffset += 2;
  149.                         
  150.                         *(newoffset++) = ANZ_WINDOWS;
  151.                         *(newoffset++) = SIZE_WINDOW;
  152.                         
  153.                         /* Jetzt eintragen */
  154.                         for (i = 0; i < ANZ_WINDOWS; i++)
  155.                         {
  156.                             for (j = 0; j < 4; j++)
  157.                                 *(newoffset++) = position_min[4 * i + j];
  158.                             for (j = 0; j < 4; j++)
  159.                                 *(newoffset++) = position_max[4 * i + j];
  160.                             
  161.                             *(newoffset++) = bools[i];
  162.                         }
  163.                         
  164.                         *(LONG *)newoffset = flag_main;
  165.                         
  166.                         if (SaveFile(fullname, newbuf, SIZE_CONFIG))
  167.                         {
  168.                             SetProtection(fullname, FIBF_EXECUTE);
  169.                             returnval = RETURN_OK;
  170.                         }
  171.                     }
  172.                     
  173.                     FreeVec(newbuf);
  174.                 }
  175.                 FreeVec(oldbuf);
  176.             }
  177.         }
  178.         FreeDosObject(DOS_RDARGS, rda);
  179.     }
  180.  
  181.     return (returnval);
  182. }
  183.  
  184. char * OpenFile(char * name)
  185. {
  186.     BPTR filehandle;
  187.     struct FileInfoBlock *fib;
  188.     APTR buffer = NULL;
  189.  
  190.     /* Datei öffnen */
  191.     if (filehandle = Open(name, MODE_OLDFILE))
  192.     {
  193.         if (fib = (struct FileInfoBlock *)AllocDosObject(DOS_FIB, NULL))
  194.         {
  195.             /* FileInfoblock auslesen, für Dateigröße */
  196.             if (ExamineFH(filehandle, fib) == DOSTRUE)
  197.             {
  198.                 if (fib->fib_Size)
  199.                 {
  200.                     /* Speicher reservieren */
  201.                     if (buffer = (char *)AllocVec(fib->fib_Size, MEMF_ANY))
  202.                     {
  203.                         /* Datei in Speicher schreiben */
  204.                         if (Read(filehandle, buffer, fib->fib_Size) != fib->fib_Size)
  205.                             buffer = NULL;
  206.                     }
  207.                 }
  208.             }
  209.             FreeDosObject(DOS_FIB, (APTR)fib);
  210.         }
  211.         /* Datei schließen */
  212.         Close(filehandle);
  213.     }
  214.     return ((char *)buffer);
  215. }
  216.  
  217. BOOL SaveFile(char *name, char *buffer, LONG bufferlen)
  218. {
  219.     BPTR filehandle;
  220.     BOOL success = FALSE;
  221.  
  222.     if (filehandle = Open(name, MODE_NEWFILE))
  223.     {
  224.         if (Write(filehandle, (APTR)buffer, bufferlen) == bufferlen)
  225.             success = TRUE;
  226.         Close(filehandle);
  227.     }
  228.  
  229.     return (success);
  230. }