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