home *** CD-ROM | disk | FTP | other *** search
/ World of A1200 / World_Of_A1200.iso / programs / monitors / rsys / rsyssrc.lha / RSysModify.c < prev    next >
C/C++ Source or Header  |  1993-09-19  |  24KB  |  1,080 lines
  1. /*
  2. ***************************************************************************
  3. *
  4. * Datei:
  5. *      RSysModify.c
  6. *
  7. * Inhalt:
  8. *
  9. *      --- Globale Routinen ---
  10. *
  11. *    int CheckWindow ( struct Window *findwin );
  12. *    void CountAssocObjects ( struct Task *task , int *wins , int *scrs , int *ports );
  13. *    void ModifyObject ( int TypeID , ULONG code );
  14. *
  15. *      --- Lokale  Routinen ---
  16. *
  17. *    static BOOL CheckObject ( struct List *list , struct objectid *obj );
  18. *    static BOOL CheckTask ( struct objectid *obj );
  19. *    static int CheckScreen ( struct Screen *findscr );
  20. *    static int OpenChgPriWindow ( void );
  21. *    static struct MsgPort *TaskPort ( struct Task *task );
  22. *    static struct Window *TaskWindow ( struct Task *task );
  23. *    static void ChangePri ( struct objectid *obj );
  24. *    static void ClosingScreens ( struct Screen *scr );
  25. *    static void ClosingWindows ( struct Window *wind );
  26. *    static void DisplayAllFonts ( int TypeID , struct Node *ClickedNode );
  27. *    static void DisplayResource ( int TypeID , struct objectid *obj );
  28. *    static void DisplaySoftDevice ( int TypeID , struct objectid *obj );
  29. *    static void DisplayTreeDevice ( int TypeID , struct objectid *obj );
  30. *    static void FlushLibrary ( struct objectid *obj );
  31. *    static void KillTask ( struct objectid *obj );
  32. *    static void ModifyFont ( int TypeID , struct objectid *obj );
  33. *    static void ModifyLibrary ( int TypeID , struct objectid *obj );
  34. *    static void ModifyPort ( int TypeID , struct objectid *obj );
  35. *    static void ModifyScreen ( int TypeID , struct objectid *obj );
  36. *    static void ModifyTask ( int TypeID , struct objectid *obj );
  37. *    static void ModifyVolumeLock ( int TypeID , struct objectid *obj );
  38. *    static void ModifyWindow ( int TypeID , struct objectid *obj );
  39. *    static void RemoveFontSafely ( struct TextFont *tf );
  40. *    static void RemovePortSafely ( struct MsgPort *p , struct objectid *obj );
  41. *    static void SignalTask ( struct objectid *obj , ULONG signal );
  42. *
  43. * Bemerkungen:
  44. *      Enthält die Routinen zum Modifizieren von Objekten.
  45. *
  46. * Erstellungsdatum:
  47. *      07-Jan-93     Rolf Böhme
  48. *
  49. * Änderungen:
  50. *      07-Jan-93     Rolf Böhme      Erstellung
  51. *
  52. ***************************************************************************
  53. */
  54.  
  55. #include "RSys.h"
  56.  
  57. static void KillTask(struct objectid *);
  58. static int modified = FALSE;
  59.  
  60.     /*
  61.      * CheckObject() prüft, ob ein ausgewähltes Listenelement (Objekt)
  62.      * sich noch in der Liste befindet
  63.      */
  64. static BOOL
  65. CheckObject(struct List *list, struct objectid *obj)
  66. {
  67.     struct Node *node;
  68.  
  69.     Forbid();
  70.  
  71.     for (node = list->lh_Head; node->ln_Succ && (node != obj->address); node = node->ln_Succ) ;
  72.  
  73.     Permit();
  74.  
  75.     return ((node == obj->address) ? TRUE : FALSE);
  76. }
  77.  
  78.     /*
  79.      * CheckTask() prüft, ob ein Task-Objekt sich noch in den Listen
  80.      * befindet, also noch existiert
  81.      */
  82. static BOOL
  83. CheckTask(struct objectid *obj)
  84. {
  85.     if(CheckObject(&(SysBase->TaskWait),obj) || CheckObject(&(SysBase->TaskReady),obj) ||
  86.         ((struct Task *)obj->address == FindTask(NULL)))
  87.         return(TRUE);
  88.     else return(FALSE);
  89. }
  90.  
  91.     /*
  92.      * CountAssocObjects() zählt die zu einem Task gehörenden
  93.      * Windows, Screens und Ports
  94.      */
  95. void
  96. CountAssocObjects(struct Task *task, int *wins, int *scrs, int *ports)
  97. {
  98.     ULONG lock;
  99.     struct Window *win;
  100.     struct Screen *scr;
  101.     struct MsgPort *port;
  102.     struct Node *node;
  103.  
  104.     DPOS;
  105.  
  106.     Forbid();
  107.  
  108.     lock = LockIBase(NULL);
  109.  
  110.     for (scr = IntuitionBase->FirstScreen; scr; scr = scr->NextScreen)
  111.         for (win = scr->FirstWindow; win; win = win->NextWindow)
  112.         {
  113.             if (win->UserPort && win->UserPort->mp_SigTask &&
  114.                  (win->UserPort->mp_SigTask == task))
  115.             {
  116.                 (*wins)++;
  117.  
  118.                 if ((scr->Flags & CUSTOMSCREEN) && NOT(scr->Flags & PUBLICSCREEN))
  119.                     (*scrs)++;
  120.             }
  121.         }
  122.  
  123.     UnlockIBase(lock);
  124.  
  125.     for (node = SysBase->PortList.lh_Head; node->ln_Succ; node = node->ln_Succ)
  126.     {
  127.         port = (struct MsgPort *) node;
  128.  
  129.         if (port->mp_SigTask && (port->mp_SigTask == task))
  130.             (*ports)++;
  131.     }
  132.  
  133.     Permit();
  134.  
  135.     return;
  136. }
  137.  
  138.     /*
  139.      * CheckWindow() prüft, ob ein Fenster noch existiert, und zwar
  140.      * auf allen Screens
  141.      */
  142. int
  143. CheckWindow(struct Window *findwin)
  144. {
  145.     ULONG lock;
  146.     struct Window *win;
  147.     struct Screen *scr;
  148.     int    ret = FALSE;
  149.  
  150.     DPOS;
  151.  
  152.     lock = LockIBase(NULL);
  153.  
  154.     for (scr = IntuitionBase->FirstScreen; scr && NOT(ret); scr = scr->NextScreen)
  155.         for (win = scr->FirstWindow; win && NOT(ret); win = win->NextWindow)
  156.             if (win == findwin) ret = TRUE;
  157.  
  158.     UnlockIBase(lock);
  159.  
  160.     return ret;
  161. }
  162.  
  163.     /*
  164.      * CheckScreen() prüft, ob ein Screen noch existiert
  165.      */
  166. static int
  167. CheckScreen(struct Screen *findscr)
  168. {
  169.     ULONG lock;
  170.     struct Screen *scr;
  171.     int    ret = FALSE;
  172.  
  173.     lock = LockIBase(NULL);
  174.  
  175.     for (scr = IntuitionBase->FirstScreen; scr && NOT(ret); scr = scr->NextScreen)
  176.         if (scr == findscr) ret = TRUE;
  177.  
  178.     UnlockIBase(lock);
  179.  
  180.     return ret;
  181. }
  182.  
  183.     /*
  184.      * TaskPort() sucht in der Liste der öffentlichen Ports
  185.      * nach dem ersten Port, der den Task task als Signaltask
  186.      * hat
  187.      */
  188. static struct MsgPort *
  189. TaskPort(struct Task *task)
  190. {
  191.     struct MsgPort *taskport = NULL,
  192.           *port;
  193.     struct Node *node;
  194.  
  195.     Forbid();
  196.  
  197.     for (node = SysBase->PortList.lh_Head; node->ln_Succ; node = node->ln_Succ)
  198.     {
  199.         port = (struct MsgPort *) node;
  200.  
  201.         if (port->mp_SigTask && (port->mp_SigTask == task))
  202.         {
  203.             taskport = port;
  204.             break;
  205.         }
  206.     }
  207.  
  208.     Permit();
  209.  
  210.     return taskport;
  211. }
  212.  
  213.     /*
  214.      * TaskWindow() sucht in der IntuitionBase nach dem ersten Fenster,
  215.      * dessen UserPort zu dem Task task gehört
  216.      */
  217. static struct Window *
  218. TaskWindow(struct Task *task)
  219. {
  220.     ULONG lock;
  221.     struct Window *win,
  222.           *taskwindow = NULL;
  223.     struct Screen *scr;
  224.  
  225.     lock = LockIBase(NULL);
  226.  
  227.     for (scr = IntuitionBase->FirstScreen; scr && NOT(taskwindow); scr = scr->NextScreen)
  228.         for (win = scr->FirstWindow; win && NOT(taskwindow); win = win->NextWindow)
  229.             if (win->UserPort && (win->UserPort->mp_SigTask) && (win->UserPort->mp_SigTask == task))
  230.                 taskwindow = win;
  231.  
  232.     UnlockIBase(lock);
  233.  
  234.     return taskwindow;
  235. }
  236.  
  237.     /*
  238.      * ClosingWindows() schließt ein Fenster auf sicherste
  239.      * Weise, wie ich hoffe...
  240.      */
  241. static void
  242. ClosingWindows(struct Window *wind)
  243. {
  244.     if (CheckWindow(wind))
  245.     {
  246.         if((wind->ReqCount != 0) && wind->FirstRequest)
  247.             while(wind->ReqCount != 0) EndRequest(wind->FirstRequest,wind);
  248.  
  249.         if(wind->DMRequest)  ClearDMRequest(wind);
  250.         if(wind->Pointer)    ClearPointer(wind);
  251.         if(wind->MenuStrip)  ClearMenuStrip(wind);
  252.  
  253.         CloseWindow(wind);
  254.     }
  255.     else ErrorHandle("CheckWindow()", WINDOW_ERR, FIND_FAIL, NO_KILL);
  256.  
  257.     return;
  258. }
  259.  
  260.     /*
  261.      * ClosingScreens() schließt einen Screen auf sicherste
  262.      * Weise, wie ich hoffe...
  263.      */
  264. static void
  265. ClosingScreens(struct Screen *scr)
  266. {
  267.     struct Window *win = scr->FirstWindow,
  268.           *markwin;
  269.  
  270.     if (CheckScreen(scr))
  271.     {
  272.         while (win)
  273.         {
  274.             markwin = win->NextWindow;
  275.             ClosingWindows(win);
  276.             win = markwin;
  277.         }
  278.  
  279.         CloseScreen(scr);
  280.  
  281.         if (CheckScreen(scr)) PrintInfo("Screen not killed!", SPEAK, SEC);
  282.     }
  283.     else ErrorHandle("CheckScreen", SCREEN_ERR, FIND_FAIL, NO_KILL);
  284.  
  285.     return;
  286. }
  287.  
  288.     /*
  289.      * RemovePortSavely() entfernt eine Port auf sicherste Weise
  290.      */
  291. static void
  292. RemovePortSafely(struct MsgPort *p, struct objectid *obj)
  293. {
  294.     struct Node *MsgNode;
  295.     struct MsgPort *port;
  296.  
  297.     port = (obj ? (struct MsgPort *) obj->address : p);
  298.  
  299.     Forbid();
  300.  
  301.     if (NOT(IsMsgPortEmpty(port)))
  302.     {
  303.         MsgNode = port->mp_MsgList.lh_Head;
  304.  
  305.         while (MsgNode = MsgNode->ln_Succ)
  306.             Remove((struct Node *) MsgNode);
  307.     }
  308.  
  309.     DeletePort(port);
  310.  
  311.     if (CheckObject(&SysBase->PortList, obj))
  312.         RemPort(port);
  313.  
  314.     Permit();
  315.  
  316.     return;
  317. }
  318.  
  319. static void
  320. RemoveFontSafely(struct TextFont *tf)
  321. {
  322.     if (tf->tf_Flags & FPF_DISKFONT)
  323.     {
  324.         Forbid();
  325.         CloseFont(tf);
  326.         Remove((struct Node *) tf);
  327.         Permit();
  328.     }
  329.     else if (Question(SysWnd,"You attempt to remove a ROM-Font!\n"
  330.                                      "Remove this Font anyway?", YES))
  331.     {
  332.         Forbid();
  333.         RemFont(tf);
  334.         Remove((struct Node *) tf);
  335.         Permit();
  336.     }
  337.  
  338.     return;
  339. }
  340.  
  341.     /*
  342.      * KillTask() entfernt einen Task aund alle mit ihm verbundenen
  343.      * Windows, Screens und Ports. Alle anderen Resourcen können
  344.      * nicht mehr eindeutig zugeordnet werden
  345.      */
  346. static void
  347. KillTask(struct objectid *obj)
  348. {
  349.     struct Task *task = (struct Task *) obj->address;
  350.     struct Window *taskwin;
  351.     struct MsgPort *port;
  352.  
  353.     if (Question(SysWnd, "Break signal failed!\n"
  354.                                 "Do you really want to kill the task harder?", YES))
  355.         if (CheckTask(obj))
  356.         {
  357.             Forbid();
  358.  
  359.             Disable();
  360.             Remove((struct Node *)task);
  361.             Enable();
  362.  
  363.             if (taskwin = TaskWindow(task))
  364.             {
  365.                 struct Screen *taskscr = NULL;
  366.                 ULONG lock = LockIBase(NULL);
  367.  
  368.                 if (taskwin->WScreen && (taskwin->WScreen->Flags & CUSTOMSCREEN))
  369.                     taskscr = taskwin->WScreen;
  370.  
  371.                 while (taskwin)
  372.                 {
  373.                     ClosingWindows(taskwin);
  374.                     taskwin = TaskWindow(task);
  375.                 }
  376.  
  377.                 if (taskscr) CloseScreen(taskscr);
  378.  
  379.                 UnlockIBase(lock);
  380.             }
  381.  
  382.             while(port = TaskPort(obj->address)) RemovePortSafely(port, NULL);
  383.  
  384.             Disable();
  385.             RemTask(task);
  386.             Enable();
  387.  
  388.             Permit();
  389.         }
  390.         else ErrorHandle("CheckTask()", TASK_ERR, FIND_FAIL, NO_KILL);
  391.  
  392.     return;
  393. }
  394.  
  395.     /*
  396.      * SignalTask() sendet eine Signal signal an den Task obj
  397.      */
  398. static void
  399. SignalTask(struct objectid *obj, ULONG signal)
  400. {
  401.     struct Task *task;
  402.  
  403.     if (task = FindTask((UBYTE *) obj->fullname)) Signal(task, signal);
  404.     else
  405.         ErrorHandle(obj->fullname, TASK_ERR, FIND_FAIL, NO_KILL);
  406.  
  407.     return;
  408. }
  409.  
  410. static struct Window *ChgPriWnd = NULL;
  411. static struct Gadget *ChgPriGList = NULL;
  412. static struct Gadget *ChgPriGadgets[5];
  413. static UWORD ChgPriLeft = 195;
  414. static UWORD ChgPriTop = 71;
  415. static UWORD ChgPriWidth = 228;
  416. static UWORD ChgPriHeight = 55;
  417. static UBYTE *ChgPriWdt = (UBYTE *) NAME " " VERSION " - Change priority";
  418.  
  419. static UWORD ChgPriGTypes[]=
  420. {
  421.     TEXT_KIND,
  422.     SLIDER_KIND,
  423.     BUTTON_KIND,
  424.     BUTTON_KIND,
  425.     INTEGER_KIND
  426. };
  427.  
  428. static struct NewGadget ChgPriNGad[]=
  429. {
  430.     52, 5, 169, 13, (UBYTE *) "Task", NULL, GD_TaskGad, PLACETEXT_LEFT, NULL, NULL,
  431.     52, 21, 129, 13, (UBYTE *) "Prio", NULL, GD_PrioGad, NG_HIGHLABEL, NULL, NULL,
  432.     8, 37, 69, 13, (UBYTE *) "Ok", NULL, GD_OkGad, PLACETEXT_IN, NULL, NULL,
  433.     156, 37, 65, 13, (UBYTE *) "Cancel", NULL, GD_CancelPriGad, PLACETEXT_IN, NULL, NULL,
  434.     88, 37, 57, 13, NULL, NULL, GD_PriIntGad, 0, NULL, NULL
  435. };
  436.  
  437. static ULONG *ChgPriGTags[]=
  438. {
  439.     (ULONG *) (GTTX_Text), (ULONG *) NULL,
  440.     (ULONG *) (GTTX_Border), (ULONG *) TRUE,
  441.     (ULONG *) (TAG_DONE),
  442.  
  443.     (ULONG *) (GTSL_Min), (ULONG *) (-128),
  444.     (ULONG *) (GTSL_Max), (ULONG *) 128,
  445.     (ULONG *) (GTSL_MaxLevelLen), (ULONG *) 4,
  446.     (ULONG *) (GTSL_LevelFormat), (ULONG *) "%4ld",
  447.     (ULONG *) (GTSL_LevelPlace), (ULONG *) (PLACETEXT_RIGHT),
  448.     (ULONG *) (PGA_Freedom), (ULONG *) LORIENT_HORIZ,
  449.     (ULONG *) (GA_Immediate), (ULONG *) TRUE,
  450.     (ULONG *) (GA_RelVerify), (ULONG *) TRUE,
  451.     (ULONG *) (TAG_DONE),
  452.  
  453.     (ULONG *) (TAG_DONE),
  454.  
  455.     (ULONG *) (TAG_DONE),
  456.  
  457.     (ULONG *) (GTIN_Number), (ULONG *) 0,
  458.     (ULONG *) (GTIN_MaxChars), (ULONG *) 5,
  459.     (ULONG *) (TAG_DONE)
  460. };
  461.  
  462.     /*
  463.      * OpenChgPriWindow() öffnet ein kleines Fenster, in
  464.      * dem man mit einem Slider die Priorität eines Tasks einstellen
  465.      * kann
  466.      */
  467. static int
  468. OpenChgPriWindow(void)
  469. {
  470.     struct NewGadget ng;
  471.     struct Gadget *g;
  472.     UWORD lc,
  473.             tc;
  474.     UWORD wleft = ChgPriLeft,
  475.             wtop = ChgPriTop,
  476.             ww,
  477.             wh;
  478.     int gl[] = {GD_TaskGad - GD_TaskGad,
  479.                GD_PriIntGad - GD_TaskGad,
  480.                GD_PrioGad - GD_TaskGad};
  481.  
  482.    AdjustWindowDimensions(Scr, ChgPriLeft, ChgPriTop, ChgPriWidth, ChgPriHeight,
  483.                                &wleft, &wtop, &ww, &wh);
  484.  
  485.     if (!(g = CreateContext(&ChgPriGList))) return 1L;
  486.  
  487.     for (lc = 0, tc = 0; lc < ChgPri_CNT; lc++)
  488.     {
  489.         CopyMem((char *)&ChgPriNGad[lc], (char *)&ng, (long)sizeof(struct NewGadget));
  490.  
  491.         ng.ng_VisualInfo = VisualInfo;
  492.         ng.ng_TextAttr = Font;
  493.         ng.ng_LeftEdge = OffX + ComputeX(ng.ng_LeftEdge);
  494.         ng.ng_TopEdge = OffY + ComputeY(ng.ng_TopEdge);
  495.         ng.ng_Width = ComputeX(ng.ng_Width);
  496.         ng.ng_Height = ComputeY(ng.ng_Height);
  497.  
  498.         ChgPriGadgets[lc] = g = CreateGadgetA((ULONG) ChgPriGTypes[lc], g, &ng, (struct TagItem *) & ChgPriGTags[tc]);
  499.  
  500.         makelabelvisible(ChgPriGadgets[lc]);
  501.  
  502.         while (ChgPriGTags[tc]) tc += 2;
  503.  
  504.         tc++;
  505.  
  506.         if (NOT g) return 2L;
  507.     }
  508.  
  509.     if (!(ChgPriWnd = OpenWindowTags(NULL,
  510.                                                 WA_Left, wleft,
  511.                                                 WA_Top, wtop,
  512.                                                 WA_Width, ww,
  513.                                                 WA_Height, wh,
  514.                                                 WA_IDCMP, TEXTIDCMP |
  515.                                                 SLIDERIDCMP |
  516.                                                 BUTTONIDCMP |
  517.                                                 INTEGERIDCMP |
  518.                                                 IDCMP_CLOSEWINDOW |
  519.                                                 IDCMP_REFRESHWINDOW,
  520.                                                 WA_Flags, WFLG_DRAGBAR |
  521.                                                 WFLG_DEPTHGADGET |
  522.                                                 WFLG_CLOSEGADGET |
  523.                                                 WFLG_SMART_REFRESH |
  524.                                                 WFLG_ACTIVATE |
  525.                                                 WFLG_RMBTRAP,
  526.                                                 WA_Title, ChgPriWdt,
  527.                                                 WA_PubScreenFallBack,TRUE,
  528.                                                 WA_PubScreen, Scr,
  529.                                                 TAG_DONE)))
  530.         return 4L;
  531.  
  532.     RefreshRastPort(ChgPriWnd,ChgPriGadgets,gl, 3, FALSE, ChgPriGList);
  533.  
  534.     return (0L);
  535. }
  536.  
  537.     /*
  538.      * ChangePri() öffnet ein Fenster und managed das
  539.      * Priority-Handling für ein gewähltes Objekt obj
  540.      */
  541. static void
  542. ChangePri(struct objectid *obj)
  543. {
  544.     struct Task *task = (struct Task *) obj->address;
  545.     int    TaskPri = task->tc_Node.ln_Pri,
  546.             OldPri = TaskPri;
  547.     register struct IntuiMessage *message;
  548.     ULONG class,
  549.             code;
  550.     APTR    object;
  551.     extern struct Window *ChgPriWnd;
  552.     extern struct Gadget *ChgPriGadgets[];
  553.  
  554.     Flags.quit_cp = 0;
  555.  
  556.     if (OpenASysWindow(OpenChgPriWindow,NO_KILL))
  557.     {
  558.       LockMainWindow(LOCK);
  559.  
  560.         GT_SetGadgetAttrs(ChgPriGadgets[GD_TaskGad - GD_TaskGad], ChgPriWnd, NULL,
  561.                                 GTTX_Text, (UBYTE *) obj->fullname,
  562.                                 TAG_DONE);
  563.  
  564.         GT_SetGadgetAttrs(ChgPriGadgets[GD_PrioGad - GD_TaskGad], ChgPriWnd, NULL,
  565.                                 GTSL_Level, (UBYTE *) TaskPri,
  566.                                 TAG_DONE);
  567.  
  568.         GT_SetGadgetAttrs(ChgPriGadgets[GD_PriIntGad - GD_TaskGad], ChgPriWnd, NULL,
  569.                                 GTIN_Number, (UBYTE *) TaskPri,
  570.                                 TAG_DONE);
  571.  
  572.         do
  573.         {
  574.             Wait(1L << ChgPriWnd->UserPort->mp_SigBit);
  575.  
  576.             while ((message = (struct IntuiMessage *)
  577.                       GT_GetIMsg(ChgPriWnd->UserPort)) != NULL)
  578.             {
  579.                 object = message->IAddress;
  580.                 class = message->Class;
  581.                 code = message->Code;
  582.  
  583.                 GT_ReplyIMsg(message);
  584.  
  585.                 switch (class)
  586.                 {
  587.                     case IDCMP_GADGETUP:
  588.                         switch (((struct Gadget *) object)->GadgetID)
  589.                         {
  590.                             case GD_PrioGad:
  591.                                 TaskPri = (int)((char)code);
  592.                                 GT_SetGadgetAttrs(ChgPriGadgets[GD_PriIntGad - GD_TaskGad], ChgPriWnd,
  593.                                                         NULL,
  594.                                                         GTIN_Number, (int)TaskPri,
  595.                                                         TAG_DONE);
  596.  
  597.                                 break;
  598.  
  599.                             case GD_OkGad:
  600.                                 Flags.quit_cp = 1;
  601.                                 break;
  602.  
  603.                             case GD_CancelPriGad:
  604.                                 TaskPri = OldPri;
  605.                                 Flags.quit_cp = 1;
  606.                                 break;
  607.  
  608.                             case GD_PriIntGad:
  609.                                 TaskPri = (int)((struct StringInfo *)
  610.                                                      (((struct Gadget *)
  611.                                                         object)->SpecialInfo))->LongInt;
  612.                                 if ((TaskPri < -128) || (TaskPri > 127))
  613.                                     GT_SetGadgetAttrs(ChgPriGadgets[GD_PriIntGad - GD_TaskGad],
  614.                                                             ChgPriWnd,
  615.                                                             NULL,
  616.                                                             GTIN_Number, OldPri,
  617.                                                             TAG_DONE);
  618.                                 else
  619.                                     GT_SetGadgetAttrs(ChgPriGadgets[GD_PrioGad - GD_TaskGad], ChgPriWnd,
  620.                                                             NULL,
  621.                                                             GTSL_Level, TaskPri,
  622.                                                             TAG_DONE);
  623.                                 break;
  624.                         }
  625.  
  626.                         break;
  627.  
  628.                     case IDCMP_CLOSEWINDOW:
  629.                         TaskPri = OldPri;
  630.                         Flags.quit_cp = 1;
  631.                         break;
  632.                 }
  633.             }
  634.         }
  635.         while (NOT(Flags.quit_cp));
  636.  
  637.         CloseASysWindow(&ChgPriWnd, &ChgPriGList, NULL);
  638.  
  639.         if (CheckTask(obj) && (TaskPri != OldPri)) SetTaskPri(task, TaskPri);
  640.       
  641.       LockMainWindow(UNLOCK);
  642.     }
  643.  
  644.     return;
  645. }
  646.  
  647.     /*
  648.      * FlushLibrary() entfernt eine geschlossene Library aus
  649.      * dem System
  650.      */
  651. static void
  652. FlushLibrary(struct objectid *obj)
  653. {
  654.     struct Library *result;
  655.  
  656.     if (Question(SysWnd, "Do you really want to remove the Library?", YES))
  657.     {
  658.         Forbid();
  659.  
  660.       result = (struct Library *)FindName(&SysBase->LibList, (UBYTE *)obj->fullname);
  661.  
  662.         if (result && (result->lib_OpenCnt == 0)) RemLibrary(result);
  663.  
  664.         Permit();
  665.  
  666.         if (!result) ErrorHandle(obj->fullname, LIBRARY_ERR, FIND_FAIL, NO_KILL);
  667.     }
  668.  
  669.     return;
  670. }
  671.  
  672. static void
  673. ModifyTask(int TypeID, struct objectid *obj)
  674. {
  675.     WORD    sel;
  676.     ULONG signals[5] =
  677.     {
  678.         SIGBREAKF_CTRL_C, SIGBREAKF_CTRL_D, SIGBREAKF_CTRL_E, SIGBREAKF_CTRL_F,
  679.         (SIGBREAKF_CTRL_C | SIGBREAKF_CTRL_D | SIGBREAKF_CTRL_E | SIGBREAKF_CTRL_F)
  680.     };
  681.  
  682.     if (CheckTask(obj))
  683.     {
  684.         sel = DisplayTaskInfo(obj);
  685.  
  686.         switch (sel)
  687.         {
  688.             case 1:
  689.                 if (obj->address != FindTask(NULL))
  690.                 {
  691.                     SignalTask(obj, signals[4]);
  692.  
  693.                     Delay(SEC);
  694.  
  695.                     if (CheckTask(obj)) KillTask(obj);
  696.                     else
  697.                         PrintInfo("Break signal killed the task!", SPEAK, 2*SEC);
  698.  
  699.                modified = TRUE;
  700.                 }
  701.                 else ErrorHandle(obj->fullname, OWN_OBJECT_ERR, KILL_FAIL, NO_KILL);
  702.  
  703.                 break;
  704.  
  705.             case 0:
  706.                 break;
  707.  
  708.             case 2:
  709.             case 3:
  710.             case 4:
  711.             case 5:
  712.                 SignalTask(obj, signals[sel - 2]);
  713.  
  714.             modified = TRUE;
  715.                 break;
  716.  
  717.             case 6:
  718.                 if (CheckTask(obj)) ChangePri(obj);
  719.                 else
  720.                ErrorHandle(obj->fullname, TASK_ERR, FIND_FAIL, NO_KILL);
  721.  
  722.             modified = TRUE;
  723.                 break;
  724.  
  725.             case 7:
  726.             modified = TRUE;
  727.                 break;
  728.         }
  729.  
  730.       return;
  731.     }
  732.     else ErrorHandle(obj->fullname, TASK_ERR, FIND_FAIL, NO_KILL);
  733.  
  734.    modified = TRUE;
  735.  
  736.     return;
  737. }
  738.  
  739. static void
  740. ModifyLibrary(int TypeID, struct objectid *obj)
  741. {
  742.     if (CheckObject(&SysBase->LibList, obj))
  743.    {
  744.         if(DisplayLibraryInfo(obj)) FlushLibrary(obj);
  745.     }
  746.     else ErrorHandle(obj->fullname, LIBRARY_ERR, FIND_FAIL, NO_KILL);
  747.  
  748.    modified = TRUE;
  749.  
  750.     return;
  751. }
  752.  
  753. static void
  754. DisplaySoftDevice(int TypeID, struct objectid *obj)
  755. {
  756.     if (CheckObject(&SysBase->DeviceList, obj)) DisplaySoftDevInfo(obj);
  757.     else
  758.     {
  759.         ErrorHandle("Soft Device", DEVICE_ERR, FIND_FAIL, NO_KILL);
  760.       modified = TRUE;
  761.     }
  762.  
  763.     return;
  764. }
  765.  
  766. static void
  767. DisplayResource(int TypeID, struct objectid *obj)
  768. {
  769.     if (CheckObject(&SysBase->ResourceList, obj))
  770.         DisplayResourceInfo(obj);
  771.     else
  772.     {
  773.         ErrorHandle("Resource", DEVICE_ERR, FIND_FAIL, NO_KILL);
  774.       modified = TRUE;
  775.     }
  776.  
  777.     return;
  778. }
  779.  
  780. static void
  781. ModifyPort(int TypeID, struct objectid *obj)
  782. {
  783.     WORD    sel;
  784.  
  785.     if (CheckObject(&SysBase->PortList, obj))
  786.     {
  787.         sel = DisplayPortInfo(obj);
  788.  
  789.         if (sel && ((obj->address == SysIdPort) || (obj->address == broker_mp) ||
  790.                    (strstr(obj->fullname,"RSYS") != NULL)))
  791.         {
  792.             ErrorHandle(obj->fullname, OWN_OBJECT_ERR, MODIFY_FAIL, NO_KILL);
  793.             return;
  794.         }
  795.  
  796.         if (sel && Question(SysWnd, "Do you want to remove the Port?", YES))
  797.         {
  798.             if (CheckObject(&SysBase->PortList, obj)) RemovePortSafely(NULL, obj);
  799.             else
  800.                 ErrorHandle(obj->fullname, PORT_ERR, FIND_FAIL, NO_KILL);
  801.  
  802.          modified = TRUE;
  803.         }
  804.     }
  805.     else
  806.     {
  807.         ErrorHandle(obj->fullname, PORT_ERR, FIND_FAIL, NO_KILL);
  808.       modified = TRUE;
  809.     }
  810.  
  811.     return;
  812. }
  813.  
  814. static void
  815. ModifyFont(int TypeID, struct objectid *obj)
  816. {
  817.     WORD sel;
  818.     struct TextFont *tf = (struct TextFont *) obj->address;
  819.  
  820.     if (CheckObject(&GfxBase->TextFonts, obj)) sel = DisplayFontInfo(obj);
  821.     else
  822.     {
  823.         ErrorHandle(obj->fullname, FONT_ERR, FIND_FAIL, NO_KILL);
  824.       modified = TRUE;
  825.  
  826.         return;
  827.     }
  828.  
  829.     switch(sel)
  830.     {
  831.         case 1:
  832.             if (Question(SysWnd, "Do you want to close and remove this font?", YES))
  833.             {
  834.                 if (CheckObject(&GfxBase->TextFonts, obj)) RemoveFontSafely(tf);
  835.                 else
  836.                     ErrorHandle(obj->fullname, FONT_ERR, FIND_FAIL, NO_KILL);
  837.  
  838.             modified = TRUE;
  839.             }
  840.             break;
  841.  
  842.         case 2:
  843.             if (CheckObject(&GfxBase->TextFonts, obj)) ShowFont((struct TextFont *) obj->address);
  844.             else
  845.          {
  846.                 ErrorHandle(obj->fullname, FONT_ERR, FIND_FAIL, NO_KILL);
  847.             modified = TRUE;
  848.          }
  849.             break;
  850.     }
  851.  
  852.     return;
  853. }
  854.  
  855. static void
  856. ModifyWindow(int TypeID, struct objectid *obj)
  857. {
  858.     WORD sel;
  859.  
  860.     sel = DisplayWindowInfo(obj);
  861.  
  862.     if (sel && ((struct Window *) obj->address == SysWnd))
  863.     {
  864.         ErrorHandle("Main window", OWN_OBJECT_ERR, MODIFY_FAIL, NO_KILL);
  865.         return;
  866.     }
  867.  
  868.     if (sel &&Question(SysWnd, "Closing of Windows are very dangerous! The System \n"
  869.                               "may be crash, when you close an active Window\n"
  870.                               "Do you want to close the Window anyway?", YES))
  871.         ClosingWindows((struct Window *) obj->address);
  872.  
  873.    modified = TRUE;
  874.  
  875.     return;
  876. }
  877.  
  878. static void
  879. ModifyScreen(int TypeID, struct objectid *obj)
  880. {
  881.     WORD sel;
  882.  
  883.     sel = DisplayScreenInfo(obj);
  884.  
  885.     if (sel && (((struct Screen *) obj->address == SysWnd->WScreen) ||
  886.                (((struct Screen *) obj->address)->Flags & WBENCHSCREEN)))
  887.     {
  888.         ErrorHandle((char *)namebuffer, OWN_OBJECT_ERR, MODIFY_FAIL, NO_KILL);
  889.         return;
  890.     }
  891.  
  892.     if (sel && Question(SysWnd, "Closing of Screens are very dangerous! The System \n"
  893.                                "may be crash, when you close an active Screen with\n"
  894.                                "all associated windows!\n"
  895.                                "Do you want to close the Screen and Windows anyway?", YES))
  896.    {
  897.         ClosingScreens((struct Screen *) obj->address);
  898.       modified = TRUE;
  899.    }
  900.  
  901.     return;
  902. }
  903.  
  904. static void
  905. DisplayTreeDevice(int TypeID, struct objectid *obj)
  906. {
  907.     if (DisplayDiskInfo(obj->fullname, TRUE)) PrintTree(obj);
  908.  
  909.     return;
  910. }
  911.  
  912. static void
  913. DisplayAllFonts(int TypeID, struct Node *ClickedNode)
  914. {
  915.     struct TextFont *tf;
  916.     struct TextAttr testfont;
  917.     int    i,
  918.             j;
  919.     char    fontname[MAXSTRLEN],
  920.             size[5];
  921.  
  922.     i = 0;
  923.  
  924.     while (ClickedNode->ln_Name[i] != ' ')
  925.     {
  926.         fontname[i] = ClickedNode->ln_Name[i];
  927.         i++;
  928.     }
  929.  
  930.     fontname[i] = STRINGEND;
  931.  
  932.     testfont.ta_Name = (UBYTE *) fontname;
  933.  
  934.     while (ClickedNode->ln_Name[i] == ' ') i++;
  935.     while (ClickedNode->ln_Name[i] != ' ')    i++;
  936.     while (ClickedNode->ln_Name[i] == ' ')    i++;
  937.  
  938.     j = 0;
  939.     while (ClickedNode->ln_Name[i] != ' ')
  940.     {
  941.         size[j] = ClickedNode->ln_Name[i];
  942.         i++;
  943.         j++;
  944.     }
  945.  
  946.     size[j] = STRINGEND;
  947.  
  948.     testfont.ta_YSize = atoi(size);
  949.     testfont.ta_Flags = 0;
  950.     testfont.ta_Style = 0;
  951.  
  952.     tf = OpenDiskFont(&testfont);
  953.     if (tf)
  954.     {
  955.         ShowFont(tf);
  956.         CloseFont(tf);
  957.     }
  958.  
  959.     return;
  960. }
  961.  
  962. static void
  963. ModifyVolumeLock(int TypeID, struct objectid *obj)
  964. {
  965.    if(DisplayLockInfo(obj) && Question(SysWnd, "Unlocking is very dangerous!\n"
  966.                                                "Do you really want to unlock this lock?",YES))
  967.    {
  968.       Forbid();
  969.       UnLock((BPTR)obj->address);
  970.       Permit();
  971.  
  972.       modified = TRUE;
  973.    }
  974.  
  975.    return;
  976. }
  977.  
  978.     /*
  979.      * ModifyObject() prüft ob ein Element einer Liste im Hauptfenster
  980.      * modifiziert oder angezeigt werden kann und ruft die entsprechenden
  981.      * Routinen auf
  982.      */
  983. void
  984. ModifyObject(int TypeID, ULONG code)
  985. {
  986.     struct Node *ClickedNode;
  987.     struct objectid *obj;
  988.     char    out[BUFSIZE]
  989.  
  990.     DPOS;
  991.  
  992.    modified = FALSE;
  993.  
  994.     sprintf(out, "Modify %s", EntryAttr[TypeID].ea_type);
  995.     PrintInfo(out, SPEAK, 0);
  996.  
  997.     if (NOT(ClickedNode = GetNode(&ListeLVList, code)))
  998.     {
  999.         ErrorHandle("No Object found ???", LIST_NODE_ERR, FIND_FAIL, NO_KILL);
  1000.         return;
  1001.     }
  1002.  
  1003.     obj = &((ScrollEntry *) ClickedNode)->se_obj_id;
  1004.  
  1005.     switch (TypeID)
  1006.     {
  1007.         case TASKS:
  1008.             ModifyTask(TypeID, obj);
  1009.             break;
  1010.  
  1011.         case LIBRARIES:
  1012.             ModifyLibrary(TypeID, obj);
  1013.             break;
  1014.  
  1015.         case SYSSOFTDEV:
  1016.             DisplaySoftDevice(TypeID, obj);
  1017.             break;
  1018.  
  1019.         case RESOURCES:
  1020.             DisplayResource(TypeID, obj);
  1021.             break;
  1022.  
  1023.         case PORTS:
  1024.             ModifyPort(TypeID, obj);
  1025.             break;
  1026.  
  1027.         case FONTS:
  1028.             ModifyFont(TypeID, obj);
  1029.             break;
  1030.  
  1031.         case WINDOWS:
  1032.             ModifyWindow(TypeID, obj);
  1033.             break;
  1034.  
  1035.         case SCREENS:
  1036.             ModifyScreen(TypeID, obj);
  1037.             break;
  1038.  
  1039.         case ASSIGNS:
  1040.         case VOLUMES:
  1041.             DisplayTreeDevice(TypeID, obj);
  1042.             break;
  1043.  
  1044.         case ALLFONTS:
  1045.             DisplayAllFonts(TypeID, ClickedNode);
  1046.             break;
  1047.  
  1048.       case VOLLOCKS:
  1049.          ModifyVolumeLock(TypeID, obj);
  1050.          break;
  1051.  
  1052.       case SYSINFO:
  1053.       case HARDWARE:
  1054.       case PREFS:
  1055.       case ENVVARS:
  1056.       case SYSVECTORS:
  1057.       case PRINTERDATA:
  1058.       case LIBRARYOFFS:
  1059.             DisplayBeep(NULL);
  1060.             break;
  1061.  
  1062.       case MEMORY:
  1063.          if(code < 3) DisplayBeep(NULL);
  1064.          else
  1065.             Monitor(obj, ((ScrollEntry *) ClickedNode)->se_Entry);
  1066.          break;
  1067.  
  1068.         default:
  1069.          Monitor(obj, ((ScrollEntry *) ClickedNode)->se_Entry);
  1070.             break;
  1071.     }
  1072.  
  1073.    if(modified) RefreshList(LastID);
  1074.  
  1075.     PrintStatistics();
  1076.  
  1077.     return;
  1078. }
  1079.  
  1080.