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