home *** CD-ROM | disk | FTP | other *** search
/ Gold Fish 3 / goldfish_volume_3.bin / files / util / misc / ascsend / non-mui / ascsend-source / ascsend.c next >
C/C++ Source or Header  |  1995-06-19  |  20KB  |  687 lines
  1. #include "ascsend.h"
  2.  
  3. /* ------------------------------------------------------------------- */
  4. /*      for cback.o startup */
  5. /* ------------------------------------------------------------------- */
  6.  
  7. long                      __stack        = 4096;
  8. char                      *__procname    = ASCSEND_VERSION;
  9. long                      __priority      = 0L;
  10. long                      __BackGroundIO = 0;
  11. extern BPTR               _Backstdout;
  12.  
  13. /* ------------------------------------------------------------------- */
  14.  
  15. struct TagItem       FRTags[] =
  16.                      {
  17.                       ASL_Hail,(ULONG)"ASC_Send: Datei auswählen",
  18.                       ASL_FuncFlags,0L,
  19.                       ASL_LeftEdge,0L,
  20.                       ASL_TopEdge,0L,
  21.                       ASL_Dir,0L,
  22.                       ASL_Pattern,(ULONG)"~(#?.info)",
  23.                       ASL_File,0L,
  24.                       TAG_DONE,0L
  25.                      };
  26.  
  27. struct EasyStruct InfoReq =
  28.        {
  29.         0L,0L,(UBYTE *)"ASC_Send",
  30.               (UBYTE *)ASCSEND_VERSION "\n\nFreeware By Lunqual%%MAB@wsb.freinet.de\n",
  31.               (UBYTE *)"Beenden|Weiter",
  32.        };
  33.  
  34. UBYTE  *version = ASCSEND_VERSION; 
  35. struct NewBroker  newbroker;
  36. CxObj            *broker;  
  37. char            **tooltypes;
  38.  
  39. struct List       action_list;
  40. struct Node       dummy; 
  41. ULONG             verzoegerung;
  42. ULONG             v_char;
  43. ULONG             from_inside;
  44. UBYTE             reqpath[STRINGSIZE];
  45. UBYTE             reqfile[STRINGSIZE];
  46.  
  47. struct IOStdReq  *s_HandlerIO;
  48. struct MsgPort   *s_InputPort;
  49. BYTE              s_device;
  50.  
  51. long              __OSlibversion = 37;
  52.  
  53. ULONG filesize;
  54. ULONG filepos;
  55.  
  56. void __stdargs main(int argc,char **argv)
  57. {
  58.  int   end = FALSE;
  59.  NewList(&action_list);
  60.  {
  61.   if(OpenBroker(argc,argv))
  62.   {
  63.    while(!end)
  64.    {
  65.     Wait(1L << newbroker.nb_Port->mp_SigBit);
  66.     if(HandleBroker() == RETURN_QUIT) end = TRUE;
  67.    }
  68.    CloseBroker();
  69.   }
  70.  }
  71.  exit(0);
  72. }
  73.  
  74. int OpenBroker(int argc,char **argv)
  75. {
  76.  int     ret = FALSE;
  77.  UBYTE   keybuffer[20];
  78.  UBYTE   filebuffer[20];
  79.  if(newbroker.nb_Port = CreateMsgPort())
  80.  {
  81.   tooltypes = ArgArrayInit(argc,argv);
  82.   newbroker.nb_Version = NB_VERSION;
  83.   newbroker.nb_Name    = "ASCII_SEND";
  84.   newbroker.nb_Title   = "ASCII Send to  Window Tool";
  85.   newbroker.nb_Descr   = "Sends Textfiles as Inputevents ";
  86.   newbroker.nb_Unique  = NBU_UNIQUE | NBU_NOTIFY;
  87.   newbroker.nb_Pri     = (BYTE)ArgInt(tooltypes,"CX_PRIORITY",0);  
  88.   verzoegerung         = (ULONG)ArgInt(tooltypes,"DELAY",0);
  89.   v_char               = (ULONG)ArgInt(tooltypes,"DELAYCHAR",0);
  90.   strncpy(reqpath,ArgString(tooltypes,"REQPATH",""),STRINGSIZE);
  91.   strncpy(reqfile,ArgString(tooltypes,"REQFILE",""),STRINGSIZE);
  92.   if(broker = CxBroker(&newbroker,NULL))
  93.   {
  94.    /* make keys */
  95.    long  i = HOTKEY_BASE;
  96.    int end = FALSE;
  97.    {
  98.     struct a_node *node;
  99.     if(node  = MakeActionNode(ArgString(tooltypes,"INFOKEY","control alt s"),NULL,
  100.                                 0)) AddTail(&action_list,(struct Node *)node);
  101.    }
  102.    if(ArgString(tooltypes,"REQUESTKEY","control alt i"))
  103.    {
  104.     struct a_node *node;
  105.     if(node  = MakeActionNode(ArgString(tooltypes,"REQUESTKEY","control alt 2"),NULL,
  106.                                 1)) AddTail(&action_list,(struct Node *)node);
  107.    }
  108.    if(ArgString(tooltypes,"STOPKEY",NULL))
  109.    {
  110.     struct a_node *node;
  111.     if(node  = MakeActionNode(ArgString(tooltypes,"STOPKEY","control alt 3"),NULL,
  112.                                 2)) AddTail(&action_list,(struct Node *)node);
  113.    }
  114.    for(;!end;i++)
  115.    {
  116.     sprintf(keybuffer,"HOTKEY%ld",i - HOTKEY_BASE);
  117.     sprintf(filebuffer,"FILE%ld",i - HOTKEY_BASE);
  118.     if(ArgString(tooltypes,keybuffer,NULL))
  119.     {
  120.      if(ArgString(tooltypes,filebuffer,NULL))
  121.      {
  122.       struct a_node *node;
  123.       if(node  = MakeActionNode(ArgString(tooltypes,keybuffer,NULL),
  124.                                 ArgString(tooltypes,filebuffer,NULL),
  125.                                 i))
  126.       {
  127.        AddTail(&action_list,(struct Node *)node);
  128.        ret = TRUE;
  129.       }         
  130.      }
  131.     }
  132.     else end = TRUE;
  133.    }
  134.   }
  135.  }
  136.  if(ret)ActivateCxObj(broker,1L);
  137.  return ret;
  138. }
  139.  
  140. void CloseBroker()
  141. {
  142.  struct a_node *n;
  143.  struct Message *msg;
  144.  if(broker)
  145.  {
  146.    if(newbroker.nb_Port)
  147.   {
  148.    while(msg = GetMsg(newbroker.nb_Port))ReplyMsg(msg);
  149.    DeletePort(newbroker.nb_Port);
  150.   }
  151.   while(n = (struct a_node *)RemHead(&action_list))RemActionNode(n);
  152.   DeleteCxObjAll(broker);
  153.   if(tooltypes)ArgArrayDone();
  154.  }
  155. }
  156.  
  157. struct a_node *MakeActionNode(UBYTE *key,UBYTE *file,LONG ID)
  158. {
  159.  struct a_node *node;
  160.  if(node = (struct a_node *)AllocVec(sizeof(struct a_node),MEMF_ANY | MEMF_CLEAR))
  161.  {
  162.   strncpy(node->an_action.hotkey,key,STRINGSIZE);
  163.   if(file)strncpy(node->an_action.file,file,STRINGSIZE);
  164.   node->an_action.id = ID;
  165.   if(node->an_action.key = CxFilter(node->an_action.hotkey))
  166.   {
  167.    AttachCxObj(broker,node->an_action.key);
  168.    if(node->an_action.sender = CxSender(newbroker.nb_Port,ID))
  169.    {
  170.     AttachCxObj(node->an_action.key,node->an_action.sender);
  171.     if(node->an_action.translate = (CxTranslate(NULL)))
  172.     {
  173.      AttachCxObj(node->an_action.key,node->an_action.translate);
  174.     }
  175.    }
  176.   }
  177.  }
  178.  return node;   
  179. }
  180.  
  181. void  RemActionNode(struct a_node *node)
  182. {
  183.  DeleteCxObjAll(node->an_action.key);
  184.  FreeVec(node); 
  185. }
  186.  
  187. int HandleBroker()
  188. {
  189.  LONG id,type;
  190.  int rc = RETURN_IS_OK;
  191.  CxMsg *msg;
  192.  if(msg = (CxMsg *)GetMsg(newbroker.nb_Port))
  193.  {
  194.   id    = CxMsgID(msg);
  195.   type  = CxMsgType(msg);
  196.   ReplyMsg((struct Message *)msg);
  197.   switch(type)
  198.   {
  199.    case CXM_IEVENT   :{
  200.                        struct a_node *node;
  201.                        if(node = Findentry(id))
  202.                        {
  203.                         if(id == 0)
  204.                         {
  205.                          if(EasyRequest(NULL,&InfoReq,NULL) == 1)rc = RETURN_QUIT;
  206.                         }
  207.                         else if(id == 1)
  208.                         {
  209.                          UBYTE filename[STRINGSIZE];
  210.                          struct Window *active_wd;
  211.                          active_wd =  IntuitionBase->ActiveWindow;
  212.                          if(!from_inside)
  213.                          {
  214.                           if(showrequest())
  215.                           {
  216.                            strncpy(filename,reqpath,STRINGSIZE);
  217.                            AddPart(filename,reqfile,STRINGSIZE);
  218.                            ScreenToFront(active_wd->WScreen);
  219.                            ActivateWindow(active_wd);
  220.                            rc = Sendfile(filename,GET_A_FILE);
  221.                           }
  222.                          }
  223.                         }
  224.                         else if(id == 2)
  225.                         {
  226.                          rc = RETURN_STOP;
  227.                         }
  228.                         else if(!from_inside)rc = Sendfile(node->an_action.file,GET_A_FILE);
  229.                        }
  230.                       }
  231.                       break;
  232.    case CXM_COMMAND  :
  233.         switch(id)
  234.         {
  235.          case CXCMD_DISABLE   : ActivateCxObj(broker,0L);
  236.                                 break;
  237.          case CXCMD_ENABLE    : ActivateCxObj(broker,1L);
  238.                                 break;
  239.          case CXCMD_KILL      : if(EasyRequest(NULL,&InfoReq,NULL) == 1)rc = RETURN_QUIT;
  240.                                 break;
  241.          case CXCMD_UNIQUE    : rc = RETURN_QUIT;
  242.                                 break; 
  243.          default     : break;
  244.         }
  245.         break;     
  246.    default           : break;
  247.   }
  248.  }
  249.  return rc;
  250. }
  251.  
  252. long __regargs Sendfile(UBYTE *filename,ULONG mode)
  253. {
  254.  int rc = TRUE;
  255.  struct InputEvent *ie;
  256.  UBYTE buffer[STRINGSIZE];
  257.  UBYTE *filebuffer;
  258.  int Ldelay     = FALSE;
  259.  ULONG           stop = FALSE;
  260.  ULONG           v_line;
  261.  ULONG           v_z;
  262.  ULONG           fpm;
  263.  ULONG           brk = IE_COUNT;
  264.  if(!makeIHandler())return rc;
  265.  v_line = verzoegerung;
  266.  v_z = v_char;
  267.  from_inside = TRUE;
  268.  filepos = 0;
  269.  if(filebuffer = getfilebuffer(filename,mode))
  270.  {
  271.   while((getnextchar(filebuffer,buffer)) && (!stop))
  272.   {
  273.    *(buffer + 1) = 0;
  274.    switch(*buffer)
  275.    {
  276.     case '\n' : Ldelay = TRUE;
  277.                 strcpy(buffer,"\\n");
  278.                 break;
  279.     case '\r' : Ldelay = TRUE;
  280.                 strcpy(buffer,"\\r");
  281.                 break;
  282.     case '\t' : strcpy(buffer,"\\t");
  283.                 break;
  284.     case '\\' : fpm = filepos;
  285.                 getnextchar(filebuffer,buffer + 1);
  286.                 *(buffer + 2) = 0;
  287.                 {
  288.                  int end = FALSE;
  289.                  int p = 2;
  290.                  ULONG v;
  291.                  if((*(buffer + 1)=='d')||(*(buffer + 1)=='l')||(*(buffer + 1)=='c')||
  292.                     (*(buffer + 1)=='n')||(*(buffer + 1)=='r')||(*(buffer + 1)=='t'))
  293.                  {
  294.                   do
  295.                   {
  296.                    if( (*(buffer + 1)=='n')||(*(buffer + 1)=='r')||(*(buffer + 1)=='t'))
  297.                    {
  298.                     end = TRUE;
  299.                    }
  300.                    else
  301.                    {
  302.                     getnextchar(filebuffer,buffer + p);
  303.                     if(!(isdigit(*(buffer + p))) || (p >= 6))
  304.                     {
  305.                      end = TRUE;
  306.                      *(buffer + p + 1) = 0;
  307.                      v = atol(buffer + 2);
  308.                      switch(*(buffer + 1))
  309.                      {
  310.                       case 'd' : Delay(v);
  311.                                  break;
  312.                       case 'l' : v_line = v;
  313.                                  break;
  314.                       case 'c' : v_z = v;
  315.                                  break;
  316.                       default  : break;
  317.                      }
  318.                      *buffer = 0;
  319.                      filepos -= 1;
  320.                     }
  321.                     p++;
  322.                     if(p >= (STRINGSIZE - 2))end = TRUE;
  323.                    }
  324.                   }
  325.                   while(!end); 
  326.                  }
  327.                  else
  328.                  {
  329.                   UBYTE t[2] = {0,0}; 
  330.                   struct InputEvent ev;
  331.                   if(*(buffer + 1) == '(')
  332.                   {
  333.                    getnextchar(filebuffer,buffer + 2);
  334.                    getnextchar(filebuffer,buffer + 3);
  335.                    getnextchar(filebuffer,buffer + 4);
  336.                    getnextchar(filebuffer,buffer + 5);
  337.                    if((*(buffer + 3) == 'm')&&(*(buffer + 5)==':'))
  338.                    {
  339.                     int p = 6;
  340.                     int py;
  341.                     int end = FALSE;
  342.                     while(!end)
  343.                     {
  344.                      getnextchar(filebuffer,buffer + p);
  345.                      if(!(isdigit(*(buffer + p))))
  346.                      {
  347.                       end = TRUE;
  348.                      }
  349.                      p++;
  350.                     }
  351.                     --p;
  352.                     if(*(buffer + p) == ',')
  353.                     {
  354.                      p++;
  355.                      py = p;
  356.                      end = FALSE;
  357.                      while(!end)
  358.                      {
  359.                       getnextchar(filebuffer,buffer + p);
  360.                       if(!(isdigit(*(buffer + p))))
  361.                       {
  362.                        end = TRUE;
  363.                       }
  364.                       p++;
  365.                      }
  366.                      --p;
  367.                      if(*(buffer + p) == ')')
  368.                      {
  369.                       ev.ie_Class = IECLASS_POINTERPOS;
  370.                       ev.ie_NextEvent = NULL;
  371.                       ev.ie_Qualifier = 0;
  372.                       ev.ie_SubClass  = 0;
  373.                       ev.ie_TimeStamp.tv_secs = 0;
  374.                       ev.ie_TimeStamp.tv_micro = 0;
  375.                       ev.ie_Y = (WORD)atol(buffer + py);
  376.                       ev.ie_X = (WORD)atol(buffer + 6);
  377.                       switch(*(buffer + 2))
  378.                       {
  379.                        case 'l' : if(*(buffer + 4) == 'd')
  380.                                    ev.ie_Code      = IECODE_LBUTTON ;
  381.                                   else
  382.                                     ev.ie_Code      = IECODE_LBUTTON | IECODE_UP_PREFIX;
  383.                                   my_AddIEvents(&ev);
  384.                                   break;
  385.                        case 'r' : if(*(buffer + 4) == 'd')
  386.                                    ev.ie_Code      = IECODE_RBUTTON ;
  387.                                   else
  388.                                     ev.ie_Code      = IECODE_RBUTTON | IECODE_UP_PREFIX;
  389.                                   my_AddIEvents(&ev);
  390.                                   break;
  391.                         case 'm' : if(*(buffer + 4) == 'd')
  392.                                    ev.ie_Code      = IECODE_MBUTTON ;
  393.                                   else
  394.                                     ev.ie_Code      = IECODE_MBUTTON | IECODE_UP_PREFIX;
  395.                                   my_AddIEvents(&ev);
  396.                                   break;
  397.                       }
  398.                       *buffer = 0;
  399.                      }
  400.                      else
  401.                      {
  402.                       filepos =fpm;
  403.                       strcpy(buffer,"\\\\");
  404.                       if(ie = InvertString(buffer,NULL))
  405.                       {
  406.                        my_AddIEvents(ie);
  407.                        FreeIEvents(ie);
  408.                        *buffer = 0;
  409.                       }
  410.                      }
  411.                     }
  412.                     else
  413.                     {
  414.                      filepos = fpm;
  415.                      strcpy(buffer,"\\\\");
  416.                      if(ie = InvertString(buffer,NULL))
  417.                      {
  418.                       my_AddIEvents(ie);
  419.                       FreeIEvents(ie);
  420.                       *buffer = 0;
  421.                      }
  422.                     }
  423.                    }
  424.                    else
  425.                    {
  426.                     filepos = fpm;
  427.                     strcpy(buffer,"\\\\");
  428.                     if(ie = InvertString(buffer,NULL))
  429.                     {
  430.                      my_AddIEvents(ie);
  431.                      FreeIEvents(ie);
  432.                      *buffer = 0;
  433.                     }
  434.                    }
  435.                   }
  436.                   else
  437.                   {
  438.                    t[0] = *(buffer + 1);
  439.                    strcpy(buffer,"\\\\");
  440.                    if(ie = InvertString(buffer,NULL))
  441.                    {
  442.                     my_AddIEvents(ie);
  443.                     FreeIEvents(ie);
  444.                    }
  445.                   }
  446.                   strcpy(buffer,t);
  447.                   switch(*buffer)
  448.                   {
  449.                    case '\n' : strcpy(buffer,"\\n");
  450.                                break;
  451.                    case '\r' : strcpy(buffer,"\\r");
  452.                                break;
  453.                    case '<'  : *buffer = 0;filepos -= 1;
  454.                                break;
  455.                   }
  456.                  }
  457.                 }
  458.                 break;
  459.     case '<'  : {
  460.                  int end;
  461.                  int p;
  462.                  end = FALSE;
  463.                  p = 1;
  464.                  fpm = filepos;
  465.                  do
  466.                  {
  467.                   getnextchar(filebuffer,buffer + p);
  468.                   switch(*(buffer + p))
  469.                   {
  470.                    case '\r': 
  471.                    case '\n': if(ie = InvertString("\\<",NULL))
  472.                               {
  473.                                my_AddIEvents(ie); 
  474.                                FreeIEvents(ie);
  475.                               }
  476.                               filepos = fpm;
  477.                               *buffer = 0;
  478.                               end = TRUE;
  479.                               break;
  480.                    case '>' : *(buffer + p + 1) = 0;
  481.                               if(ie = InvertString(buffer,NULL))
  482.                               {
  483.                                my_AddIEvents(ie); 
  484.                                FreeIEvents(ie);
  485.                               }
  486.                               else
  487.                               {
  488.                                if(ie = InvertString("\\<",NULL))
  489.                                {
  490.                                 my_AddIEvents(ie); 
  491.                                 FreeIEvents(ie);
  492.                                }
  493.                                filepos = fpm;
  494.                               }
  495.                               *buffer = 0;
  496.                               end = TRUE;
  497.                               break;
  498.                    default  : break;
  499.                   }
  500.                   p++;
  501.                   if(p >= (STRINGSIZE - 2))end = TRUE;
  502.                  }
  503.                  while(!end);
  504.                  break;
  505.                 }
  506.     
  507.     case '>'  : if(ie = InvertString(buffer,NULL))
  508.                 {
  509.                  my_AddIEvents(ie); 
  510.                  FreeIEvents(ie);
  511.                 }
  512.                 strcpy(buffer,"\\>");
  513.                 break;
  514.     default   : *(buffer + 1) = 0;
  515.                 break;
  516.    }
  517.    if(ie = InvertString(buffer,NULL))
  518.    {
  519.     --brk;
  520.     if(v_z)Delay(v_z);
  521.     my_AddIEvents(ie);
  522.     if(Ldelay)
  523.     {
  524.      Delay(v_line);
  525.      Ldelay = FALSE;
  526.      brk = 0;
  527.     }
  528.     if(!brk)
  529.     {
  530.      brk = IE_COUNT;
  531.      {
  532.       int r = HandleBroker();
  533.       switch(r)
  534.       {
  535.        case RETURN_STOP : stop = TRUE;
  536.                           break;
  537.        case RETURN_QUIT : stop = TRUE; rc = RETURN_QUIT;
  538.                           break;
  539.        case RETURN_IS_OK   :
  540.        default          : break;
  541.       }
  542.      }
  543.     }
  544.     FreeIEvents(ie);
  545.    }
  546.   }
  547.   freefilebuffer(filebuffer,filesize);
  548.  }
  549.  from_inside=FALSE; 
  550.  remIHandler();
  551.  return rc;
  552. }
  553.  
  554. struct a_node *Findentry(LONG id)
  555. {
  556.  struct a_node *n;
  557.  for(n = (struct a_node *)action_list.lh_Head;n->an_Node.ln_Succ;n = (struct a_node *)n->an_Node.ln_Succ)
  558.  {
  559.   if(n->an_action.id == id)return n;
  560.  }
  561.  return NULL;
  562. }
  563.  
  564. int showrequest()
  565. {
  566.  int ret = FALSE;
  567.  struct  FileRequester *FileReq;
  568.  struct Screen         *rscreen;
  569.  if(rscreen = LockPubScreen(NULL))ScreenToFront(rscreen);
  570.  FRTags[4].ti_Data = (ULONG)reqpath;
  571.  FRTags[6].ti_Data = (ULONG)reqfile;
  572.  if(FileReq = (struct FileRequester *)AllocAslRequest(ASL_FileRequest,FRTags))
  573.  {
  574.   if(RequestFile(FileReq))
  575.   {
  576.    ret = TRUE;
  577.    strcpy(reqfile,FileReq->rf_File);
  578.    strcpy(reqpath,FileReq->rf_Dir);
  579.   }
  580.   FreeAslRequest((APTR)FileReq);
  581.  }
  582.  return ret;
  583. }
  584.  
  585. UBYTE __regargs *makemem(ULONG size)
  586. {
  587.  return((UBYTE *)AllocVec(size,MEMF_PUBLIC | MEMF_CLEAR));   
  588. }
  589.  
  590. void releasemem(void *mem)
  591. {
  592.  FreeVec(mem);   
  593. }
  594.  
  595. UBYTE __regargs *getfilebuffer(UBYTE *filename,ULONG mode)
  596. {
  597.  struct FileInfoBlock *fib;
  598.  BPTR lock,fh;
  599.  UBYTE *buffer;
  600.  switch( mode )
  601.  {
  602.   case GET_A_FILE: 
  603.   if(lock = Lock(filename,ACCESS_READ))
  604.   {
  605.    if(fib = AllocDosObject(DOS_FIB,TAG_DONE))
  606.    {
  607.     Examine(lock,fib);
  608.     filesize = fib->fib_Size;
  609.     FreeDosObject(DOS_FIB,fib);
  610.     if(buffer = (UBYTE *)makemem(filesize))
  611.     {
  612.      if(fh = OpenFromLock(lock))
  613.      {
  614.       FRead(fh,buffer,filesize,1);
  615.       Close(fh);
  616.       return buffer;
  617.      }
  618.      else UnLock(lock);
  619.     }
  620.    }
  621.   }
  622.   return NULL;
  623.   break;
  624.   case GET_A_STRING :
  625.   filesize = strlen(filename + 1);
  626.   if(buffer = (UBYTE *)makemem(filesize))
  627.   {
  628.    strcpy(buffer,filename);
  629.    return buffer;
  630.   }
  631.   else return NULL;
  632.   break;
  633.  }
  634.  return NULL;
  635. }
  636.  
  637. void __regargs freefilebuffer(UBYTE *buffer,ULONG size)
  638. {
  639.  releasemem(buffer);   
  640. }
  641.  
  642. BOOL __regargs getnextchar(UBYTE *buffer,UBYTE *where)
  643. {
  644.  if(filepos >= filesize)return FALSE;
  645.  *where = *(buffer + filepos);
  646.  filepos++;   
  647.  return TRUE;
  648. }
  649.  
  650.  
  651. /*********************************************************************/
  652. /*                  InputHandler Glump                               */
  653. /*********************************************************************/
  654.  
  655. LONG makeIHandler()
  656. {
  657.  if(s_InputPort = CreateMsgPort())
  658.  {
  659.   if(s_HandlerIO = (struct IOStdReq *)CreateExtIO(s_InputPort,sizeof(struct IOStdReq)))
  660.   {
  661.    if(!(s_device = OpenDevice("input.device",NULL,(struct IORequest *)s_HandlerIO,0L)))
  662.    {
  663.     s_HandlerIO->io_Length  = sizeof(struct InputEvent);
  664.     s_HandlerIO->io_Command = IND_WRITEEVENT;
  665.     return(TRUE);
  666.    }
  667.   }  
  668.  }
  669.  return (FALSE);
  670. }
  671.  
  672. void remIHandler()
  673. {
  674.  if(s_HandlerIO)
  675.  {
  676.   if(!s_device)CloseDevice((struct IORequest *)s_HandlerIO);
  677.   DeleteExtIO((struct IORequest *)s_HandlerIO);
  678.   s_HandlerIO = NULL;
  679.  }
  680.  if(s_InputPort)
  681.  {
  682.   DeletePort(s_InputPort);
  683.   s_InputPort = NULL;
  684.  }
  685. }
  686.  
  687.