home *** CD-ROM | disk | FTP | other *** search
/ World of A1200 / World_Of_A1200.iso / programs / monitors / rsys / source.lha / src / rsysutils.c < prev    next >
C/C++ Source or Header  |  1995-01-09  |  24KB  |  1,075 lines
  1. /*
  2. ***************************************************************************
  3. *
  4. * Datei:
  5. *    RSysUtils.c
  6. *
  7. * Inhalt:
  8. *    char *strncpy(char *dest, char const *src, unsigned long len);
  9. *    char *strcpy(char *dest, char const *src);
  10. *    void *MyAllocVec(unsigned long byteSize, unsigned long requirements, int kill);
  11. *    void MyFreeVec(void *memptr);
  12. *    long Command(struct Node *node, char *file);
  13. *    void ToggleFastMode(void);
  14. *    void ToggleAskingMode(void);
  15. *    void ToggleSortMode(void);
  16. *    void ToggleSpeakMode(void);
  17. *    void ToggleAutoFront(void);
  18. *    void ToggleMouseWindow(void);
  19. *    void ToggleTopazFont(void);
  20. *    void AddNodeSorted(struct List *list, struct Node *node);
  21. *    void AddNodeToList(int i, int sort_in);
  22. *    void CreateEntryList(int sorting);
  23. *    char *B2CStr(char *ret, long inp);
  24. *    void savestrcpy(char *str, struct Node *node, int cnt, int type);
  25. *    struct Node *GetNode(struct List *list, unsigned long offset);
  26. *    long SizeOfFile(char *Name);
  27. *    int SizeOfDir(long lock, long *Size, int *Dirs);
  28. *    struct SE *AllocScrollEntries(int count);
  29. *    long getdisktype(long lock);
  30. *    void FreeBytes(char *Vol, long *free, long *used, long *usedpercent, char *state, char *type);
  31. *    int exist(char *name);
  32. *    void quit(int askyou);
  33. *    int Question(struct Window *wind, char *ask, int def);
  34. *    void OpenLibs(void);
  35. *    void CloseLibs(void);
  36. *    void CloseAll(void);
  37. *
  38. * Bemerkungen:
  39. *    Utilities, die im ganzen Programm verwendet werden, z.B.
  40. *    Listen- und Stringverwaltungsroutinen.
  41. *
  42. * Erstellungsdatum:
  43. *    07-Jan-93    Rolf Böhme
  44. *
  45. * Änderungen:
  46. *    07-Jan-93    Rolf Böhme    Erstellung
  47. *
  48. ***************************************************************************
  49. */
  50.  
  51. #include "RSysDebug.h"
  52. #include "RSysFunc.h"
  53.  
  54. extern struct Library *IconBase;
  55.  
  56.    /*
  57.     * strncpy() ersetzt die Compiler-Routine. Im Gegensatz zur
  58.     * Orginalroutine wird der Zielstring korrekt terminiert
  59.     */
  60. char *
  61. strncpy(char *dest, const char *src, size_t len)
  62. {
  63.    register size_t i = len;
  64.    char *tmp = dest;
  65.  
  66.    if (src)
  67.       while ((*(tmp++) = *(src++)) && --i) ;
  68.  
  69.    *tmp = STRINGEND;
  70.  
  71.    return (dest);
  72. }
  73.  
  74.    /*
  75.     * strcpy() ersetzt die Compiler-Routine. Im Gegensatz zur
  76.     * Orginalroutine wird überprüft, ob der Quellstring
  77.     * überhaupt existiert und kein NULL-Zeiger übergeben
  78.     * wurde
  79.     */
  80. char *
  81. strcpy(char *dest, const char *src)
  82. {
  83.    char *tmp = dest;
  84.  
  85.    if (src)
  86.       while (*(tmp++) = *(src++)) ;
  87.    else
  88.       *tmp = STRINGEND;
  89.  
  90.    return (dest);
  91. }
  92.  
  93.    /*
  94.     * MyAllocVec() ist eine Erweiterung der AllocVec()-Routine. In
  95.     * einem Fehlerfall wird eine Meldung ausgegeben und das
  96.     * Programm evtl korrekt beendet
  97.     */
  98. void *
  99. MyAllocVec(unsigned long byteSize, unsigned long requirements, int kill)
  100. {
  101.    void *memptr = NULL;
  102.  
  103.    DPOS;
  104.  
  105.    if (NOT(memptr = AllocVec(byteSize, requirements)))
  106.       ErrorHandle(MEMORY_ERR, ALLOC_FAIL, kill);
  107.  
  108.    return (memptr);
  109. }
  110.  
  111.    /*
  112.     * MyFreeVec() prüft im Gegensatz zu Originalroutine, ob ein
  113.     * NULL-Zeiger übergeben wurde
  114.     */
  115. void
  116. MyFreeVec(void *memptr)
  117. {
  118.    DPOS;
  119.  
  120.    if (memptr != NULL)
  121.       FreeVec(memptr);
  122.  
  123.    memptr = NULL;
  124.  
  125.    return;
  126. }
  127.  
  128. extern UBYTE autocon[];
  129.  
  130.    /*
  131.     * Command() führt einen Befehl in einem eigenen Prozeß aus.
  132.     * Als Aus- und Eingabekanal wird das Window verwendet, das im
  133.     * RSys-Icon festgelegt wurde
  134.     */
  135. LONG
  136. Command(struct Node *node, char *file)
  137. {
  138.    struct TagItem stags[5];
  139.    LONG  result = -2;
  140.    BPTR  fileptr;
  141.    struct _acts *Act = (struct _acts *) node;
  142.    UBYTE cmd[512];
  143.  
  144.    DPOS;
  145.  
  146.    if (node && strcmp(Act->act_command, field[NO_FIELD]) &&
  147.        (fileptr = Open(autocon, MODE_OLDFILE)))
  148.    {
  149.       stags[0].ti_Tag = SYS_Input;
  150.       stags[0].ti_Data = fileptr;
  151.       stags[1].ti_Tag = SYS_Output;
  152.       stags[1].ti_Data = NULL;
  153.       stags[2].ti_Tag = SYS_Asynch;
  154.       stags[2].ti_Data = FALSE;
  155.       stags[3].ti_Tag = SYS_UserShell;
  156.       stags[3].ti_Data = TRUE;
  157.       stags[4].ti_Tag = TAG_DONE;
  158.  
  159.       sprintf((char *)cmd, "%s \"%s\"", Act->act_command, file);
  160.  
  161.       result = System(cmd, stags);
  162.       if (result == -1L)
  163.       {
  164.          Close(fileptr);
  165.          ErrorHandle(TASK_ERR, CREATE_FAIL, NO_KILL);
  166.       }
  167.    }
  168.  
  169.    return (result);
  170. }
  171.  
  172.    /*
  173.     * ToggleFastMode() schaltet zwischen der schnellen Anzeige (die
  174.     * Listenelemente werden während der Erzeugung nicht angezeigt)
  175.     * und der langsamen Anzeige (wenn ein Eintrag erzeugt wurde,
  176.     * wird er sofort angezeigt)
  177.     */
  178. void
  179. ToggleFastMode(void)
  180. {
  181.    DPOS;
  182.  
  183.    Flags.fastmode = ~Flags.fastmode;
  184.  
  185.    PrintInfo(Flags.fastmode ? "Fast mode on" : "Fast mode off", SPEAK, SEC);
  186.  
  187.    PrintStatistics();
  188.  
  189.    return;
  190. }
  191.  
  192.    /*
  193.     * ToggleAskingMode() schaltet die Sicherheits-
  194.     * abfrage bei kritischen Aktionen ein oder aus
  195.     */
  196. void
  197. ToggleAskingMode(void)
  198. {
  199.    DPOS;
  200.  
  201.    Flags.saveasking = ~Flags.saveasking;
  202.  
  203.    PrintInfo(Flags.saveasking ? "Save asking mode on" : "Save asking mode off", SPEAK, SEC);
  204.  
  205.    PrintStatistics();
  206.  
  207.    return;
  208. }
  209.  
  210.    /*
  211.     * ToggleSortMode() schaltet zwischen dem sortierten und
  212.     * direkten Einfügen von Listenelementen um
  213.     */
  214. void
  215. ToggleSortMode(void)
  216. {
  217.    DPOS;
  218.  
  219.    Flags.sortmode = ~Flags.sortmode;
  220.  
  221.    PrintInfo(Flags.sortmode ? "List sorting on" : "List sorting off", SPEAK, SEC);
  222.  
  223.    RefreshList(LastID);
  224.  
  225.    PrintStatistics();
  226.  
  227.    return;
  228. }
  229.  
  230.    /*
  231.     * ToggleWorkingBar() schaltet die Anzeige des Working Bars
  232.     * (Anzeigestatus in Form eines Laufbalkens) um
  233.     */
  234. void
  235. ToggleWorkingBar(void)
  236. {
  237.    DPOS;
  238.  
  239.    Flags.workingbar = ~Flags.workingbar;
  240.  
  241.    PrintInfo(Flags.workingbar ? "Working bar on" : "Working bar off", SPEAK, SEC);
  242.  
  243.    RefreshList(LastID);
  244.  
  245.    PrintStatistics();
  246.  
  247.    return;
  248. }
  249.  
  250.    /*
  251.     * ToggleSpeakMode() schaltet die Sprachausgabe ein oder aus.
  252.     * Alle Mitteilungen, die im Textgadget unten im Hauptwindow
  253.     * erscheinen, werden über das narrator.device ausgegeben, wenn
  254.     * der Modus eingeschaltet wurde
  255.     */
  256. void
  257. ToggleSpeakMode(void)
  258. {
  259.    DPOS;
  260.  
  261.    Flags.speakmode = ~Flags.speakmode;
  262.  
  263.    if (NOT(Flags.speakmode))
  264.       RemoveSpeech();
  265.    else if (NOT(InitSpeech()))
  266.       Flags.speakmode = ~Flags.speakmode;
  267.  
  268.    PrintInfo(Flags.speakmode ? "Speak mode on" : "Speak mode off", SPEAK, SEC);
  269.  
  270.    PrintStatistics();
  271.  
  272.    return;
  273. }
  274.  
  275.    /*
  276.     * ToggleAutoFront() ermöglicht das Öffnen eines Fensters
  277.     * mit anschließendem Nach-Vorne-Bringen dieses Fensters
  278.     */
  279. void
  280. ToggleAutoFront(void)
  281. {
  282.    DPOS;
  283.  
  284.    Flags.autofront = ~Flags.autofront;
  285.  
  286.    PrintInfo(Flags.autofront ? "Auto front on" : "Auto front off", SPEAK, SEC);
  287.  
  288.    PrintStatistics();
  289.  
  290.    return;
  291. }
  292.  
  293.    /*
  294.     * ToggleMouseWindow() schaltet die Möglichkeit ein oder aus,
  295.     * alle Fenster von RSys unter dem Mauszeiger zu öffnen
  296.     */
  297. void
  298. ToggleMouseWindow(void)
  299. {
  300.    DPOS;
  301.  
  302.    Flags.mousewindow = ~Flags.mousewindow;
  303.  
  304.    PrintInfo(Flags.mousewindow ? "Mouse window on" : "Mouse window off", SPEAK, SEC);
  305.  
  306.    PrintStatistics();
  307.  
  308.    return;
  309. }
  310.  
  311.    /*
  312.     * ToggleTopazFont() schaltet zwischen der Verwendung des
  313.     * System-Fonts und dem Topaz-Font um. Wird als
  314.     * System-Workbench-Font ein proportionaler Zeichensatz
  315.     * gewählt, sehen die Listen etwas unformatiert aus. Topaz ist
  316.     * ein unproportionaler Font, der Listen korrekt formatiert
  317.     * darstellt
  318.     */
  319. void
  320. ToggleTopazFont(void)
  321. {
  322.    extern int ReopenWindow;
  323.  
  324.    D(kprintf("----------------------------\n"));
  325.  
  326.    DPOS;
  327.  
  328.    Flags.sysfont = ~Flags.sysfont;
  329.  
  330.    CloseASysWindow(&SysWnd, &SysGList, &SysMenus);
  331.    CloseDownScreen();
  332.  
  333.    OpenMainWindow();
  334.  
  335.    RefreshList(LastID);
  336.  
  337.    PrintInfo(Flags.sysfont ? "Topaz font on" : "Topaz font off", SPEAK, SEC);
  338.  
  339.    PrintStatistics();
  340.  
  341.    ReopenWindow = TRUE;
  342.  
  343.    DPOS;
  344.  
  345.    D(kprintf("----------------------------\n"));
  346.  
  347.    return;
  348. }
  349.  
  350.    /*
  351.     * StrICmp() ersetzt die Utility-Library- und Aztec-C-Routine.
  352.     * Beide liefern enforcer-Hits, falls man sie mit Leer- oder
  353.     * NULL-Strings aufruft
  354. static int
  355. StrICmp(const char *s1, char *s2)
  356. {
  357.    int   c1,
  358.          c2,
  359.          diff = 0;
  360.  
  361.    while (s1 && *s1 && s2 && *s2 && (diff == 0))
  362.    {
  363.       c1 = toupper((int)(*s1));
  364.       c2 = toupper((int)(*s2));
  365.       diff = c1 - c2;
  366.  
  367.       s1++;
  368.       s2++;
  369.    }
  370.  
  371.    return (diff);
  372. }
  373.     */
  374.  
  375.    /*
  376.     * AddNodeSorted() sortiert ein Listenelement in eine
  377.     * bestehende Liste ein. Da die hier betrachteten Listen
  378.     * ziemlich klein sind, wird hier ein einfaches Sortieren durch
  379.     * Einfügen verwendet
  380.     */
  381. void
  382. AddNodeSorted(struct List *list, struct Node *node)
  383. {
  384.    struct Node *head = list->lh_Head,
  385.         *loop_node;
  386.    BOOL  ins = FALSE;
  387.  
  388.    if (IsListEmpty(list))
  389.       AddHead(list, node);
  390.    else if (head->ln_Succ == NULL)
  391.    {
  392.       if (Stricmp((STRPTR)head->ln_Name, (STRPTR)node->ln_Name) <= 0L)
  393.          AddTail(list, node);
  394.       else
  395.          AddHead(list, node);
  396.  
  397.       ins = TRUE;
  398.    }
  399.    else
  400.    {
  401.       if (Stricmp((STRPTR)head->ln_Name, (STRPTR)node->ln_Name) > 0L)
  402.       {
  403.          AddHead(list, node);
  404.          ins = TRUE;
  405.       }
  406.  
  407.       for (loop_node = head;
  408.            loop_node->ln_Succ && loop_node->ln_Succ->ln_Succ && (ins == FALSE);
  409.            loop_node = loop_node->ln_Succ)
  410.       {
  411.          if ((Stricmp((STRPTR)loop_node->ln_Name, (STRPTR)node->ln_Name) <= 0L) &&
  412.              (Stricmp((STRPTR)node->ln_Name, (STRPTR)loop_node->ln_Succ->ln_Name) < 0L))
  413.          {
  414.             Insert(list, node, loop_node);
  415.             ins = TRUE;
  416.          }
  417.       }
  418.  
  419.       if (ins == FALSE)
  420.          AddTail(list, node);
  421.    }
  422.  
  423.    return;
  424. }
  425.  
  426. static ULONG xmin,ymin,xmax,ymax, textx, texty;
  427.  
  428.    /*
  429.     * InitBar() entfernt das Informationen-Text-Gadget; dabei
  430.     * bleibt der Rahmen stehen (dank Intuition). Dieser Rahmen
  431.     * wird dann als Begrenzung für den Statusbalken verwendet.
  432.     * Der Balkenbereich wird dann gelöscht und die Zeichenmodi
  433.     * eingestellt.
  434.     */
  435. static UWORD
  436. InitBar(void)
  437. {
  438.    extern long bpp;
  439.    extern int bpc, bgc;
  440.    UWORD pos = RemoveGadget(SysWnd,SysGadgets[18]);
  441.    struct RastPort *RP;
  442.  
  443.    RP = SysWnd->RPort;
  444.  
  445.    xmin = SysGadgets[18]->LeftEdge+1;
  446.    ymin = SysGadgets[18]->TopEdge+1;
  447.  
  448.    xmax = SysGadgets[18]->LeftEdge + SysGadgets[18]->Width-4;
  449.    ymax = SysGadgets[18]->TopEdge + SysGadgets[18]->Height-2;
  450.  
  451.    textx = xmin + 2 + (SysGadgets[18]->Width - 4 * (FontX + 1)) / 2;
  452.    texty = ymin + 1 + (SysGadgets[18]->Height - 2 - FontY) / 2 +
  453.            RP->TxBaseline;
  454.  
  455.    EraseRect(RP,xmin,ymin,xmax,ymax);
  456.  
  457.    SetDrMd(RP, JAM1);
  458.    SetAPen(RP,3);
  459.    SetBPen(RP,0);
  460.  
  461.    return(pos);
  462. }
  463.  
  464.    /*
  465.     * RefreshBar() aktualisiert die Anzeige des Statusbalkens.
  466.     * Dazu wird wie folgt vorgegangen:
  467.     * 1. Neue Breite des Balkens und Prozentzahl berechnen
  468.     * 2. Den Bereich mit Farbe füllen
  469.     * 3. Falls es nicht der letzte Eintrag war, wird
  470.     *    der Rest des Balkenbereichs (rechts) gelöscht
  471.     * 4. Die Prozentzahl wird entsprechend des Fonts in den
  472.     * Balken gesetzt.
  473.     */
  474. static void
  475. RefreshBar(int curr)
  476. {
  477.    ULONG percent = (100 * curr) / countentries,
  478.          xcurr = xmin + ((xmax-xmin) * curr) / countentries;
  479.    UBYTE percentstr[5] = " ";
  480.  
  481.    RectFill(SysWnd->RPort, xmin, ymin, xcurr, ymax);
  482.  
  483.    if(curr != countentries)
  484.       EraseRect(SysWnd->RPort, xcurr + 1, ymin, xmax, ymax);
  485. /*
  486.    Move(SysWnd->RPort,textx, texty);
  487.  
  488.    sprintf((char *)percentstr,"%3ld%%", percent);
  489.  
  490.    SetAPen(SysWnd->RPort,2);
  491.    Text(SysWnd->RPort,percentstr, strlen((char *)percentstr));
  492.  
  493.    SetAPen(SysWnd->RPort,3);
  494. */
  495.    if (Flags.fastmode)
  496.       WaitTOF();
  497.  
  498.    return;
  499. }
  500.  
  501.    /*
  502.     * RemoveBar() löscht den Bereich des für den Statusbalkens
  503.     * entfernten Gadgets und hängt das Gadget wieder ein
  504.     */
  505. static void
  506. RemoveBar(UWORD pos)
  507. {
  508.    SetAPen(SysWnd->RPort,0);
  509.  
  510.    EraseRect(SysWnd->RPort,xmin,ymin,xmax,ymax);
  511.  
  512.    AddGadget(SysWnd,SysGadgets[18], (ULONG)pos);
  513.  
  514.    RefreshGList(SysGadgets[18], SysWnd, NULL, 1);
  515.    GT_RefreshWindow( SysWnd, NULL );
  516.  
  517.    return;
  518. }
  519.  
  520.    /*
  521.     * AddNodeToList() ist eine Schnittstelle zwischen den Routinen
  522.     * AddNodeSorted() und AddTail(). Je nachdem, ob ein Element in
  523.     * die Liste sortiert einfügt werden soll oder nicht, werden
  524.     * die entsprechenden Routinen aufgerufen
  525.     */
  526. void
  527. AddNodeToList(int i, int sort_in)
  528. {
  529.    struct List *list = &ListeLVList;
  530.    struct Node *head = list->lh_Head,
  531.                *node = &(Entries[i].se_Node);
  532.    BOOL  ins = FALSE;
  533.    UWORD gadpos;
  534.  
  535.    if(Flags.workingbar && (i == 0))
  536.       gadpos = InitBar();
  537.  
  538.    if (Flags.sortmode && sort_in && head && node->ln_Name)
  539.       AddNodeSorted(list, node);
  540.    else
  541.       AddTail(list, node);
  542.  
  543.    if (NOT(Flags.fastmode))
  544.    {
  545.       RefreshListView();
  546.       WaitTOF();
  547.    }
  548.  
  549.    if(Flags.workingbar)
  550.    {
  551.       RefreshBar(i);
  552.  
  553.       if(i == (countentries - 1))
  554.       {
  555.          RefreshBar(countentries);
  556.          RemoveBar(gadpos);
  557.       }
  558.    }
  559.  
  560.    return;
  561. }
  562.  
  563.    /*
  564.     * CreateEntryList() fügt die Entries in die Anzeigeliste ein.
  565.     */
  566. void
  567. CreateEntryList(int sorting)
  568. {
  569.    register int i;
  570.  
  571.    for (i = 0; i < countentries; i++)
  572.       AddNodeToList(i, sorting);
  573.  
  574.    return;
  575. }
  576.  
  577.    /*
  578.     * B2CStr() wandelt einen BCPL-String in einen C-String um
  579.     */
  580. char *
  581. B2CStr(char *ret, BSTR inp)
  582. {
  583.    register int i;
  584.    char *help = (char *)BADDR(inp);
  585.  
  586.    DPOS;
  587.  
  588.    for (i = 0; i < *help; i++)
  589.       *(ret + i) = *(help + i + 1);
  590.  
  591.    *(ret + i) = STRINGEND;
  592.  
  593.    return (ret);
  594. }
  595.  
  596.    /*
  597.     * savestrcpy() kopiert eine Anzahl von Zeichen eines
  598.     * Node-Namens in einen Zielstring. Hierbei wird darauf
  599.     * geachtet, daß ein Node-Name überhaupt existiert
  600.     */
  601. void
  602. savestrcpy(char *str, struct Node *node, int cnt, int type)
  603. {
  604.    register int i = 0;
  605.  
  606.    DPOS;
  607.  
  608.    if(!node || !(node->ln_Name))
  609.    {
  610.       strcpy(str, field[NO_NODE]);
  611.       return;
  612.    }
  613.  
  614.    if((type == NT_TASK) && (node->ln_Type == NT_PROCESS))
  615.       type = NT_PROCESS;
  616.  
  617.    if((type == NT_SEMAPHORE) && (node->ln_Type == NT_SIGNALSEM))
  618.       type = NT_SIGNALSEM;
  619.  
  620.    if(node->ln_Type == type)
  621.       strncpy(str, node->ln_Name, cnt);
  622.    else
  623.       sprintf(str, field[WRONG_TYPE_FMT], node->ln_Type);
  624.  
  625.    return;
  626. }
  627.  
  628.    /*
  629.     * GetNode() ermittelt einen Eintrag, dessen Abstand vom
  630.     * Listenkopf in offset angegeben wird, also das offset'te
  631.     * Element
  632.     */
  633. struct Node *
  634. GetNode(struct List *list, ULONG offset)
  635. {
  636.    struct Node *Node;
  637.    LONG  i;
  638.  
  639.    DPOS;
  640.  
  641.    Node = (struct Node *) list->lh_Head;
  642.  
  643.    for (i = 0; i < offset; i++)
  644.    {
  645.       if (!Node->ln_Succ)
  646.          return (NULL);
  647.  
  648.       Node = Node->ln_Succ;
  649.    }
  650.  
  651.    return (Node);
  652. }
  653.  
  654.    /*
  655.     * SizeOfFile() ermittelt die Größe einer Datei
  656.     */
  657. long
  658. SizeOfFile(char *Name)
  659. {
  660.    struct FileInfoBlock *FileInfo;
  661.    LONG  FileSize = 0L;
  662.  
  663.    DPOS;
  664.  
  665.    if (NOT(exist(Name)))
  666.       return (FileSize);
  667.  
  668.    if (FileInfo = (struct FileInfoBlock *) AllocDosObject(DOS_FIB, TAG_DONE))
  669.    {
  670.       BPTR  FileLock;
  671.  
  672.       if (FileLock = Lock((UBYTE *) Name, ACCESS_READ))
  673.       {
  674.          if (Examine(FileLock, FileInfo))
  675.             FileSize = FileInfo->fib_Size;
  676.  
  677.          UnLock(FileLock);
  678.       }
  679.  
  680.       FreeDosObject(DOS_FIB, FileInfo);
  681.    }
  682.  
  683.    return (FileSize);
  684. }
  685.  
  686.    /*
  687.     * SizeOfDir() ermittelt die Größe eines Directories, also die
  688.     * Größe aller in ihr enthaltenen Dateien
  689.     */
  690. int
  691. SizeOfDir(BPTR lock, long *Size, int *Dirs)
  692. {
  693.    struct ExAllControl *eac;
  694.    struct ExAllData *EAData,
  695.         *ead;
  696.    int   cnt = 0,
  697.          more;
  698.  
  699.    DPOS;
  700.  
  701.    if (eac = AllocDosObject(DOS_EXALLCONTROL, NULL))
  702.    {
  703.       eac->eac_LastKey = 0;
  704.  
  705.       EAData = MyAllocVec(513 * sizeof(struct ExAllData),
  706.                           MEMF_ANY | MEMF_CLEAR, NO_KILL);
  707.  
  708.       if(EAData)
  709.       {
  710.          do
  711.          {
  712.             more = ExAll(lock, EAData, 512 * sizeof(struct ExAllData),
  713.                          ED_SIZE, eac);
  714.  
  715.             if ((!more) && (IoErr()!= ERROR_NO_MORE_ENTRIES))
  716.             {
  717.                ErrorHandle(DOS_EXALL_ERR, EXALL_FAIL, NO_KILL);
  718.                break;
  719.             }
  720.  
  721.             if (eac->eac_Entries == 0)
  722.                continue;
  723.  
  724.             ead = EAData;
  725.  
  726.             do
  727.             {
  728.                if (SetSignal(0L, SIGBREAKF_CTRL_C) & SIGBREAKF_CTRL_C)
  729.                {
  730.                   more = FALSE;
  731.                   break;
  732.                }
  733.  
  734.                *Size += ead->ed_Size;
  735.  
  736.                if (ead->ed_Type > 0)
  737.                   (*Dirs)++;
  738.                else
  739.                   cnt++;
  740.  
  741.                ead = ead->ed_Next;
  742.  
  743.             }
  744.             while (ead);
  745.          }
  746.          while (more);
  747.       }
  748.  
  749.       MyFreeVec(EAData);
  750.  
  751.       FreeDosObject(DOS_EXALLCONTROL, eac);
  752.    }
  753.    else
  754.       ErrorHandle(MEMORY_ERR, ALLOC_FAIL, KILL);
  755.  
  756.    return (cnt);
  757. }
  758.  
  759.    /*
  760.     * AllocScrollEntries() reserviert Speicher für die
  761.     * Listeneinträge des Haupt-ListViews. Werden weniger Einträge
  762.     * angefordert, als zuvor alloziert sind, wird kein neuer
  763.     * Speicher angefordert, sondern ein Zeiger auf die
  764.     * Ursprungs-Liste zurückgegeben, damit die Daten dann
  765.     * überschrieben werden können
  766.     */
  767. ScrollEntry *
  768. AllocScrollEntries(int count)
  769. {
  770.    register int i;
  771.    static int memcounter = 0;
  772.  
  773.    DPOS;
  774.  
  775.    if (count > memcounter)
  776.    {
  777.       if (Entries != NULL)
  778.       {
  779.          MyFreeVec(Entries);
  780.          Entries = NULL;
  781.       }
  782.  
  783.       if (Entries = (ScrollEntry *)MyAllocVec(count * sizeof(ScrollEntry),
  784.                                               MEMF_ANY | MEMF_CLEAR, KILL))
  785.       {
  786.          for (i = 0; i < count; i++)
  787.             Entries[i].se_Node.ln_Name = Entries[i].se_Entry;
  788.  
  789.          memcounter = count;
  790.  
  791.          return (Entries);
  792.       }
  793.    }
  794.    else
  795.       return (Entries);
  796.  
  797.    return (NULL);
  798. }
  799.  
  800.    /*
  801.     * getdisktype() holt aus einem FileLock die Typ-Nummer des
  802.     * angemeldeten Devices heraus
  803.     */
  804. long
  805. getdisktype(BPTR lock)
  806. {
  807.    struct FileLock *fl = (struct FileLock *) BADDR(lock);
  808.  
  809.    return (((struct DeviceList *)BADDR(fl->fl_Volume))->dl_DiskType);
  810. }
  811.  
  812.    /*
  813.     * FreeBytes() ermittelt die Daten eines Volumes
  814.     */
  815. void
  816. FreeBytes(char *Vol, long *free, long *used, long *usedpercent,
  817.           char *state, char *type)
  818. {
  819.    BPTR  lock = NULL;
  820.    register int i;
  821.    register struct InfoData *ID = NULL;
  822.    union
  823.    {
  824.       LONG  dostype;
  825.       char  dostypestr[5];
  826.    }     convert;
  827.  
  828.    DPOS;
  829.  
  830.    if (ID = (struct InfoData *) MyAllocVec(sizeof(struct InfoData),
  831.                                            MEMF_CLEAR, NO_KILL))
  832.    {
  833.       if (lock = Lock((UBYTE *) Vol, ACCESS_READ))
  834.       {
  835.          if (Info(lock, ID))
  836.          {
  837.             *free = (((ID->id_NumBlocks - ID->id_NumBlocksUsed) *
  838.                       ID->id_BytesPerBlock) >> 10);
  839.             *used = ((ID->id_NumBlocksUsed * ID->id_BytesPerBlock) >> 10);
  840.             *usedpercent = (100 * ID->id_NumBlocksUsed) / ID->id_NumBlocks;
  841.  
  842.             if((convert.dostype = getdisktype(lock)) == 0L)
  843.                convert.dostype = ID->id_DiskType;
  844.  
  845.             if (convert.dostype != (long)(-1))
  846.             {
  847.                strncpy(type, convert.dostypestr,4);
  848.                for (i = 0; i < 4; i++)
  849.                {
  850.                   type[i] += ((int)type[i] < 10 ? 0x30 : 0x20);
  851.                   type[i] = ToUpper((int)type[i]);
  852.                }
  853.             }
  854.             else
  855.                strcpy(type, "NODI");
  856.  
  857.             if (strstr(Vol, "AX") || strstr(Vol, "AMAX"))
  858.                strcpy(type, "AMAX");
  859.  
  860.             switch (ID->id_DiskState)
  861.             {
  862.                case ID_WRITE_PROTECTED:
  863.                   strcpy(state, "R/O");
  864.                   break;
  865.  
  866.                case ID_VALIDATING:
  867.                   strcpy(state, "VAL");
  868.                   break;
  869.  
  870.                case ID_VALIDATED:
  871.                   strcpy(state, "R/W");
  872.                   break;
  873.  
  874.                default:
  875.                   strcpy(state, field[NO_FIELD]);
  876.                   break;
  877.             }
  878.          }
  879.          else
  880.          {
  881.             *free = 0L;
  882.             *used = 0L;
  883.             *usedpercent = 0;
  884.             strcpy(state, "NST");
  885.             strcpy(type, "NINF");
  886.          }
  887.  
  888.          UnLock(lock);
  889.       }
  890.       else
  891.       {
  892.          *free = 0L;
  893.          *used = 0L;
  894.          *usedpercent = 0;
  895.          strcpy(type, field[NO_FIELD]);
  896.          strcpy(state, "NOL");
  897.       }
  898.  
  899.       MyFreeVec(ID);
  900.    }
  901.  
  902.    return;
  903. }
  904.  
  905.    /*
  906.     * exist() prüft, ob ein File oder Directory angegebenen Namens
  907.     * existiert
  908.     */
  909. int
  910. exist(char *name)
  911. {
  912.    BPTR  File;
  913.  
  914.    DPOS;
  915.  
  916.    if (NOT(name) || NOT(name[0]))
  917.       return (FALSE);
  918.  
  919.    if (File = Lock((UBYTE *) name, ACCESS_READ))
  920.    {
  921.       UnLock(File);
  922.       return (TRUE);
  923.    }
  924.  
  925.    return (FALSE);
  926. }
  927.  
  928.    /*
  929.     * quit() beendet nach einer Sicherheitsabfrage das Programm
  930.     */
  931. void
  932. quit(int askyou)
  933. {
  934.    WORD  check = 1;
  935.    UBYTE *answer = (UBYTE *)(Flags.wb_start ? "Yes|Iconify|No" : "Yes|No");
  936.    DPOS;
  937.  
  938.    if(Flags.saveasking && askyou)
  939.       check = MyEasyRequest(SysWnd, (UBYTE *) NAME " ask you",
  940.                             answer, (UBYTE *) "Quit program?");
  941.  
  942.    switch (check)
  943.    {
  944.       case 1:
  945.          PrintInfo("Bye bye", SPEAK, SEC);
  946.          CloseAll();
  947.          break;
  948.  
  949.       case 2:
  950.          if (!appicon)
  951.             Iconify();
  952.          break;
  953.  
  954.       default:
  955.          break;
  956.    }
  957.  
  958.    return;
  959. }
  960.  
  961.    /*
  962.     * Question() bietet eine Ja-Nein-Abfrage in Form eines
  963.     * System-Requesters an. Ist das Flag saveasking ausgeschaltet,
  964.     * wird der Wert default automatisch an die aufrufende
  965.     * Prozedur zurückgegeben.
  966.     */
  967. int
  968. Question(struct Window * wind, char *ask, int def)
  969. {
  970.    UBYTE header[MAXSTRLEN];
  971.  
  972.    DPOS;
  973.  
  974.    if(Flags.saveasking)
  975.    {
  976.       sprintf((char *)header, "%s ask you", NAME);
  977.  
  978.       if (Flags.speakmode)
  979.          Speak(ask);
  980.  
  981.       return (MyEasyRequest(wind, header, (UBYTE *) "Yes|No", (UBYTE *) "%s",
  982.                             (UBYTE *) ask));
  983.    }
  984.    else
  985.       return((WORD)def);
  986. }
  987.  
  988.    /*
  989.     * OpenLibs() öffnet alle notwendigen Libraries, installiert
  990.     * den Broker und liest die ActionList ein
  991.     */
  992. void
  993. OpenLibs(void)
  994. {
  995.    DPOS;
  996.  
  997.    IntuitionBase = (struct IntuitionBase *)OpenLibrary((UBYTE *) "intuition.library", 36);
  998.    WorkbenchBase = (struct WorkbenchBase *)OpenLibrary((UBYTE *) "workbench.library", 36);
  999.    GfxBase       = (struct GfxBase *)OpenLibrary((UBYTE *) "graphics.library", 36);
  1000.  
  1001.    GadToolsBase  = OpenLibrary((UBYTE *) "gadtools.library", 36);
  1002.    UtilityBase   = OpenLibrary((UBYTE *) "utility.library", 36);
  1003.    DiskfontBase  = OpenLibrary((UBYTE *) "diskfont.library", 36);
  1004.    CxBase        = OpenLibrary((UBYTE *) "commodities.library", 36);
  1005.    IconBase      = OpenLibrary((UBYTE *) "icon.library", 36);
  1006.  
  1007.    if(!IntuitionBase || !WorkbenchBase || !GfxBase       || !GadToolsBase  ||
  1008.       !UtilityBase   || !DiskfontBase  || !CxBase        || !IconBase)
  1009.       ErrorHandle(LIBRARY_ERR, OPEN_FAIL, KILL);
  1010.  
  1011.    InstallBroker();
  1012.    BuildActionList();
  1013.  
  1014.    return;
  1015. }
  1016.  
  1017.    /*
  1018.     * CloseLibs() schließt alle geöffneten Resourcen
  1019.     */
  1020. void
  1021. CloseLibs(void)
  1022. {
  1023.    DPOS;
  1024.  
  1025.    MyFreeVec(Actions);
  1026.  
  1027.    RemoveBroker();
  1028.  
  1029.    CloseLibrary(IconBase);
  1030.    CloseLibrary(CxBase);
  1031.    CloseLibrary(DiskfontBase);
  1032.    CloseLibrary(UtilityBase);
  1033.    CloseLibrary(GadToolsBase);
  1034.    CloseLibrary((struct Library *) GfxBase);
  1035.    CloseLibrary((struct Library *) WorkbenchBase);
  1036.    CloseLibrary((struct Library *) IntuitionBase);
  1037.  
  1038.    return;
  1039. }
  1040.  
  1041.    /*
  1042.     * CloseAll() schließt alle geöffneten und initialisierten
  1043.     * Intuitionobjekte und beendet das Programm
  1044.     */
  1045. void
  1046. CloseAll(void)
  1047. {
  1048.    DPOS;
  1049.  
  1050.    if (Flags.speakmode)
  1051.       RemoveSpeech();
  1052.  
  1053.    if (appicon)
  1054.       RemoveAppIcon(appicon);
  1055.  
  1056.    MyFreeVec(Entries);
  1057.  
  1058.    KillList();
  1059.  
  1060.    if (SysIdPort)
  1061.       DeletePort(SysIdPort);
  1062.  
  1063.    CloseASysWindow(&SysWnd, &SysGList, &SysMenus);
  1064.  
  1065.    CloseDownScreen();
  1066.  
  1067.    CloseLibs();
  1068.  
  1069.    MyFreeVec(RSysName);
  1070.  
  1071.    RemoveTrapHandlers();
  1072.  
  1073.    exit(0);
  1074. }
  1075.