home *** CD-ROM | disk | FTP | other *** search
/ ARM Club 3 / TheARMClub_PDCD3.iso / hensa / programming / tcl / tclsrc / c / WimpTask < prev   
Text File  |  1996-02-05  |  6KB  |  225 lines
  1. /* Task window commands for tcl */
  2. /* (c) C.T.Stretch */
  3. /* Sat,27 Aug 1994 */
  4.  
  5. #include "tclInt.h"
  6. #undef UCHAR
  7.  
  8. #include "h.WInt"
  9. #include "h.wimp"
  10. #include "h.taskwindow"
  11.  
  12. typedef struct task
  13. { struct task *next;
  14.   char *rec_proc,*quit_proc,*name;
  15.   wimp_t task;
  16.   int txt;
  17. } task;
  18.  
  19. Tcl_HashTable taskTable;
  20. static task *tasklist;
  21.  
  22. /*
  23.  *  --
  24.  *
  25.  *
  26.  *
  27.  *
  28.  *
  29.  * Results:
  30.  *      None.
  31.  *
  32.  * Side effects:
  33.  *      None.
  34.  *
  35. */
  36.  
  37. int w_SystemCmd(ClientData dummy,Tcl_Interp *interp,int argc,char **argv)
  38. { wimp_t t;
  39.   os_error *e;
  40.   char *r;
  41.   if(argc!=2) return wrong(WNA,"system <string>");
  42.   e=xwimp_start_task(argv[1],&t);
  43.   if(e)
  44.   { sprintf(interp->result,"%.199s",e->errmess);
  45.     return TCL_ERROR;
  46.   }
  47.   if(t) strcpy(interp->result,"Task");
  48.   else
  49.   { r=getenv("Sys$ReturnCode");
  50.     if(r) sprintf(interp->result,"%.199s",r);
  51.   }
  52.   return TCL_OK;
  53. }
  54.  
  55. extern void task_killall(void)
  56. { task *t;
  57.   wimp_message wm;
  58.   wm.size=256;
  59.   wm.your_ref=0;
  60.   wm.action=message_TASK_WINDOW_MORITE;
  61.   for(t=tasklist;t;t=t->next) wimp_send_message(wimp_USER_MESSAGE,&wm,t->task);
  62. }
  63.  
  64. static void task_kill(task *t)
  65. { Tcl_HashEntry *p;
  66.   unlink(&(tasklist),t);
  67.   p=Tcl_FindHashEntry(&taskTable,t->name);
  68.   if(!p)
  69.   { msg("Odd close request",0,0);
  70.     return;
  71.   }
  72.   Tcl_DeleteHashEntry(p);
  73.   if(t->quit_proc)
  74.   { substr['n'-'a']=t->name;
  75.     checkEval(t->quit_proc,"quit task");
  76.   }
  77.   substr['n'-'a']=0;
  78.   ckfree(t->rec_proc);ckfree(t->quit_proc);ckfree(t->name);
  79.   ckfree(t);
  80. }
  81.  
  82. void task_message(wimp_message *m)
  83. { task *t;
  84.   int txt,n;
  85.   char stringbuf[256];
  86.   switch(m->action)
  87.   { case message_TASK_WINDOW_NEW_TASK:
  88.                                      return;
  89.         case message_TASK_WINDOW_EGO:txt=
  90.                                     ((taskwindow_message_ego*)(&m->data))->txt;
  91.                                      for(t=tasklist;t;t=t->next) if(txt==t->txt)
  92.                                      { t->task=m->sender;
  93.                                        return;
  94.                                      }
  95.                                      return;
  96.       case message_TASK_WINDOW_MORIO:for(t=tasklist;t;t=t->next)
  97.                                      if(m->sender==t->task)
  98.                                      { task_kill(t);return;}
  99.                                      return;
  100.      case message_TASK_WINDOW_OUTPUT:for(t=tasklist;t;t=t->next)
  101.                                      if(m->sender==t->task)
  102.                                      { if(!t->rec_proc) return;
  103.                                        n=
  104.                                   ((taskwindow_message_data*)(&m->data))->size;
  105.                                        substr['n'-'a']=t->name;
  106.                                        substr['o'-'a']=stringbuf;
  107.                                        strncpy(stringbuf,
  108.                                   ((taskwindow_message_data*)(&m->data))->data,
  109.                                        n);
  110.                                        stringbuf[n]=0;
  111.                                        checkEval(t->rec_proc,"task receive");
  112.                                        substr['o'-'a']=0;
  113.                                        substr['n'-'a']=0;
  114.                                        return;
  115.                                      }
  116.   }
  117. }
  118.  
  119. int w_TaskCmd(ClientData dummy,Tcl_Interp *interp,int argc,char **argv)
  120. { task *t;
  121.   char *cmd="";
  122.   Tcl_HashEntry *p;
  123.   wimp_message wm;
  124.   if(argc<3)
  125.   { sprintf(interp->result,
  126.     "wrong # args: should be w_task name command ... ");
  127.     return TCL_ERROR;
  128.   }
  129.   /* *********** create a task *************** */
  130.   if(!strcmp(argv[2],"create"))
  131.   { int new,m,slot=128;
  132.     char buf[256];
  133.     static int nexttxt=1;
  134.     p=Tcl_CreateHashEntry(&taskTable,argv[1],&new);
  135.     if(!new)
  136.     { Tcl_AppendResult(interp,"task already exists ",argv[1],0);
  137.       return TCL_ERROR;
  138.     }
  139.     t=ckcalloc(sizeof(task));
  140.     t->txt=nexttxt++;
  141.     t->name=scopy(argv[1]);
  142.     for(m=3;m<argc-1;m++)
  143.     { if(!strcmp(argv[m],"-receive"))
  144.       { t->rec_proc=scopy(argv[++m]);
  145.         continue;
  146.       }
  147.       if(!strcmp(argv[m],"-quit"))
  148.       { t->quit_proc=scopy(argv[++m]);
  149.         continue;
  150.       }
  151.       if(!strcmp(argv[m],"-command"))
  152.       { cmd=argv[++m];
  153.         continue;
  154.       }
  155.       if(!strcmp(argv[m],"-slot"))
  156.       { slot=atoi(argv[++m]);
  157.         continue;
  158.       }
  159.     }
  160.     t->next=tasklist;
  161.     tasklist=t;
  162.     Tcl_SetHashValue(p,t);
  163.     sprintf(buf,
  164.       "TaskWindow %.140s -wimpslot %dK -name %s_%.10s -task &%08X -txt &%08X",
  165.                   cmd,slot,progname,t->name,(int)taskhandle,t->txt);
  166.     t->task=wimp_start_task(buf);
  167.     return TCL_OK;
  168.   }
  169.   p=Tcl_FindHashEntry(&taskTable,argv[1]);
  170.   if(!p)
  171.   { Tcl_AppendResult(interp,"No such task ",argv[1],0);
  172.     return TCL_ERROR;
  173.   }
  174.   t=(task*)Tcl_GetHashValue(p);
  175.   wm.size=256;
  176.   wm.your_ref=0;
  177.   if(t->task==0)
  178.   { msg("Task has not responded",0,0);
  179.     return TCL_OK;
  180.   }
  181.   /* *********** send data to task *************** */
  182.   if(!strcmp(argv[2],"send"))
  183.   { char *p;
  184.     int m,n;
  185.     if(argc!=4)
  186.     { sprintf(interp->result,
  187.       "wrong # args: should be w_task name send data");
  188.       return TCL_ERROR;
  189.     }
  190.     wm.action=message_TASK_WINDOW_INPUT;
  191.     p=argv[3];n=strlen(p);
  192.     while(n)
  193.     { m=(n>232)?232:n;
  194.       memcpy(((taskwindow_message_data*)(&wm.data))->data,p,m);
  195.       ((taskwindow_message_data*)(&wm.data))->size=m;
  196.       wimp_send_message(wimp_USER_MESSAGE,&wm,t->task);
  197.       p+=m;n-=m;
  198.     }
  199.     return TCL_OK;
  200.   }
  201.   /* *********** kill task *************** */
  202.   if(!strcmp(argv[2],"kill"))
  203.   { wm.action=message_TASK_WINDOW_MORITE;
  204.     wimp_send_message(wimp_USER_MESSAGE,&wm,t->task);
  205.     return TCL_OK;
  206.   }
  207.   /* *********** suspend task *************** */
  208.   if(!strcmp(argv[2],"suspend"))
  209.   { wm.action=message_TASK_WINDOW_SUSPEND;
  210.     wimp_send_message(wimp_USER_MESSAGE,&wm,t->task);
  211.     return TCL_OK;
  212.   }
  213.   /* *********** resume task *************** */
  214.   if(!strcmp(argv[2],"resume"))
  215.   { wm.action= message_TASK_WINDOW_RESUME;
  216.     wimp_send_message(wimp_USER_MESSAGE,&wm,t->task);
  217.     return TCL_OK;
  218.   }
  219.   Tcl_AppendResult(interp,"unknown w_task command: ",argv[2],0);
  220.   return TCL_ERROR;
  221. }
  222.  
  223.  
  224.  
  225.