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