workbench/libs/muimaster/classes/process.c

   1 /*
   2     Copyright © 2012, The AROS Development Team. All rights reserved.
   3     $Id$
   4 */
   5
   6 #define MUIMASTER_YES_INLINE_STDARG
   7
   8 #include <clib/alib_protos.h>
   9 #include <proto/intuition.h>
  10 #include <proto/muimaster.h>
  11 #include <proto/utility.h>
  12 #include <proto/dos.h>
  13
  14 #include "mui.h"
  15 #include "muimaster_intern.h"
  16 #include "support.h"
  17 #include "support_classes.h"
  18 #include "process_private.h"
  19
  20 #define MYDEBUG 1
  21 #include "debug.h"
  22
  23 #define DELAYTICKS (10)
  24
  25
  26 extern struct Library *MUIMasterBase;
  27
  28
  29 static void my_process(void)
  30 {
  31     // invokes MUIM_Process_Process  for the the class/object specified by
  32     // MUIA_Process_SourceClass/Object (source class may be NULL)
  33
  34     D(bug("[Process.mui] my_process called\n"));
  35
  36     struct Task *thistask = FindTask(NULL);
  37     struct Process_DATA *data = thistask->tc_UserData;
  38
  39     if (data->sourceclass)
  40     {
  41         CoerceMethod(data->sourceclass, data->sourceobject,
  42             MUIM_Process_Process, &data->kill, data->self);
  43     }
  44     else
  45     {
  46         DoMethod(data->sourceobject, MUIM_Process_Process, &data->kill,
  47             data->self);
  48     }
  49
  50     data->task = NULL;          // show MUIM_Process_Kill that we're done
  51
  52     D(bug("[Process.mui] my_process terminated\n"));
  53 }
  54
  55
  56 IPTR Process__OM_NEW(struct IClass *cl, Object *obj, struct opSet *msg)
  57 {
  58     struct Process_DATA *data;
  59     struct TagItem *tag, *tags;
  60     struct Task *thistask;
  61
  62     obj = (Object *) DoSuperMethodA(cl, obj, (Msg) msg);
  63     if (!obj)
  64         return FALSE;
  65
  66     data = INST_DATA(cl, obj);
  67
  68     data->self = obj;
  69
  70     // defaults
  71     data->autolaunch = TRUE;
  72     data->stacksize = 40000;
  73     thistask = FindTask(NULL);
  74     data->priority = thistask->tc_Node.ln_Pri;
  75
  76     for (tags = msg->ops_AttrList; (tag = NextTagItem(&tags));)
  77     {
  78         switch (tag->ti_Tag)
  79         {
  80         case MUIA_Process_AutoLaunch:
  81             data->autolaunch = tag->ti_Data;
  82             break;
  83
  84         case MUIA_Process_Name:
  85             data->name = (STRPTR) tag->ti_Data;
  86             break;
  87
  88         case MUIA_Process_Priority:
  89             data->priority = tag->ti_Data;
  90             break;
  91
  92         case MUIA_Process_SourceClass:
  93             data->sourceclass = (struct IClass *)tag->ti_Data;
  94             break;
  95
  96         case MUIA_Process_SourceObject:
  97             data->sourceobject = (Object *) tag->ti_Data;
  98             break;
  99
 100         case MUIA_Process_StackSize:
 101             data->stacksize = tag->ti_Data;
 102             break;
 103         }
 104     }
 105
 106     D(bug("muimaster.library/process.c: Process Object created at 0x%lx\n",
 107             obj));
 108
 109     if (data->autolaunch)
 110     {
 111         DoMethod(obj, MUIM_Process_Launch);
 112     }
 113
 114     return (IPTR) obj;
 115 }
 116
 117
 118 IPTR Process__OM_GET(struct IClass *cl, Object *obj, struct opGet *msg)
 119 {
 120 #define STORE *(msg->opg_Storage)
 121
 122     struct Process_DATA *data = INST_DATA(cl, obj);
 123
 124     STORE = 0;
 125
 126     switch (msg->opg_AttrID)
 127     {
 128     case MUIA_Process_Task:
 129         STORE = (IPTR) data->task;
 130         return TRUE;
 131     }
 132
 133     return DoSuperMethodA(cl, obj, (Msg) msg);
 134 #undef STORE
 135 }
 136
 137
 138 IPTR Process__OM_DISPOSE(struct IClass *cl, Object *obj, Msg msg)
 139 {
 140     D(bug("[Process.mui/OM_DISPOSE]\n"));
 141
 142     // struct Process_DATA *data = INST_DATA(cl, obj);
 143
 144     DoMethod(obj, MUIM_Process_Kill, 0);
 145
 146     return DoSuperMethodA(cl, obj, msg);
 147 }
 148
 149
 150 IPTR Process__MUIM_Process_Kill(struct IClass *cl, Object *obj,
 151     struct MUIP_Process_Kill *msg)
 152 {
 153     D(bug("[MUIM_Process_Kill] maxdelay %d\n", msg->maxdelay));
 154
 155     struct Process_DATA *data = INST_DATA(cl, obj);
 156     ULONG delay = 0;
 157     BOOL retval = TRUE;
 158
 159     // send SIGBREAKF_CTRL_C
 160     // wait until  it has terminated
 161
 162     // Stops process' loop (MUIM_Process_Process). If the loop
 163     // is not running does nothing.
 164
 165     // msg->maxdelay == 0 means "wait forever"
 166
 167     data->kill = 1;             // stops the loop in Class4.c demo
 168
 169     // the spawned task sets data->task to NULL on exit
 170     while (data->task != NULL)
 171     {
 172         Signal((struct Task *)data->task, SIGBREAKF_CTRL_C);
 173         Delay(DELAYTICKS);
 174         delay += DELAYTICKS;
 175         D(bug("[MUIM_Process_Kill] delay %d maxdelay %d\n", delay,
 176                 msg->maxdelay));
 177         if ((msg->maxdelay != 0) && (delay > msg->maxdelay))
 178         {
 179             D(bug("[MUIM_Process_Kill] timeout\n"));
 180             retval = FALSE;
 181             break;
 182         }
 183     }
 184
 185     D(bug("[MUIM_Process_Kill] retval %d\n", retval));
 186
 187     return retval;
 188 }
 189
 190
 191 IPTR Process__MUIM_Process_Launch(struct IClass *cl, Object *obj,
 192     struct MUIP_Process_Launch *msg)
 193 {
 194     D(bug("[MUIM_Process_Launch]\n"));
 195
 196     struct Process_DATA *data = INST_DATA(cl, obj);
 197
 198     // Starts process's loop (MUIM_Process_Process). If the loop
 199     // is already running does nothing.
 200
 201     if (data->task == NULL)
 202     {
 203         struct TagItem tags[] = {
 204             {NP_Entry, (IPTR) my_process},
 205             {NP_StackSize, data->stacksize},
 206             {data->name ? NP_Name : TAG_IGNORE,
 207                 (IPTR) data->name},
 208             {NP_Priority, data->priority},
 209             {NP_UserData, (IPTR) data},
 210             {TAG_DONE}
 211         };
 212
 213         data->task = CreateNewProc(tags);
 214     }
 215
 216     return (IPTR) TRUE;
 217 }
 218
 219
 220 IPTR Process__MUIM_Process_Process(struct IClass *cl, Object *obj,
 221     struct MUIP_Process_Process *msg)
 222 {
 223     D(bug("[MUIM_Process_Process] kill %p proc %p\n", msg->kill,
 224             msg->proc));
 225
 226     // struct Process_DATA *data = INST_DATA(cl, obj);
 227
 228     // Main process method. Terminating condition is passed in message struct.
 229     // Proper implementation should wait for a signal to not use 100% cpu.
 230     // This is some kind of a virtual function. Sub-class implementators
 231     // must overwrite it.
 232
 233     return DoSuperMethodA(cl, obj, (Msg) msg);
 234 }
 235
 236
 237 IPTR Process__MUIM_Process_Signal(struct IClass *cl, Object *obj,
 238     struct MUIP_Process_Signal *msg)
 239 {
 240     D(bug("[MUIM_Process_Signal] sigs %u\n", msg->sigs));
 241
 242     struct Process_DATA *data = INST_DATA(cl, obj);
 243
 244     // just send an arbitrary signal to the spawned process.
 245     if (data->task)
 246     {
 247         Signal((struct Task *)data->task, msg->sigs);
 248     }
 249
 250     return 0;
 251 }
 252
 253
 254 #if ZUNE_BUILTIN_PROCESS
 255 BOOPSI_DISPATCHER(IPTR, Process_Dispatcher, cl, obj, msg)
 256 {
 257     switch (msg->MethodID)
 258     {
 259     case OM_NEW:
 260         return Process__OM_NEW(cl, obj, (struct opSet *)msg);
 261     case OM_GET:
 262         return Process__OM_SET(cl, obj, (struct opSet *)msg);
 263     case OM_DISPOSE:
 264         return Process__OM_DISPOSE(cl, obj, msg);
 265     case MUIM_Process_Kill:
 266         return Process__MUIM_Process_Kill(cl, obj,
 267             (struct MUIP_Process_Kill *)msg);
 268     case MUIM_Process_Launch:
 269         return Process__MUIM_Process_Launch(cl, obj,
 270             (struct MUIP_Process_Launch *)msg);
 271     case MUIM_Process_Process:
 272         return Process__MUIM_Process_Process(cl, obj,
 273             (struct MUIP_Process_Process *)msg);
 274     case MUIM_Process_Signal:
 275         return Process__MUIM_Process_Signal(cl, obj,
 276             (struct MUIP_Process_Signal *)msg);
 277     default:
 278         return DoSuperMethodA(cl, obj, msg);
 279     }
 280 }
 281 BOOPSI_DISPATCHER_END
 282
 283 const struct __MUIBuiltinClass _MUI_Process_desc =
 284 {
 285     MUIC_Process,
 286     MUIC_Semaphore,
 287     sizeof(struct Process_DATA),
 288     (void *) Process_Dispatcher
 289 };
 290 #endif /* ZUNE_BUILTIN_PROCESS */