home *** CD-ROM | disk | FTP | other *** search
/ World of A1200 / World_Of_A1200.iso / programs / monitors / rsys / rsyssrc.lha / RSysDisplays.c < prev    next >
C/C++ Source or Header  |  1993-09-19  |  14KB  |  507 lines
  1. /*
  2. ***************************************************************************
  3. *
  4. * Datei:
  5. *      RSysDisplays.c
  6. *
  7. * Inhalt:
  8. *
  9. *      --- Globale Routinen ---
  10. *
  11. *    int DisplayDiskInfo ( char *filename , int with_tree );
  12. *    int DisplayFileInfo ( char *filename );
  13. *    int DisplayFontInfo ( struct objectid *obj );
  14. *    int DisplayLibraryInfo ( struct objectid *obj );
  15. *    int DisplayLockInfo ( struct objectid *obj );
  16. *    int DisplayPortInfo ( struct objectid *obj );
  17. *    int DisplayScreenInfo ( struct objectid *obj );
  18. *    int DisplayTaskInfo ( struct objectid *obj );
  19. *    int DisplayWindowInfo ( struct objectid *obj );
  20. *    void DisplayDirectoryInfo ( char *filename );
  21. *    void DisplayResourceInfo ( struct objectid *obj );
  22. *    void DisplaySoftDevInfo ( struct objectid *obj );
  23. *
  24. *      --- Lokale  Routinen ---
  25. *
  26. *    static char *makelibflags ( struct Library *lib , char *flags );
  27. *    static void savecpyid ( char *IDStr , struct Library *lib );
  28. *
  29. * Bemerkungen:
  30. *      Funktionen zur Anzeige weiterer Informationen zu ausgewählten
  31. *      Objekten.
  32. *
  33. * Erstellungsdatum:
  34. *      07-Jul-93     Rolf Böhme
  35. *
  36. * Änderungen:
  37. *      07-Jul-93     Rolf Böhme      Erstellung
  38. *
  39. ***************************************************************************
  40. */
  41.  
  42. #include "RSys.h"
  43.  
  44.     /*
  45.      * DisplayDiskInfo() zeigt eine Info über ein Volume an.
  46.      * Auf Wunsch kann die Verzeichnisstruktur angezeigt
  47.      * werden
  48.      */
  49. int
  50. DisplayDiskInfo(char *filename, int with_tree)
  51. {
  52.     int    sel;
  53.     long free = 0L,used = 0L,percentused = 0L;
  54.     char state[5],type[6];
  55.  
  56.     DPOS;
  57.  
  58.     FreeBytes(filename, &free, &used, &percentused, state, type);
  59.  
  60.     sel = MyEasyRequest(SysWnd, (UBYTE *) NAME " - Volume/Device Info",
  61.                               (UBYTE *) ((with_tree) ? "Tree|Continue" : "Continue"),
  62.                               (UBYTE *) "Name    : %-20.20s\n"
  63.                               "Size    : %7ld KBytes\n"
  64.                               "Free    : %7ld KBytes\n"
  65.                               "Used    : %7ld KBytes\n"
  66.                               "%% used  : %3ld%%\n"
  67.                               "State   : %s\n"
  68.                               "Type    : %s",
  69.                               filename,
  70.                               free + used,
  71.                               free, used, percentused,
  72.                               state, type);
  73.  
  74.     return sel;
  75. }
  76.  
  77.     /*
  78.      * DisplayFileInfo() zeigt Infos über eine Datei an.
  79.      * Handelt es sich um ein Executable, kann eine Hunk-Liste
  80.      * erzeugt werden lassen
  81.      */
  82. int
  83. DisplayFileInfo(char *filename)
  84. {
  85.     char    path[MAXFULLNAME],
  86.           *help,
  87.             file[MAXFULLNAME];
  88.     int    sel,
  89.             ftype = filetype(filename);
  90.  
  91.     DPOS;
  92.  
  93.     strncpy(path, filename,MAXFULLNAME);
  94.     help = (char *)PathPart((UBYTE *) path);
  95.     *help = STRINGEND;
  96.  
  97.     strncpy(file, (char *)FilePart((UBYTE *) filename),MAXFULLNAME);
  98.  
  99.     sel = MyEasyRequest(NULL, (UBYTE *) NAME " - File Info",
  100.                               (UBYTE *) ((ftype == TYPE_EXECUTABLE) ?
  101.                                              "Hunk list|Continue" : "Continue"),
  102.                               (UBYTE *) "Filename : %-20.20s\n"
  103.                               "Path     : %s\n"
  104.                               "Size     : %ld Bytes\n"
  105.                               "Type     : %s",
  106.                               file, path, SizeOfFile(filename),
  107.                               mess[ftype]);
  108.  
  109.     if (ftype != TYPE_EXECUTABLE)    return TRUE;
  110.  
  111.     return sel;
  112. }
  113.  
  114.     /*
  115.      * DisplayDirectoryInfo() zeigt Infos über ein Verzeichnis
  116.      * an
  117.      */
  118. void
  119. DisplayDirectoryInfo(char *filename)
  120. {
  121.     int    count,
  122.             Dirs = 0;
  123.     long    Size = 0L;
  124.     char    path[MAXFULLNAME],
  125.           *help;
  126.     BPTR    lock;
  127.  
  128.     DPOS;
  129.  
  130.     strncpy(path, filename,MAXFULLNAME);
  131.     help = (char *)PathPart((UBYTE *) path);
  132.     *help = STRINGEND;
  133.  
  134.     if (lock = Lock((UBYTE *) path, MODE_OLDFILE))
  135.     {
  136.         count = SizeOfDir(lock, &Size, &Dirs);
  137.         UnLock(lock);
  138.     }
  139.     else count = Size = Dirs = 0;
  140.  
  141.     MyEasyRequest(NULL, (UBYTE *) NAME " - Directory Info", (UBYTE *) "Continue",
  142.                       (UBYTE *) "Path       : %s\n"
  143.                       "# Files    : %ld\n"
  144.                       "# Sub-Dirs : %ld\n"
  145.                       "Total      : %ld Bytes",
  146.                       path, count, Dirs, Size);
  147.     return;
  148. }
  149.  
  150.     /*
  151.      * DisplayTaskInfo() zeigt Infos über einen Task an. Auf
  152.      * Wunsch kann der Task gekillt, ein Signal gesendet oder
  153.      * die Priorität geändert werden
  154.      */
  155. int
  156. DisplayTaskInfo(struct objectid *obj)
  157. {
  158.     struct Task *task = (struct Task *) obj->address,display_task;
  159.     char *status[]=
  160.     {
  161.         "Invalid", "Adding ", "Running", "Ready ", "Waiting", "Except", "Remove"
  162.     };
  163.     int    sel = 7,
  164.             wins = 0,
  165.             scrs = 0,
  166.             ports = 0;
  167.  
  168.     DPOS;
  169.  
  170.     Disable();
  171.     CopyMem(task,&display_task,sizeof(struct Task));
  172.     Enable();
  173.  
  174.     CountAssocObjects(task, &wins, &scrs, &ports);
  175.  
  176.     sel = MyEasyRequest(SysWnd, (UBYTE *) NAME " " VERSION " - Task Control",
  177.                               (UBYTE *) "Kill!|^C|^D|^E|^F|Prio|Continue",
  178.                               (UBYTE *) "Name : %-20.20s  (%s) Prio: %-4ld\n"
  179.                               "Address   : 0x%08lx  Flags     : 0x%08lx\n"
  180.                               "State     : %8s      IDNest    : %-8ld\n"
  181.                               "TDNest    : %-8ld    SigAlloc  : 0x%08lx\n"
  182.                               "SigWait   : 0x%08lx  SigRecvd  : 0x%08lx\n"
  183.                               "SigExcept : 0x%08lx  Stack     : %-5ld\n\n"
  184.                               "Associated Objects\n"
  185.                               "Ports     : %4ld - Windows : %4ld\n"
  186.                               "Screens   : %4ld",
  187.                               obj->fullname,
  188.                               (display_task.tc_Node.ln_Type == NT_TASK) ? "Task" : "Process",
  189.                               display_task.tc_Node.ln_Pri,
  190.                               task, display_task.tc_Flags, status[display_task.tc_State],
  191.                               display_task.tc_IDNestCnt, display_task.tc_TDNestCnt,
  192.                               display_task.tc_SigAlloc, display_task.tc_SigWait, display_task.tc_SigRecvd,
  193.                               display_task.tc_SigExcept,
  194.                               ((ULONG) display_task.tc_SPUpper - (ULONG) display_task.tc_SPLower),
  195.                               ports, wins, scrs);
  196.  
  197.     return sel;
  198. }
  199.  
  200.     /*
  201.      * savecpyid() kopiert den ID-String einer Library in ein
  202.      * Zeichenfeld. Am Ende des Strings erscheinen häufig zwei
  203.      * Sonderzeichen, die hier entfernt werden
  204.      */
  205. static void
  206. savecpyid(char *IDStr,struct Library *lib)
  207. {
  208.     char *id;
  209.  
  210.     id = (char *)lib->lib_IdString;
  211.  
  212.     if(id && *id)
  213.     {
  214.         strncpy(IDStr,id,40);
  215.  
  216.         if(!isprint((int)IDStr[strlen(IDStr)-1]))    IDStr[strlen(IDStr)-1] = STRINGEND;
  217.         if(!isprint((int)IDStr[strlen(IDStr)-2]))    IDStr[strlen(IDStr)-2] = STRINGEND;
  218.     }
  219.     else strcpy(IDStr, field[NO_LIB_ID]);
  220.  
  221.     return;
  222. }
  223.  
  224.     /*
  225.      * makelibflags() erzeugt entsprechend der Library-Flags
  226.      * einen "lesbaren" String
  227.      */
  228. static char *
  229. makelibflags(struct Library *lib,char *flags)
  230. {
  231.     if(lib->lib_Flags == 0)    strcpy(flags, field[NO_FLAGS]);
  232.     else
  233.         sprintf(flags,"%10s %10s %10s %10s",
  234.                   (lib->lib_Flags & LIBF_SUMMING) ? "CheckSum" : field[BLANK_FIELD],
  235.                   (lib->lib_Flags & LIBF_CHANGED) ? "Changed" : field[BLANK_FIELD],
  236.                   (lib->lib_Flags & LIBF_SUMUSED) ? "ResetByErr" : field[BLANK_FIELD],
  237.                   (lib->lib_Flags & LIBF_DELEXP) ?    "DelExpunge" : field[BLANK_FIELD]);
  238.  
  239.     return flags;
  240. }
  241.  
  242.     /*
  243.      * DisplayLibraryInfo() zeigt alle Infos über eine Library
  244.      * an
  245.      */
  246. int
  247. DisplayLibraryInfo(struct objectid *obj)
  248. {
  249.     int    sel;
  250.     struct Library *lib = (struct Library *) obj->address;
  251.     char IDStr[41];
  252.     char flags[45];
  253.  
  254.     DPOS;
  255.  
  256.     savecpyid(IDStr,lib);
  257.  
  258.     sel = MyEasyRequest(SysWnd, (UBYTE *) NAME " " VERSION " - Library Control",
  259.                               (UBYTE *) "Remove Library|Continue",
  260.                               (UBYTE *) "Type           : Library\n"
  261.                               "Name           : %s\n"
  262.                               "ID-String      : %-30.30s\n"
  263.                               "Address        : 0x%08lx\n"
  264.                               "Flags          : %s\n"
  265.                               "Jump-Table-Size: %4ld Bytes   Data-Size   : %ld Bytes\n"
  266.                               "CheckSum       : 0x%08lx",
  267.                               obj->fullname, IDStr, obj->address,
  268.                               makelibflags(lib,flags),
  269.                               lib->lib_NegSize,
  270.                               lib->lib_PosSize,
  271.                               lib->lib_Sum);
  272.  
  273.     return sel;
  274. }
  275.  
  276.     /*
  277.      * DisplaySoftDevInfo() zeigt alle Infos über ein
  278.      * *.device an
  279.      */
  280. void
  281. DisplaySoftDevInfo(struct objectid *obj)
  282. {
  283.     struct Library *lib = (struct Library *) obj->address;
  284.     char IDStr[40];
  285.     char flags[45];
  286.  
  287.     DPOS;
  288.  
  289.     savecpyid(IDStr,lib);
  290.  
  291.     MyEasyRequest(SysWnd,
  292.                       (UBYTE *) NAME " " VERSION " - Software Device Info",
  293.                       (UBYTE *) "Continue",
  294.                       (UBYTE *) "Type           : Software Device\n"
  295.                       "Name           : %s\n"
  296.                       "ID-String      : %-30.30s\n"
  297.                       "Address        : 0x%08lx\n"
  298.                       "Flags          : %s\n"
  299.                       "Jump-Table-Size: %4ld Bytes   Data-Size   : %ld Bytes\n"
  300.                       "CheckSum       : 0x%08lx",
  301.                       obj->fullname, IDStr, obj->address,
  302.                       makelibflags(lib,flags),
  303.                       lib->lib_NegSize,
  304.                       lib->lib_PosSize,
  305.                       lib->lib_Sum);
  306.  
  307.     return;
  308. }
  309.  
  310.     /*
  311.      * DisplayResourceInfo() zeigt alle Infos über eine .resource
  312.      * an
  313.      */
  314. void
  315. DisplayResourceInfo(struct objectid *obj)
  316. {
  317.     struct Library *lib = (struct Library *) obj->address;
  318.     char flags[45];
  319.  
  320.     DPOS;
  321.  
  322.     MyEasyRequest(SysWnd,
  323.                       (UBYTE *) NAME " " VERSION " - RessourceInfo",
  324.                       (UBYTE *) "Continue",
  325.                       (UBYTE *) "Type           : Ressource\n"
  326.                       "Name           : %s\n"
  327.                       "Address        : 0x%08lx\n"
  328.                       "Flags          : %s\n"
  329.                       "Jump-Table-Size: %4ld Bytes   Data-Size   : %ld Bytes\n"
  330.                       "CheckSum       : 0x%08lx",
  331.                       obj->fullname, obj->address,
  332.                       makelibflags(lib,flags),
  333.                       lib->lib_NegSize,
  334.                       lib->lib_PosSize,
  335.                       lib->lib_Sum);
  336.  
  337.     return;
  338. }
  339.  
  340.     /*
  341.      * DisplayPortInfo() zeigt Infos über einen Port an
  342.      */
  343. int
  344. DisplayPortInfo(struct objectid *obj)
  345. {
  346.     int    sel;
  347.     struct MsgPort *port;
  348.     char    sigtask[MAXFULLNAME];
  349.     struct Task *task;
  350.     char *flags[]=
  351.     {
  352.         "Signal", "SoftInt", "Ignore"
  353.     };
  354.  
  355.     DPOS;
  356.  
  357.     Disable();
  358.     port = (struct MsgPort *) obj->address;
  359.     if (port->mp_SigTask)
  360.     {
  361.         task = (struct Task *) (port->mp_SigTask);
  362.         savestrcpy(sigtask, &task->tc_Node, MAXFULLNAME, NT_TASK);
  363.     }
  364.     else strcpy(sigtask, field[NO_TASK]);
  365.  
  366.     Enable();
  367.  
  368.     sel = MyEasyRequest(SysWnd, (UBYTE *) NAME " " VERSION " - Port Control",
  369.                               (UBYTE *) "Remove Port|Continue",
  370.                               (UBYTE *) "Type        : %s\n"
  371.                               "Address     : 0x%08lx\n"
  372.                               "Name        : %-20.20s\n"
  373.                               "Signal-Task : %-20.20s\n"
  374.                               "Flags       : %s",
  375.                               "Port", obj->address, obj->fullname, sigtask,
  376.                               flags[port->mp_Flags]);
  377.  
  378.     return sel;
  379. }
  380.  
  381.     /*
  382.      * DisplayFontInfo() zeigt alle Infos über einen Font an.
  383.      * Dieser kann dann wahlweise entfernt oder angezeigt
  384.      * werden
  385.      */
  386. int
  387. DisplayFontInfo(struct objectid *obj)
  388. {
  389.     int    sel;
  390.  
  391.     DPOS;
  392.  
  393.     sel = MyEasyRequest(SysWnd, (UBYTE *) NAME " " VERSION " - Font Control",
  394.                               (UBYTE *) "Remove Font|Show Font|Continue",
  395.                               (UBYTE *) "Type    : %s\n"
  396.                               "Address : 0x%08lx\n"
  397.                               "Name    : %s",
  398.                               "Font", obj->address, obj->fullname);
  399.  
  400.     return sel;
  401. }
  402.  
  403.     /*
  404.      * DisplayWindowInfo() zeigt Infos über ein Fenster an
  405.      */
  406. int
  407. DisplayWindowInfo(struct objectid *obj)
  408. {
  409.     int    sel;
  410.     struct Window disp_win;
  411.     ULONG lock;
  412.  
  413.     DPOS;
  414.  
  415.     lock = LockIBase(NULL);
  416.     CopyMem((struct Window *)(obj->address),&disp_win,sizeof(struct Window));
  417.     UnlockIBase(lock);
  418.  
  419.     sel = MyEasyRequest(SysWnd, (UBYTE *) NAME " " VERSION " - Window Control",
  420.                               (UBYTE *) "Close Window|Continue",
  421.                               (UBYTE *)
  422.                               "Type     : Window   Address : 0x%08lx\n"
  423.                               "Name     : %-30.30s\n"
  424.                               "Next     : 0x%08lx\n"
  425.                               "LeftEdge : %-4ld        TopEdge  : %-4ld\n"
  426.                               "Width    : %-4ld        Height   : %-4ld\n"
  427.                               "MinWidth : %-4ld        MinHeight: %-4ld\n"
  428.                               "MaxWidth : %-4ld        MaxHeight: %-4ld\n"
  429.                               "Flags    : 0x%08lx  Menu: %s\n"
  430.                               "Requester: %s       ReqCount: %ld  DMReq: %s\n"
  431.                               "IDCMP    : 0x%08lx  Detail: %-2ld   Block: %2ld",
  432.                               obj->address, obj->fullname,
  433.                               disp_win.NextWindow,
  434.                               disp_win.LeftEdge,disp_win.TopEdge,
  435.                               disp_win.Width,disp_win.Height,
  436.                               disp_win.MinWidth,disp_win.MinHeight,
  437.                               disp_win.MaxWidth,disp_win.MaxHeight,
  438.                               disp_win.Flags,(disp_win.MenuStrip ? "Yes" : "No"),
  439.                               (disp_win.FirstRequest ? "Yes" : "No"),disp_win.ReqCount,
  440.                               (disp_win.DMRequest ? "Yes" : "No"),disp_win.IDCMPFlags,
  441.                               disp_win.DetailPen,disp_win.BlockPen );
  442.  
  443.     return sel;
  444. }
  445.  
  446.     /*
  447.      * DisplayScreenInfo() zeigt Infos über ein Screen an
  448.      */
  449. int
  450. DisplayScreenInfo(struct objectid *obj)
  451. {
  452.     int    sel;
  453.     struct Screen disp_scr;
  454.     ULONG lock;
  455.  
  456.     DPOS;
  457.  
  458.     lock = LockIBase(NULL);
  459.     CopyMem((struct Screen *)(obj->address),&disp_scr,sizeof(struct Screen));
  460.     UnlockIBase(lock);
  461.  
  462.     sel = MyEasyRequest(SysWnd, (UBYTE *) NAME " " VERSION " - Screen Control",
  463.                               (UBYTE *) "Close Screen|Continue",
  464.                               (UBYTE *) "Type     : Screen   Address : 0x%08lx\n"
  465.                               "Name     : %.20s\n"
  466.                               "Next     : 0x%08lx\n"
  467.                               "LeftEdge : %-4ld  TopEdge  : %-4ld\n"
  468.                               "Width    : %-4ld  Height   : %-4ld\n"
  469.                               "BarHeight: %-4ld  BarVBord : %-4ld\n"
  470.                               "BarHBord : %-4ld  MenuVBord: %-4ld\n"
  471.                               "MenuHBord: %-4ld  WBorTop  : %-4ld\n"
  472.                               "WBorLeft : %-4ld  WBorRight: %-4ld\n"
  473.                               "WBorBott : %-4ld  DetailPen: %-4ld\n"
  474.                               "BlockPen : %-4ld  FlashCol : %-4ld\n"
  475.                               "Flags    : 0x%08lx",
  476.                               obj->address, obj->fullname,
  477.                               disp_scr.NextScreen,
  478.                               disp_scr.LeftEdge,disp_scr.TopEdge,
  479.                               disp_scr.Width,disp_scr.Height,
  480.                               disp_scr.BarHeight,disp_scr.BarVBorder,
  481.                               disp_scr.BarHBorder,disp_scr.MenuVBorder,
  482.                               disp_scr.MenuHBorder,disp_scr.WBorTop,
  483.                               disp_scr.WBorLeft,disp_scr.WBorRight,
  484.                               disp_scr.WBorBottom,disp_scr.DetailPen,
  485.                               disp_scr.BlockPen,disp_scr.SaveColor0,
  486.                               disp_scr.Flags);
  487.  
  488.     return sel;
  489. }
  490.  
  491. int
  492. DisplayLockInfo(struct objectid *obj)
  493. {
  494.    int sel;
  495.     int ftype = filetype(obj->fullname);
  496.  
  497.     sel = MyEasyRequest(SysWnd, (UBYTE *) NAME " " VERSION " - FileLock Control",
  498.                               (UBYTE *) (ftype ? "Unlock|Continue" : "Continue"),
  499.                               (UBYTE *) "Type      : Lock\n"
  500.                                  "File      : %s\n"
  501.                                  "Address   : 0x%08lx\n"
  502.                                  "File type : %s",
  503.                        obj->fullname, obj->address, mess[ftype]);
  504.  
  505.    return (ftype ? sel : 0);
  506. }
  507.