home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 13 / AACD13.ISO / AACD / Utilities / ACDPlay / src / V1.5 / pickcdid / PickCDID.c < prev    next >
C/C++ Source or Header  |  1997-04-26  |  21KB  |  720 lines
  1. /**************************************************************************
  2.  
  3.         |¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯|
  4.         |             PickCDID - Tool               |
  5.         |            -----------------              |
  6.         |                                           |
  7.         |               Version 0.9                 |
  8.         |___________________________________________|
  9.  
  10.     Autor     : Martin Kresse [mak]
  11.     Copyright: Freeware
  12.  
  13.    Was: Programm, das CDIDs eingelegter CDs aus einem Verzeichnis in
  14.         ein anderes kopiert.
  15.  
  16.    Umgebung    : Maxon C++ light auf Amiga 12oo OS3.0 68o3o 2MB Chip 12MB Fast
  17.  
  18.    Status    : 1. Release mit ACDPlay 1.5
  19.  
  20.    Bugs        : keine bekannt
  21.  
  22.  
  23.    Autor   Version   Datum      Veränderungen
  24.   ------- --------- --------   ------------------------------------------
  25.     mak        0.1        22.04.97    - Programmgerüst (Window+Gads und Timer...)
  26.             0.2        23.04.97    - CD-Zeugs eingebaut
  27.                                 - DiskFiles werden eingelesen und im LV angezeigt
  28.                                 - Windowgröße ist jetzt veränderbar
  29.             0.3        24.04.97    - ShowTitles() und OpenFile() eingefügt
  30.             0.4        25.04.97    - Programm kopiert jetzt nicht vorhandene IDs
  31.                                 - Parameter per Tooltypes
  32.             0.9        26.04.97    - kosmetische Änderungen
  33.                                 - Tastaturunterstützung
  34.                                 - ShowMsgA() benutzt ReqToolsLib falls vorhanden
  35.                                 - ToolType AUTOEJECT dazu
  36.  
  37. **************************************************************************/
  38.  
  39. static char prog_version[] = "\0$VER: PickCDID V0.9 ("__DATE2__")";
  40.  
  41.  
  42. /*----- Includes ---------------< >-*/
  43. #include <exec/types.h>
  44. #include <exec/memory.h>
  45. #include <exec/libraries.h>
  46. #include <dos/dos.h>
  47. #include <intuition/intuition.h>
  48. #include <intuition/gadgetclass.h>
  49. #include <libraries/gadtools.h>
  50. #include <devices/timer.h>
  51. #include <devices/scsidisk.h>
  52.  
  53. #include <clib/alib_protos.h>
  54. #include <clib/dos_protos.h>
  55. #include <clib/exec_protos.h>
  56. #include <clib/gadtools_protos.h>
  57. #include <clib/icon_protos.h>
  58. #include <clib/intuition_protos.h>
  59. #include <clib/graphics_protos.h>
  60. #include <wbstartup.h>
  61. #include <string.h>
  62. #include <stdio.h>
  63.  
  64. #include "CD-ROM.h"
  65.  
  66. /*----- globale Variablen ------< >-*/
  67. struct Library *IntuitionBase = NULL;
  68. struct Library *IconBase      = NULL;
  69. struct Library *GadToolsBase  = NULL;
  70. struct Library *GfxBase          = NULL;
  71. struct Library *ReqToolsBase  = NULL;
  72.  
  73. #define GAD_LIST    0
  74. #define GAD_DELETE    1
  75. #define ANZ_GADS    2
  76.  
  77. struct Window        *window;
  78. struct Gadget        *mygad[ANZ_GADS];
  79. struct MsgPort        *timer_mp;
  80. struct timerequest    *timereq;
  81. struct CDxRequest    *cdx;
  82.  
  83. char *devicename, *destpath, *sourcepath;
  84. ULONG unit = 0, lun = 0;
  85. BOOL autoej = FALSE;
  86.  
  87. struct CDIDNode
  88. {
  89.     struct Node        cdid_Node;        /* ln_Name zeigt auf CD-ID */
  90.     char            cdid_CDID[20];
  91. };
  92.  
  93.  
  94. /*----- interne Funktionen -----< >-*/
  95. struct List *GetDirContents(char *dirname);
  96. void ShowTitles(struct List *list, ULONG pos);
  97. void DeleteTitle(struct List *list, ULONG item);
  98.  
  99. BOOL InitAll(char *progname);
  100. void FreeAll(void);
  101. BOOL InitTimer(void);
  102. void FreeTimer(void);
  103. void AddTimeRequest(ULONG micro);
  104.  
  105. BOOL OpenLibs(void);
  106. void CloseLibs(void);
  107. char *OpenFile(char * name);
  108. void FreeList(List *list);
  109. LONG FindNodeName(List *list, char *name);
  110. Node *FindNode(List * list, ULONG number);
  111.  
  112. /*----- externe Funktionen -----< >-*/
  113. #include "Quick.h"
  114.  
  115.  
  116.  
  117. /*------------------ main() -----------------------------------< >-*/
  118. int main(int argc, char *argv[])
  119. {
  120.     struct Gadget *glist, *aktgad;
  121.     struct IntuiMessage *imsg;
  122.     struct Screen *screen;
  123.     struct List    *idlist;
  124.  
  125.     APTR visualinfo;
  126.     BOOL terminate = FALSE;
  127.     UBYTE laststatus = AUDIO_STAT_NO_DISK;
  128.     UWORD imsgcode, fontY;
  129.     WORD lastitem = ~0;
  130.     ULONG rc = RETURN_FAIL, imsgclass, seconds, lastseconds=0, micros, lastmicros=0;
  131.  
  132.     if (!OpenLibs())
  133.     {
  134.         CloseLibs();
  135.         return(rc);
  136.     }
  137.  
  138.     if (InitAll(argv[0]))
  139.     {
  140.         if (screen = LockPubScreen("Workbench"))
  141.         {
  142.             fontY = screen->Font->ta_YSize;
  143.  
  144.             if (visualinfo = GetVisualInfo(screen, TAG_END))
  145.             {
  146.                 if (aktgad = CreateContext(&glist))
  147.                 {
  148.                     struct NewGadget ng = {    screen->WBorLeft + 4,        // ng_LeftEdge,
  149.                                             screen->WBorTop+2*fontY+8,    // ng_TopEdge,
  150.                                             192 - screen->WBorLeft - screen->WBorRight,    // ng_Width,
  151.                                             8*fontY,            // ng_Height,
  152.                                             "Known CDs",        // ng_GadgetText,
  153.                                             NULL,                 // ng_TextAttr,
  154.                                             GAD_LIST,            // ng_GadgetID,
  155.                                             0,                    // ng_Flags,
  156.                                             visualinfo,            // ng_VisualInfo,
  157.                                             NULL        };        // ng_UserData
  158.  
  159.                     idlist = GetDirContents(destpath);
  160.                     mygad[GAD_LIST] = aktgad = CreateGadget(LISTVIEW_KIND, aktgad, &ng, GTLV_ShowSelected, FALSE, GTLV_Labels, idlist, GTLV_ScrollWidth, 2*fontY, TAG_END);
  161.  
  162.                     ng.ng_GadgetID        = GAD_DELETE;
  163.                     ng.ng_TopEdge        += ng.ng_Height+1;
  164.                     ng.ng_Width            = aktgad->Width;
  165.                     ng.ng_Height        = fontY+6;
  166.                     ng.ng_GadgetText    = "_Delete";
  167.                     mygad[GAD_DELETE] = aktgad = CreateGadget(BUTTON_KIND, aktgad, &ng, GT_Underscore, '_', GA_Disabled, IsListEmpty(idlist), TAG_END);
  168.  
  169.                     if (window = OpenWindowTags(NULL,
  170.                             WA_Left,        220,
  171.                             WA_Top,            100,
  172.                             WA_Width,        200,
  173.                             WA_Height,        aktgad->TopEdge + aktgad->Height + 14,
  174.                             WA_Title,        "PickCDID V0.9",
  175.                             WA_Gadgets,        glist,
  176.                             WA_PubScreen,    screen,
  177.                             WA_Flags,        WFLG_SIZEGADGET | WFLG_DRAGBAR | WFLG_DEPTHGADGET | WFLG_CLOSEGADGET | WFLG_SIZEBBOTTOM | WFLG_ACTIVATE,
  178.                             WA_IDCMP,        LISTVIEWIDCMP | BUTTONIDCMP | IDCMP_VANILLAKEY | IDCMP_RAWKEY | IDCMP_CLOSEWINDOW | IDCMP_REFRESHWINDOW | IDCMP_NEWSIZE,
  179.                             WA_AutoAdjust,    TRUE,
  180.                             WA_MinWidth,    100,
  181.                             WA_MinHeight,    100,
  182.                             WA_MaxWidth,    ~0,
  183.                             WA_MaxHeight,    ~0,
  184.                             TAG_END))
  185.                     {
  186.                         GT_RefreshWindow(window, NULL);
  187.                         AddTimeRequest(10);
  188.  
  189.                         while (!terminate)
  190.                         {
  191.                             Wait((1L << window->UserPort->mp_SigBit) | (1L << timer_mp->mp_SigBit));
  192.  
  193.                             if (GetMsg(timer_mp))
  194.                             {
  195.                                 /* Update wird fällig */
  196.                                 CDUpdateA(cdx);
  197.                                 if (cdx->cdx_AudioStatus != laststatus)
  198.                                 {
  199.                                     /* wurde CD eingelegt? */
  200.                                     if (laststatus == AUDIO_STAT_NO_DISK)
  201.                                     {
  202.                                         char IDBuffer[20];
  203.                                         ULONG i;
  204.                                         strcpy(IDBuffer, "ID");
  205.                                         strncat(IDBuffer, cdx->cdx_TOCData->CDID, 17);
  206.  
  207.                                         /* Diskfile der eingelegten CD nicht vorhanden? */
  208.                                         if ((i = FindNodeName(idlist, IDBuffer)) == ~0)
  209.                                         {
  210.                                             char filename[256];
  211.                                             char *file;
  212.  
  213.                                             strcpy(filename, sourcepath);
  214.                                             AddPart(filename, IDBuffer, 255);
  215.  
  216.                                             /* Diskfile aus der Sammlung laden */
  217.                                             if (file = OpenFile(filename))
  218.                                             {
  219.                                                 BPTR fh;
  220.                                                 strcpy(filename, destpath);
  221.                                                 AddPart(filename, IDBuffer, 255);
  222.  
  223.                                                 /* Diskfile ins Zielverzeichnis kopieren */
  224.                                                 if (fh = Open(filename, MODE_NEWFILE))
  225.                                                 {
  226.                                                     struct CDIDNode *tempnode;
  227.  
  228.                                                     Write(fh, file+4, *(ULONG *)file);
  229.                                                     Close(fh);
  230.                                                     SetProtection(filename, FIBF_EXECUTE);
  231.  
  232.                                                     /* neues Listview-Item dazu */
  233.                                                     if (tempnode = GetVecA(sizeof(struct CDIDNode), MEMF_PUBLIC | MEMF_CLEAR))
  234.                                                     {
  235.                                                         strncpy(tempnode->cdid_CDID, IDBuffer, 19);
  236.                                                         tempnode->cdid_Node.ln_Name = tempnode->cdid_CDID;
  237.                                                         GT_SetGadgetAttrs(mygad[GAD_LIST], window, NULL, GTLV_Labels, ~0, TAG_END);
  238.                                                         AddTail(idlist, (struct Node *)tempnode);
  239.                                                         lastitem = i = FindNodeName(idlist, IDBuffer);
  240.                                                         GT_SetGadgetAttrs(mygad[GAD_LIST], window, NULL, GTLV_Labels, idlist, GTLV_Selected, i, GTLV_MakeVisible, i, TAG_END);
  241.                                                         /* Liste nicht mehr leer? */
  242.                                                         if (i==0)
  243.                                                             GT_SetGadgetAttrs(mygad[GAD_DELETE], window, NULL, GA_Disabled, FALSE, TAG_END);
  244.                                                         if (autoej)
  245.                                                             CDEjectA(cdx, TRUE);
  246.                                                     }
  247.                                                 }
  248.                                                 FreeVec(file);
  249.                                             }
  250.                                             else DisplayBeep(NULL);
  251.                                         }
  252.                                         else
  253.                                         {
  254.                                             GT_SetGadgetAttrs(mygad[GAD_LIST], window, NULL, GTLV_Selected, i, GTLV_MakeVisible, i, TAG_END);
  255.                                             lastitem = i;
  256.                                         }
  257.                                     }
  258.                                     laststatus = cdx->cdx_AudioStatus;
  259.                                 }
  260.  
  261.                                 /* Damit immer ein Item selektiert ist */
  262.                                 if (lastitem == ~0 && !IsListEmpty(idlist))
  263.                                 {
  264.                                     GT_SetGadgetAttrs(mygad[GAD_LIST], window, NULL, GTLV_Selected, 0, TAG_END);
  265.                                     lastitem = 0;
  266.                                 }
  267.  
  268.                                 /* In 0,25s nächstes Update */
  269.                                 AddTimeRequest(250000);
  270.                             }
  271.  
  272.                             while (imsg = GT_GetIMsg(window->UserPort))
  273.                             {
  274.                                 aktgad = (struct Gadget *)imsg->IAddress;
  275.                                 imsgclass = imsg->Class;
  276.                                 imsgcode = imsg->Code;
  277.                                 seconds = imsg->Seconds;
  278.                                 micros = imsg->Micros;
  279.  
  280.                                 GT_ReplyIMsg(imsg);
  281.  
  282.                                 switch(imsgclass)
  283.                                 {
  284.                                     case IDCMP_NEWSIZE:
  285.                                         RemoveGList(window, glist, -1);
  286.                                         FreeGadgets(glist);
  287.  
  288.                                         EraseRect(window->RPort,    window->BorderLeft, window->BorderTop,
  289.                                                                     window->Width  - window->BorderRight  - 1,
  290.                                                                     window->Height - window->BorderBottom - 1);
  291.                                         RefreshWindowFrame(window);
  292.  
  293.                                         aktgad = CreateContext(&glist);
  294.  
  295.                                         ng.ng_LeftEdge    = window->BorderLeft + 4;
  296.                                         ng.ng_TopEdge    = window->BorderTop + fontY + 7;
  297.                                         ng.ng_Width        = window->Width - window->BorderLeft - window->BorderRight - 8;
  298.                                         ng.ng_Height    = window->Height - window->BorderTop - window->BorderBottom - 2*fontY - 16;
  299.                                         ng.ng_GadgetText= "Known CDs";
  300.                                         ng.ng_GadgetID    = GAD_LIST;
  301.                                         mygad[GAD_LIST] = aktgad = CreateGadget(LISTVIEW_KIND, aktgad, &ng, GTLV_ShowSelected, FALSE, GTLV_Labels, idlist, GTLV_ScrollWidth, 2*fontY, GTLV_Selected, lastitem, GTLV_MakeVisible, lastitem, TAG_END);
  302.  
  303.                                         ng.ng_TopEdge        += (ng.ng_Height+aktgad->Height)/2 + 1;
  304.                                         ng.ng_Width            = aktgad->Width;
  305.                                         ng.ng_Height        = fontY+6;
  306.                                         ng.ng_GadgetText    = "_Delete";
  307.                                         ng.ng_GadgetID        = GAD_DELETE;
  308.                                         mygad[GAD_DELETE] = aktgad = CreateGadget(BUTTON_KIND, aktgad, &ng, GT_Underscore, '_', GA_Disabled, IsListEmpty(idlist), TAG_END);
  309.  
  310.                                         AddGList(window, glist, ~0, -1, NULL);
  311.                                         RefreshGList(glist, window, NULL, -1);
  312.                                         GT_RefreshWindow(window, NULL);
  313.                                         break;
  314.  
  315.                                     case IDCMP_GADGETUP:
  316.                                         switch(aktgad->GadgetID)
  317.                                         {
  318.                                             case GAD_LIST:
  319.                                                 if (lastitem == imsgcode && DoubleClick(lastseconds, lastmicros, seconds, micros))
  320.                                                 {
  321.                                                     ShowTitles(idlist, lastitem);
  322.  
  323.                                                     lastseconds = 0;
  324.                                                     lastmicros    = 0;
  325.                                                 }
  326.                                                 else
  327.                                                 {
  328.                                                     lastseconds = seconds;
  329.                                                     lastmicros    = micros;
  330.                                                     lastitem = imsgcode;
  331.                                                 }
  332.                                                 break;
  333.  
  334.                                             case GAD_DELETE:
  335.                                                 if (lastitem != ~0 && !IsListEmpty(idlist))
  336.                                                 {
  337.                                                     DeleteTitle(idlist, lastitem);
  338.                                                     /* Wenn unterstes Item eines LVs gelöscht wird rutscht das LV nach oben */
  339.                                                     if (lastitem >= ListLengthA(idlist))
  340.                                                         lastitem = ListLengthA(idlist)-1;
  341.                                                 }
  342.                                         }
  343.                                         break;
  344.  
  345.                                     case IDCMP_VANILLAKEY:
  346.                                         switch (imsgcode)
  347.                                         {
  348.                                             case 13:    /* Return */
  349.                                                 ShowTitles(idlist, lastitem);
  350.                                                 break;
  351.                                             case 32:    /* Space */
  352.                                                 if (!CDTestUnitA(cdx) || (cdx->cdx_Flags & SPECIALF_JUSTCLOSED))
  353.                                                     CDEjectA(cdx, TRUE);
  354.                                                 else
  355.                                                     CDEjectA(cdx, FALSE);
  356.                                                 break;
  357.                                             case 'd':
  358.                                             case 'D':
  359.                                             case 127:    /* Delete */
  360.                                                 if (lastitem != ~0 && !IsListEmpty(idlist))
  361.                                                 {
  362.                                                     DeleteTitle(idlist, lastitem);
  363.                                                     if (lastitem >= ListLengthA(idlist))
  364.                                                         lastitem = ListLengthA(idlist)-1;
  365.                                                 }
  366.                                                 break;
  367.                                             case 27:    /* ESC */
  368.                                                 terminate = TRUE;
  369.                                         }
  370.                                         break;
  371.  
  372.                                     case IDCMP_RAWKEY:
  373.                                         if (lastitem != ~0 && !IsListEmpty(idlist))
  374.                                         {
  375.                                             switch (imsgcode)
  376.                                             {
  377.                                                 case 0x4C:    /* Cursor hoch */
  378.                                                     if (lastitem > 0)
  379.                                                     {
  380.                                                         lastitem--;
  381.                                                         GT_SetGadgetAttrs(mygad[GAD_LIST], window, NULL, GTLV_Selected, lastitem, GTLV_MakeVisible, lastitem, TAG_END);
  382.                                                     }
  383.                                                     break;
  384.                                                 case 0x4D:    /* Cursor runter */
  385.                                                     if (lastitem < ListLengthA(idlist)-1)
  386.                                                     {
  387.                                                         lastitem++;
  388.                                                         GT_SetGadgetAttrs(mygad[GAD_LIST], window, NULL, GTLV_Selected, lastitem, GTLV_MakeVisible, lastitem, TAG_END);
  389.                                                     }
  390.                                                     break;
  391.                                             }
  392.                                         }
  393.                                         break;
  394.  
  395.                                     case IDCMP_CLOSEWINDOW:
  396.                                         terminate = TRUE;
  397.                                         break;
  398.  
  399.                                     case IDCMP_REFRESHWINDOW:
  400.                                         GT_BeginRefresh(window);
  401.                                         GT_EndRefresh(window, TRUE);
  402.                                 }
  403.                             }
  404.                         }
  405.                         CloseWindow(window);
  406.                         /* Damit nicht auf Antwort gewartet werden muß */
  407.                         if (!GetMsg(timer_mp))
  408.                         {
  409.                             AbortIO((struct IORequest *)timereq);
  410.                             WaitIO((struct IORequest *)timereq);
  411.                         }
  412.  
  413.                         rc = RETURN_OK;
  414.                     }
  415.                     FreeGadgets(glist);
  416.                     FreeList(idlist);
  417.                 }
  418.                 FreeVisualInfo(visualinfo);
  419.             }
  420.             UnlockPubScreen(NULL, screen);
  421.         }
  422.         FreeAll();
  423.     }
  424.  
  425.     CloseLibs();
  426.  
  427.     return rc;
  428. }
  429.  
  430. /*------------------ GetDirContents() -------------------------< >-*/
  431. struct List *GetDirContents(char *dirname)
  432. {
  433.     BPTR filelock;
  434.     struct FileInfoBlock *fib;
  435.     struct List *dirlist = NULL;
  436.  
  437.     if (filelock = Lock(dirname, SHARED_LOCK))
  438.     {
  439.         if (fib = (struct FileInfoBlock *)AllocDosObject(DOS_FIB, NULL))
  440.         {
  441.             if (Examine(filelock, fib) != DOSFALSE)
  442.             {
  443.                 /* Directory-Test */
  444.                 if (fib->fib_DirEntryType >= 0 && fib->fib_DirEntryType != ST_SOFTLINK)
  445.                 {
  446.                     if (dirlist = GetVecA(sizeof(struct List), MEMF_PUBLIC | MEMF_CLEAR))
  447.                     {
  448.                         struct CDIDNode *tempnode;
  449.                         NewList(dirlist);
  450.  
  451.                         while (ExNext(filelock, fib) != DOSFALSE)
  452.                         {
  453.                             /* Nur Files mit den Anfangsbuchstaben "ID" werden akzeptiert */
  454.                             if ((fib->fib_DirEntryType == ST_FILE || fib->fib_DirEntryType == ST_LINKFILE) && *(UWORD *)fib->fib_FileName == 0x4944)
  455.                             {
  456.                                 if (tempnode = GetVecA(sizeof(struct CDIDNode), MEMF_PUBLIC | MEMF_CLEAR))
  457.                                 {
  458.                                     strncpy(tempnode->cdid_CDID, fib->fib_FileName, 20);
  459.                                     tempnode->cdid_Node.ln_Name = tempnode->cdid_CDID;
  460.                                     AddTail(dirlist, (struct Node *)tempnode);
  461.                                 }
  462.                             }
  463.                         }
  464.                     }
  465.                 }
  466.             }
  467.             FreeDosObject(DOS_FIB, (APTR)fib);
  468.         }
  469.         UnLock(filelock);
  470.     }
  471.  
  472.     return (dirlist);
  473. }
  474. /*------------------ ShowTitles() -----------------------------< >-*/
  475. void ShowTitles(List *list, ULONG pos)
  476. {
  477.     struct Node *node;
  478.     char filename[256];
  479.     char *file;
  480.  
  481.     if (node = FindNode(list, pos))
  482.     {
  483.         strcpy(filename, destpath);
  484.         AddPart(filename, node->ln_Name, 256);
  485.  
  486.         if (file = (char *)OpenFile(filename))
  487.         {
  488.             if (IntuitionBase->lib_Version >= 39)
  489.                 SetWindowPointer(window, WA_BusyPointer, TRUE, TAG_END);
  490.  
  491.             ShowMsgA("CD Info", "%s", file+4);
  492.  
  493.             if (IntuitionBase->lib_Version >= 39)
  494.                 SetWindowPointer(window, WA_BusyPointer, FALSE, TAG_END);
  495.  
  496.             FreeVec(file);
  497.         }
  498.     }
  499. }
  500. /*------------------ DeleteTitle() ----------------------------< >-*/
  501. void DeleteTitle(struct List *list, ULONG item)
  502. {
  503.     char buffer[256];
  504.     struct Node *node = FindNode(list, item);
  505.  
  506.     if (node)
  507.     {
  508.         strcpy(buffer, destpath);
  509.         AddPart(buffer, node->ln_Name, 255);
  510.         if (DeleteFile(buffer))
  511.         {
  512.             GT_SetGadgetAttrs(mygad[GAD_LIST], window, NULL, GTLV_Labels, ~0, TAG_END);
  513.             Remove(node);
  514.             FreeVec(node);
  515.             GT_SetGadgetAttrs(mygad[GAD_LIST], window, NULL, GTLV_Labels, list, TAG_END);
  516.             if (IsListEmpty(list))
  517.                 GT_SetGadgetAttrs(mygad[GAD_DELETE], window, NULL, GA_Disabled, TRUE, TAG_END);
  518.         }
  519.     }
  520. }
  521.  
  522. /*------------------ InitAll() --------------------------------< >-*/
  523. BOOL InitAll(char *progname)
  524. {
  525.     if (devicename = GetVecA(32+256+256, MEMF_PUBLIC | MEMF_CLEAR))
  526.     {
  527.         struct DiskObject *dobj;
  528.         destpath = devicename + 32;
  529.         sourcepath = destpath + 256;
  530.  
  531.         /* Tooltypes auslesen */
  532.         if (dobj = GetDiskObject(progname))
  533.         {
  534.             char **toolarray, *s;
  535.             toolarray = dobj->do_ToolTypes;
  536.  
  537.             if (s = (char *)FindToolType((UBYTE **)toolarray, "DEVICE"))
  538.                 strncpy(devicename, s, 31);
  539.             if (s = (char *)FindToolType((UBYTE **)toolarray, "SOURCEPATH"))
  540.                 strncpy(sourcepath, s, 255);
  541.             if (s = (char *)FindToolType((UBYTE **)toolarray, "DESTPATH"))
  542.                 strncpy(destpath, s, 255);
  543.             if (s = (char *)FindToolType((UBYTE **)toolarray, "AUTOEJECT"))
  544.                 if (!strcmp(s, "NO") || !strcmp(s, "no"))
  545.                     autoej = FALSE;
  546.                 else
  547.                     autoej = TRUE;
  548.             if (s = (char *)FindToolType((UBYTE **)toolarray, "UNIT"))
  549.                 if (s[0] >= '0' && s[0] <= '7')
  550.                     unit = (ULONG)(s[0]-48);
  551.             if (s = (char *)FindToolType((UBYTE **)toolarray, "LUN"))
  552.                 if (s[0] >= '0' && s[0] <= '7')
  553.                     lun = (ULONG)(s[0]-48);
  554.  
  555.             FreeDiskObject(dobj);
  556.         }
  557.  
  558.  
  559.         if (cdx = CDOpenDeviceA(devicename, unit, lun))
  560.         {
  561.             if (InitTimer())
  562.             {
  563.                 return (TRUE);
  564.             }
  565.             CDCloseDeviceA(cdx);
  566.         }
  567.         FreeVec(devicename);
  568.     }
  569.     return (FALSE);
  570. }
  571. /*------------------ FreeAll() --------------------------------< >-*/
  572. void FreeAll(void)
  573. {
  574.     FreeTimer();
  575.     CDCloseDeviceA(cdx);
  576.     FreeVec(devicename);
  577. }
  578. /*------------------ InitTimer() ------------------------------< >-*/
  579. BOOL InitTimer(void)
  580. {
  581.     if (timer_mp = CreateMsgPort())
  582.     {
  583.         if (timereq = CreateIORequest(timer_mp, sizeof(struct timerequest)));
  584.         {
  585.             if (!OpenDevice("timer.device", UNIT_VBLANK, (struct IORequest *)timereq, 0L))
  586.             {
  587.                 return (TRUE);
  588.             }
  589.             DeleteIORequest(timereq);
  590.         }
  591.         DeleteMsgPort(timer_mp);
  592.     }
  593.  
  594.     return (FALSE);
  595. }
  596. /*------------------ FreeTimer() ------------------------------< >-*/
  597. void FreeTimer(void)
  598. {
  599.     CloseDevice((struct IORequest *)timereq);
  600.     DeleteIORequest(timereq);
  601.     DeleteMsgPort(timer_mp);
  602. }
  603. /*------------------ AddTimeRequest() -------------------------< >-*/
  604. void AddTimeRequest(ULONG micro)
  605. {
  606.     timereq->tr_node.io_Command = TR_ADDREQUEST;
  607.     timereq->tr_time.tv_secs    = 0;
  608.     timereq->tr_time.tv_micro    = micro;
  609.     SendIO((struct IORequest *)timereq);
  610. }
  611.  
  612. /*------------------ OpenLibs() -------------------------------< >-*/
  613. BOOL OpenLibs(void)
  614. {
  615.     if (IntuitionBase=OpenLibrary("intuition.library",37))
  616.     {
  617.         if (IconBase=OpenLibrary("icon.library",37))
  618.         {
  619.             if (GadToolsBase=OpenLibrary("gadtools.library",37))
  620.             {
  621.                 if (GfxBase=OpenLibrary("graphics.library",37))
  622.                 {
  623.                     ReqToolsBase=OpenLibrary("reqtools.library", 37);
  624.                     return(TRUE);
  625.                 }
  626.             }
  627.         }
  628.     }
  629.  
  630.     return(FALSE);
  631. }
  632. /*------------------ CloseLibs() ------------------------------< >-*/
  633. void CloseLibs(void)
  634. {
  635.     if (GfxBase)        CloseLibrary(GfxBase);
  636.     if (GadToolsBase)    CloseLibrary(GadToolsBase);
  637.     if (IconBase)        CloseLibrary(IconBase);
  638.     if (IntuitionBase)    CloseLibrary(IntuitionBase);
  639. }
  640. /*------------------ OpenFile() -------------------------------< >-*/
  641. char * OpenFile(char * name)
  642. {
  643.     BPTR filehandle;
  644.     struct FileInfoBlock *fib;
  645.     APTR buffer = NULL;
  646.  
  647.     /* Datei öffnen */
  648.     if (filehandle = Open(name, MODE_OLDFILE))
  649.     {
  650.         if (fib = (struct FileInfoBlock *)AllocDosObject(DOS_FIB, NULL))
  651.         {
  652.             /* FileInfoblock auslesen, für Dateigröße */
  653.             if (ExamineFH(filehandle, fib) == DOSTRUE)
  654.             {
  655.                 if (fib->fib_Size)
  656.                 {
  657.                     /* Speicher für File, Filelänge und Nullbyte reservieren */
  658.                     if (buffer = (char *)GetVecA(fib->fib_Size+5, MEMF_PUBLIC | MEMF_CLEAR))
  659.                     {
  660.                         *(ULONG *)buffer = fib->fib_Size;
  661.                         /* Datei in Speicher schreiben */
  662.                         if (Read(filehandle, (char *)buffer+4, fib->fib_Size) != fib->fib_Size)
  663.                         {
  664.                             FreeVec(buffer);
  665.                             buffer = NULL;
  666.                         }
  667.                     }
  668.                 }
  669.             }
  670.             FreeDosObject(DOS_FIB, (APTR)fib);
  671.         }
  672.         /* Datei schließen */
  673.         Close(filehandle);
  674.     }
  675.     return ((char *)buffer);
  676. }
  677. /*------------------ FreeList() -------------------------------< >-*/
  678. void FreeList(List *list)
  679. {
  680.     if (list)
  681.     {
  682.         Node *temp_node, *next_temp_node;
  683.  
  684.         for (temp_node = list->lh_Head; temp_node->ln_Succ;)
  685.         {
  686.             next_temp_node = temp_node->ln_Succ;
  687.             FreeVec(temp_node);
  688.             temp_node = next_temp_node;
  689.         }
  690.  
  691.         FreeVec(list);
  692.     }
  693. }
  694. /*------------------ FindNodeName() ---------------------------< >-*/
  695. LONG FindNodeName(List *list, char *name)
  696. {
  697.     register Node *node = list->lh_Head;
  698.     register LONG i=0;
  699.  
  700.     for (node = list->lh_Head ; node->ln_Succ && strcmp(name, node->ln_Name) ; node = node->ln_Succ)
  701.         i++;
  702.  
  703.     return (node->ln_Succ?i:~0);
  704. }
  705. /*------------------ FindNode() -------------------------------< >-*/
  706. Node *FindNode(List * list, ULONG number)
  707. {
  708.     register Node *tempnode = list->lh_Head;
  709.     ULONG i;
  710.  
  711.     for (i = 0; i < number; i++)
  712.     {
  713.         if (tempnode->ln_Succ)
  714.             tempnode = tempnode->ln_Succ;
  715.         else
  716.             break;
  717.     }
  718.  
  719.     return (tempnode->ln_Succ?tempnode:NULL);
  720. }