home *** CD-ROM | disk | FTP | other *** search
/ Creative Computers / CreativeComputers.iso / shareware / management / tasky_1.0 / source / tasky.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-11-17  |  7.0 KB  |  374 lines
  1. /*
  2.  * TaskY
  3.  * 
  4.  * Simple replacement for TaskX. Why? Because I wanted to...
  5.  * 
  6.  * Martin W. Scott, 19 March 1993.
  7.  */
  8.  
  9. #include <exec/types.h>
  10. #include <exec/execbase.h>
  11. #include <exec/memory.h>
  12. #include <exec/tasks.h>
  13. #include <dos/dos.h>
  14. #include <dos/var.h>
  15. #include <libraries/gadtools.h>
  16. #include <intuition/intuition.h>
  17. #include <string.h>
  18. #include <proto/dos.h>
  19. #include <proto/exec.h>
  20. #include <proto/intuition.h>
  21. #include <proto/gadtools.h>
  22.  
  23. static UBYTE VersTag[] = "\0$VER: TaskY 1.0";
  24.  
  25. #define ENVNAME        "TaskY_pos"
  26.  
  27. #include "ptask.h"
  28. PTASK *ptask;            /* current task node */
  29. WORD n=-1;            /* and its place in list */
  30. TASK *currtask;            /* and task, for relocation */
  31.  
  32. /* Local protos */
  33. void EasyEasyRequest(char *str);
  34. void CloseLibs(void);
  35. BOOL OpenLibs(void);
  36. void LoadPosition(void);
  37. void SavePosition(void);
  38. VOID _main(char *args);
  39. void HandleWindow(void);
  40.  
  41. /* Libraries */
  42. struct Library *GadToolsBase, *UtilityBase;
  43. struct GfxBase *GfxBase;
  44. struct IntuitionBase *IntuitionBase;
  45. extern struct ExecBase *SysBase;
  46.  
  47. #include "window.c"    /* gadtools-generated... */
  48.  
  49. /* dead simple requester */
  50. void
  51. EasyEasyRequest(char *str)
  52. {
  53.     struct EasyStruct es;
  54.  
  55.     es.es_StructSize = sizeof(struct EasyStruct);
  56.  
  57.     es.es_Flags = 0L;
  58.     es.es_Title = "TaskY Message";
  59.     es.es_TextFormat = str;
  60.     es.es_GadgetFormat = "OK";
  61.     EasyRequestArgs(NULL, &es, NULL, NULL);
  62. }
  63.  
  64. #define Msg(s) EasyEasyRequest(s)
  65.  
  66. void
  67. CloseLibs()
  68. {
  69.     if (GadToolsBase) CloseLibrary(GadToolsBase);
  70.     if (UtilityBase) CloseLibrary(UtilityBase);
  71.     if (GfxBase) CloseLibrary(GfxBase);
  72.     if (IntuitionBase) CloseLibrary(IntuitionBase);
  73. }
  74.  
  75. BOOL
  76. OpenLibs()
  77. {
  78.     if ((IntuitionBase = (void *)OpenLibrary("intuition.library", 0L)) &&
  79.         (GfxBase = (void *)OpenLibrary("graphics.library", 37L)) &&
  80.         (UtilityBase = OpenLibrary("utility.library", 37L)) &&
  81.         (GadToolsBase = OpenLibrary("gadtools.library", 37L)))
  82.     {
  83.         return TRUE;
  84.     }
  85.     CloseLibs();
  86.     return FALSE;
  87. }
  88.  
  89. /* try to get position of window from env-var */
  90. void
  91. LoadPosition()
  92. {
  93.     UWORD pos[3];
  94.     LONG rc;
  95.  
  96.     rc = GetVar(ENVNAME, (UBYTE *)pos, 3*sizeof(UWORD), GVF_BINARY_VAR);
  97.     if (rc != -1)    /* okay */
  98.     {
  99.         TaskYLeft = pos[0];
  100.         TaskYTop = pos[1];
  101.     }
  102. }
  103.  
  104. /* save (as env-var) position of window */
  105. void
  106. SavePosition()
  107. {
  108.     UWORD pos[3];
  109.  
  110.     pos[0] = TaskYLeft;
  111.     pos[1] = TaskYTop;
  112.     pos[2] = 0;
  113.  
  114.     SetVar(ENVNAME, (UBYTE *)pos, 2*sizeof(UWORD)+1, GVF_GLOBAL_ONLY); 
  115.     /* don't care if it worked... */
  116. }
  117.  
  118. VOID
  119. _main(char *args)
  120. {
  121.     if (OpenLibs())
  122.     {
  123.         if (RefreshPTaskList())        /* read & copy list */
  124.         {
  125.             if (!SetupScreen())
  126.             {
  127.                 LoadPosition();
  128.                 if (!OpenTaskYWindow())
  129.                 {
  130.                     HandleWindow();
  131.                     CloseTaskYWindow();
  132.                 }
  133.                 else Msg("Couldn't open window");
  134.                 CloseDownScreen();
  135.                 SavePosition();
  136.             }
  137.             else Msg("Couldn't get screen data");
  138.  
  139.             DeletePTaskList();    /* and finally, delete list */
  140.         }
  141.         else Msg("Couldn't allocate memory");
  142.  
  143.         CloseLibs();
  144.     }
  145. }
  146.  
  147. /* get nth node in list - list MUST have >= n nodes!!! */
  148. struct Node *
  149. GetNode(struct List *lh, UWORD n)
  150. {
  151.     struct Node *ln;
  152.  
  153.     for (ln = lh->lh_Head; n--; ln = ln->ln_Succ)
  154.         ;
  155.     return ln;
  156. }
  157.  
  158. /* initialise individual gadget */
  159. void
  160. InitGadget(UWORD num, LONG tagtype, LONG tagvalue)
  161. {
  162.     GT_SetGadgetAttrs(TaskYGadgets[num], TaskYWnd, NULL, tagtype, tagvalue, TAG_DONE);
  163. }
  164.  
  165. /* initialise display */
  166. void
  167. InitGadgets(void)
  168. {
  169.     static char windtitle[25]; 
  170.  
  171.     InitGadget(GDX_ListView, GTLV_Labels, (LONG)&ptlist);
  172.     InitGadget(GDX_ListView, GTLV_Selected, n);
  173.     if (n >= 0)
  174.         InitGadget(GDX_Pri, GTIN_Number, ptask->pt_TaskPri);
  175.     else
  176.         InitGadget(GDX_Pri, GTIN_Number, 0);
  177.  
  178.     SPrintf(windtitle, "TaskY 1.0   %ld tasks", num_ptasks);
  179.     SetWindowTitles(TaskYWnd, windtitle, (UBYTE *)~0);
  180. }
  181.  
  182. /* update list and gadgets */
  183. void
  184. Update()
  185. {
  186.     PTASK *pt;
  187.     UWORD new_n;
  188.  
  189.     if (!RefreshPTaskList())
  190.         Msg("Couldn't allocate memory");
  191.  
  192.     if (n >= 0)    /* something was selected */
  193.     {
  194.         n = -1;
  195.         for (new_n = 0, pt = (PTASK *)ptlist.lh_Head;
  196.              pt->pt_Node.ln_Succ;
  197.              new_n++, pt = (PTASK *)pt->pt_Node.ln_Succ)
  198.         {
  199.             if (pt->pt_Task == currtask)
  200.             {
  201.                 n = new_n;
  202.                 ptask = pt;
  203.                 break;
  204.             }
  205.         }
  206.     }
  207.     InitGadgets();
  208. }
  209.  
  210. #define GadString(gadget)    ((struct StringInfo *)(gadget)->SpecialInfo)->Buffer
  211. #define GadNum(gadget)        ((struct StringInfo *)(gadget)->SpecialInfo)->LongInt
  212.  
  213. /* handle window gadgets/menus */
  214. void
  215. HandleWindow()
  216. {
  217.     struct IntuiMessage *msg;
  218.     struct Gadget *gad;
  219.     struct Task *task;
  220.     ULONG class;
  221.     UWORD code;
  222.     LONG sigs, sigmask, newpri;
  223.     BOOL zipped = FALSE;
  224.  
  225.     InitGadgets();
  226.  
  227.     sigmask = 1 << TaskYWnd->UserPort->mp_SigBit |
  228.           SIGBREAKF_CTRL_C;
  229.  
  230.     for (;;)    /* loop until return... */
  231.     {
  232.         sigs = Wait(sigmask);
  233.  
  234.         if (sigs & SIGBREAKF_CTRL_C)
  235.             return;
  236.  
  237.         while (msg = GT_GetIMsg(TaskYWnd->UserPort))
  238.         {
  239.             class = msg->Class;
  240.             code = msg->Code;
  241.             gad = (struct Gadget *)msg->IAddress;
  242.             GT_ReplyIMsg(msg);
  243.  
  244.             switch (class)
  245.             {
  246.             case CLOSEWINDOW:
  247.                 return;
  248.  
  249.             case REFRESHWINDOW:
  250.                 GT_BeginRefresh(TaskYWnd);
  251.                 GT_EndRefresh(TaskYWnd, TRUE);
  252.                 break;
  253.  
  254.             case CHANGEWINDOW:
  255.                 if (TaskYWnd->Width == TaskYWidth)
  256.                 {
  257.                     if (zipped)
  258.                     {
  259.                         /* unzipped! */
  260.                         zipped = FALSE;
  261.                         Update();
  262.                     }
  263.  
  264.                     /* not zipped, must be moved */
  265.                     TaskYLeft = TaskYWnd->LeftEdge;
  266.                     TaskYTop = TaskYWnd->TopEdge;
  267.                 }
  268.                 else if (TaskYWnd->Width < TaskYWidth)
  269.                     zipped = TRUE;
  270.                 break;
  271.  
  272.             case VANILLAKEY:
  273.                 switch (code)
  274.                 {
  275.                 case 'u': case 'U':
  276.                     Update();
  277.                     break;
  278.                 case 'z': case 'Z':
  279.                     ZipWindow(TaskYWnd);
  280.                     break;
  281.                 case 27:  /* ESCAPE */
  282.                     return;
  283.                 }
  284.                 break;
  285.  
  286.             case GADGETDOWN:
  287.             case GADGETUP:
  288.                 if (gad->GadgetID == GD_ListView)
  289.                 {
  290.                     n = code;
  291.                     ptask = (PTASK *)GetNode(&ptlist, n);
  292.                     currtask = ptask->pt_Task;
  293.                     InitGadget(GDX_Pri, GTIN_Number, ptask->pt_TaskPri);
  294.                     ActivateGadget(TaskYGadgets[GD_Pri], TaskYWnd, NULL);
  295.                     break;
  296.                 }
  297.                 else if (gad->GadgetID == GD_Update)
  298.                 {
  299.                     Update();
  300.                     break;
  301.                 }
  302.                 else /* some other button */
  303.                 {
  304.                     if (n < 0)
  305.                         break;
  306.                     /* okay, do the changes */
  307.                     Forbid();
  308.                     if (!(task = GetOrigTask(ptask)))
  309.                     {
  310.                         Permit();
  311.                         break;
  312.                     }
  313.  
  314.                     switch (gad->GadgetID)
  315.                     {
  316.                     case GD_MinusFive:
  317.                         SetTaskPri(task, -5);
  318.                         break;
  319.  
  320.                     case GD_MinusOne:
  321.                         SetTaskPri(task, -1);
  322.                         break;
  323.  
  324.                     case GD_Zero:
  325.                         SetTaskPri(task, 0);
  326.                         break;
  327.  
  328.                     case GD_PlusOne:
  329.                         SetTaskPri(task, 1);
  330.                         break;
  331.  
  332.                     case GD_PlusFive:
  333.                         SetTaskPri(task, 5);
  334.                         break;
  335.  
  336.                     case GD_Pri:
  337.                         newpri = GadNum(gad);
  338.                         if (newpri >= -128 && newpri < 128)
  339.                             SetTaskPri(task, newpri);
  340.                         break;
  341.  
  342.                     case GD_SigC:
  343.                         Signal(task, SIGBREAKF_CTRL_C);
  344.                         /* give it a chance to work */
  345.                         if (task != SysBase->ThisTask)
  346.                             Delay(50);
  347.                         break;
  348.  
  349.                     case GD_SigD:
  350.                         Signal(task, SIGBREAKF_CTRL_D);
  351.                         break;
  352.  
  353.                     case GD_SigE:
  354.                         Signal(task, SIGBREAKF_CTRL_E);
  355.                         break;
  356.  
  357.                     case GD_SigF:
  358.                         Signal(task, SIGBREAKF_CTRL_F);
  359.                         break;
  360.  
  361.                     } /* switch (gadget id) */
  362.                     Permit();
  363.                     Update();
  364.                     break;
  365.                 }
  366.  
  367.             } /* switch (class) */
  368.  
  369.         } /* while */
  370.  
  371.     } /* for */
  372.  
  373. } /* HandleWindow() */
  374.