home *** CD-ROM | disk | FTP | other *** search
/ The Fred Fish Collection 1.5 / ffcollection-1-5-1992-11.iso / ff_progs / ui_utils / inputvie.lzh / Source.lha / Inputhandler.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-01-31  |  11.3 KB  |  380 lines
  1. /*----------------------------------------------------------------------------
  2.    File   :    InputHandler.c
  3.    Projekt:    InputView ab V0.24
  4.    Inhalt :    ProudHandler (mein erster Input-Handler!!)
  5.                LaunchPHandler (setzt den ProudHandler in die Handlerliste ein)
  6.                KillerHandler (der 'Alles-Wegfreß-Inputhandler')
  7.                LaunchKHandler (setzt meinen KillerHandler ab)
  8.                CatchHandler (und hier hole ich ihn wieder raus)
  9.                InInput (setzt die gespeicherten IEvents wieder ein)
  10.                LoadEvents (lade eine Events-Datei in den Buffer)
  11.                SaveEvents (sichere den Events-Buffer als File ab)
  12.  
  13.    Version:    0.18
  14.    Autor  :    Uwe Röhm
  15.    Adresse:    Auber Str. 25,  W-6209 Hohenstein 4
  16.     (Semester) Wörthstr. 18    W-8390 Passau
  17.    Bemerkung:
  18.    ACHTUNG:
  19.    Der Inputhandler muß mit einer Priorität >50 (und <127!!!) gestartet
  20.    werden, da er sonst keine Tiner-Ticks erhält und somit nie abbricht.
  21. ----------------------------------------------------------------------------*/
  22.  
  23. #include <exec/Types.h>
  24. #include <exec/io.h>
  25. #include <exec/ports.h>
  26. #include <libraries/dos.h>
  27. #include <exec/interrupts.h>
  28. #include <devices/inputevent.h>
  29. #include <devices/timer.h>
  30. #include <devices/input.h>
  31. #include <dos.h>
  32. #include "InputHandy.h"
  33.  
  34. #ifndef LATTICE
  35.    #include <functions.h>
  36. #else
  37.    #include <proto/exec.h>
  38.    #include <proto/dos.h>
  39.    #include <proto/timer.h>
  40.    #include <stdio.h>
  41. #endif
  42.  
  43. extern struct Interrupt *InputInt;
  44. extern struct IOStdReq  *InputDev;
  45. extern struct timerequest *TimeRequest;
  46. extern struct IEZahlen  *Numbers;
  47. extern int Priority;
  48. extern BOOL Sperre;
  49. extern struct Library *TimerBase;
  50. extern char * FileName;
  51.  
  52. /*  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --
  53.    Funktion  :  ProudHandler
  54.    Parameter :  struct InputEvent *ie1 (Zeiger auf Events...)
  55.                 struct IEZahlen *n (Zeiger auf Zahlenliste...)
  56.    Rückgabe  :  struct InputEvent *(wie genommen, so zeronnen)
  57.  
  58.    Aufruf von:  InputDevice (im ROM !)
  59.    UnterFunks:  --
  60.    Autor     :  Uwe Röhm (Floyd)
  61.    Datum     :  ???
  62.    Bemerkung:
  63.    Mein erster Input-Handler. Mal sehen, ob alles klappt.
  64. --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  */
  65. struct InputEvent* __regargs ProudHandler(struct InputEvent *ie1,struct IEZahlen *n)
  66. {
  67. struct InputEvent *iez;
  68.  
  69.    for (iez=ie1; iez; iez= iez->ie_NextEvent)
  70.    {
  71.       switch (iez->ie_Class)
  72.       {
  73.          case IECLASS_RAWKEY:
  74.          case IECLASS_RAWMOUSE:
  75.             if (n->BufferMarke != n->BufferEnde)
  76.             {
  77.                CopyMem (iez, n->BufferMarke, sizeof (struct InputEvent));
  78.                if (iez->ie_Class == IECLASS_RAWKEY)
  79.                   n->BufferMarke->ie_Class = IECLASS_GADGETDOWN;
  80.                else
  81.                   n->BufferMarke->ie_Class = IECLASS_GADGETUP;
  82.                n->BufferMarke->ie_NextEvent = NULL;
  83.                n->BufferMarke++;
  84.             }
  85.             else
  86.                Signal (n->MyPort->mp_SigTask, n->IESignal);
  87.             break;
  88.          case IECLASS_TIMER:
  89.             n->Timer++;
  90.             if (n->Timer > n->TimerMax)
  91.             {  n->Timer = 0;
  92.                Signal (n->MyPort->mp_SigTask, n->IESignal);
  93.             }
  94.             break;
  95.          default:
  96.             break;
  97.       }
  98.    }
  99.    return ie1;
  100. }
  101.  
  102.  
  103. /*  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --
  104.    Funktion  :  LaunchPHandler
  105.    Parameter :  --
  106.    Rückgabe  :  --
  107.  
  108.    Aufruf von:  main (InputMain.c)
  109.    UnterFunks:  --
  110.    Autor     :  Floyd
  111.    Datum     : ??
  112.    Bemerkung:
  113.    startet meine ProudHandler und setzt den Pointer auf die linke obere Ecke.
  114. --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  */
  115. VOID LaunchPHandler ()
  116. {
  117. struct InputEvent ie =  {
  118.    NULL, IECLASS_POINTERPOS, 0, IECODE_NOBUTTON, 0,  0, 0,  0, 0};
  119.  
  120.    InputInt->is_Code = (VOID *) ProudHandler;
  121.    InputInt->is_Data = (APTR) Numbers;
  122.    InputInt->is_Node.ln_Pri = Priority;
  123.    InputInt->is_Node.ln_Name = PHANDLERNAME;
  124.  
  125.    InputDev->io_Data    = (APTR) InputInt;
  126.    InputDev->io_Command = IND_ADDHANDLER;
  127.    DoIO ((struct IORequest *) InputDev);
  128.  
  129.    /* jetzt noch schnell den Pointer auf eine fest definierte Position*/
  130.    InputDev->io_Data = (APTR) &ie;
  131.    InputDev->io_Length = sizeof (struct InputEvent);
  132.    InputDev->io_Flags = 0;
  133.    InputDev->io_Command = IND_WRITEEVENT;
  134.    DoIO ((struct IORequest *) InputDev);
  135. }
  136.  
  137.  
  138. /*  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --
  139.    Funktion  :  KillerHandler
  140.    Parameter :  struct InputEvent *ie1 (Zeiger auf Events...)
  141.                 struct IEZahlen noull (Zeiger auf nichts, denn ich brauch nix)
  142.    Rückgabe  :  struct InputEvent *(wie genommen, so zeronnen)
  143.  
  144.    Aufruf von:  InputDevice (im ROM !)
  145.    UnterFunks:  --
  146.    Autor     :  Uwe
  147.    Datum     :  ??
  148.    Bemerkung:
  149.    Hehehe. Hier werden alle User-Eingaben radikal vernichtet. Nur die eigenen
  150.    eingesetzten Events lasse ich durch. Wie ich die erkenne? Na, ich gehe
  151.    davon aus, daß ich über der Intuition sitze (WICHTIG!!) und codiere nun
  152.    meine eingesetzten Events in solche um, die eigentlich erst die Intuition
  153.    erzeugt. Damit ist die Sachlage klar. Ich brauch sie nur zurückzukonver-
  154.    tieren und passieren zu lassen.
  155. --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  */
  156. struct InputEvent* __regargs KillerHandler(struct InputEvent *ie1, APTR noull)
  157. {
  158. struct InputEvent *iez;
  159.  
  160.    for (iez=ie1; iez; iez = iez->ie_NextEvent)
  161.    {
  162.       switch (iez->ie_Class)
  163.       {
  164.          /* Der ganze restliche Klimbatsch kommt raus.... */
  165.          case IECLASS_RAWKEY:
  166.          case IECLASS_RAWMOUSE:
  167.             iez->ie_Class = IECLASS_NULL;
  168.             iez->ie_SubClass = 0;
  169.             iez->ie_Code  = 0;
  170.             iez->ie_Qualifier = 0;
  171.             break;
  172.  
  173.          /* Diese Classes kommen sonst nur von der Intuition */
  174.          case IECLASS_GADGETDOWN:
  175.             iez->ie_Class = IECLASS_RAWKEY;
  176.             break;
  177.          case IECLASS_GADGETUP:
  178.             iez->ie_Class = IECLASS_RAWMOUSE;
  179.             break;
  180.  
  181.          default:
  182.             break;
  183.       }
  184.    }
  185.  
  186.    return ie1;
  187. }
  188.  
  189.  
  190. /*  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --
  191.    Funktion  :  LaunchKHandler
  192.    Parameter :  --
  193.    Rückgabe  :  --
  194.  
  195.    Aufruf von:  InInput (s.u.)
  196.    UnterFunks:  --
  197.    Autor     :  Floyd (that's me)
  198.    Datum     :  ??
  199.    Bemerkung:
  200.    Und hier starte ich den KillerHandler (s.o.)
  201. --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  */
  202. VOID LaunchKHandler ()
  203. {
  204.    InputInt->is_Code = (VOID*) KillerHandler;
  205.    InputInt->is_Data = NULL;
  206.    InputInt->is_Node.ln_Pri = Priority;
  207.    InputInt->is_Node.ln_Name = KHANDLERNAME;
  208.  
  209.    InputDev->io_Data    = (APTR) InputInt;
  210.    InputDev->io_Command = IND_ADDHANDLER;
  211.    DoIO ((struct IORequest *) InputDev);
  212. }
  213.  
  214.  
  215. /*  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --
  216.    Funktion  :  CatchHandler
  217.    Parameter :  --
  218.    Rückgabe  :  --
  219.  
  220.    Aufruf von:  main (InputMain.c)
  221.    UnterFunks:  --
  222.    Autor     :  Uwe Röhm
  223.    Datum     :  ??
  224.    Bemerkung:
  225.    Der gerade laufende InputHandler (KillerH. oder ProudH.) wird beendet.
  226. --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  */
  227. VOID CatchHandler ()
  228. {
  229.    InputDev->io_Data    = (APTR) InputInt;
  230.    InputDev->io_Command = IND_REMHANDLER;
  231.    DoIO ((struct IORequest *) InputDev);
  232. }
  233.  
  234.  
  235. /*---------------------------------------------------------------------------
  236.    Funktion  :  InInput
  237.    Parameter :  struct VictimIno v (Zeiger auf - na du weisst schon)
  238.    Rückgabe  :  --
  239.  
  240.    Aufruf von:  SendLoop <s.u.>
  241.    UnterFunks:  LaunchKHandler (s.o.)
  242.                 CatchHandler (s.o.)
  243.    Autor     :  Uwe Röhm
  244.    Datum     :  ??
  245.    Beschreibung:
  246.    "InInput" mischt die gespeicherten InputEvents unter die des Systems
  247.    (Input-Device sollte ja längst offen sein....). Dabei beachte ich die
  248.    Zeitverzögerung zwischen den einzelnen Events (per Timer-Device). Die
  249.    Trägheit der Workbench ist damit z.B. kein Problem mehr!!!!
  250.    Außerdem sperre ich währenddessen alle anderen Events.
  251. ---------------------------------------------------------------------------*/
  252. void InInput ()
  253. {
  254. struct timeval *oldtime;
  255. struct InputEvent *i;
  256. struct InputEvent ie =  {
  257.    NULL, IECLASS_POINTERPOS, 0, IECODE_NOBUTTON, 0,  0, 0,  0, 0};
  258.  
  259.   if (Sperre)
  260.      LaunchKHandler ();
  261.  
  262.   /* jetzt noch schnell den Pointer auf die erste gespeicherte Maus-Position */
  263.   InputDev->io_Length = sizeof (struct InputEvent);
  264.   InputDev->io_Flags = 0;
  265.   InputDev->io_Command = IND_WRITEEVENT;
  266.   InputDev->io_Data = (APTR) &ie;
  267.   DoIO ((struct IORequest *) InputDev);
  268.  
  269.   oldtime = &Numbers->BufferAnfang->ie_TimeStamp;
  270.   TimeRequest->tr_node.io_Command = TR_ADDREQUEST;
  271.  
  272.   for (i = Numbers->BufferAnfang; i < Numbers->BufferMarke; i++)
  273.   {
  274.      TimeRequest->tr_time.tv_secs = i->ie_TimeStamp.tv_secs;
  275.      TimeRequest->tr_time.tv_micro= i->ie_TimeStamp.tv_micro;
  276.      SubTime ((struct timerequest *) &TimeRequest->tr_time,
  277.               (struct timerequest *)oldtime);
  278.      DoIO ((struct IORequest *)TimeRequest);
  279.      oldtime = &i->ie_TimeStamp;
  280.  
  281.      InputDev->io_Data = (APTR) i;
  282.      DoIO ((struct IORequest *) InputDev);
  283.   }
  284.  
  285.   if (Sperre)
  286.      CatchHandler ();
  287. }
  288.  
  289.  
  290. /*  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --
  291.    Funktion  :  SaveEvents
  292.    Parameter :  --
  293.    Rückgabe  :  eventueller DOS-Error!
  294.  
  295.    Aufruf von:  main (InputMain.c)
  296.    UnterFunks:  --
  297.    Autor     :  Floyd
  298.    Datum     :  ??
  299.    Bemerkung :
  300.    Diese Funktion speichert meinen Events-Buffer in eine Datei.
  301. --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  */
  302. int SaveEvents ()
  303. {
  304.    char FileBuffer[108];
  305.    int fh;
  306.    int error;
  307.    long size;
  308.    unsigned int count;
  309.  
  310.    if (FileName == NULL)
  311.    {  printf ("Aufgezeichnete Events abspeichern in Datei:\n");
  312.       FileName = gets (FileBuffer);
  313.    }
  314.  
  315.    fh = _dopen (FileName, MODE_READWRITE);
  316.    if (fh == -1)
  317.    {
  318.       fh = _dcreatx(FileName,0);
  319.       if (fh == -1)
  320.          return (-1);
  321.    }
  322.  
  323.    size = (Numbers->BufferMarke - Numbers->BufferAnfang);
  324.    count = _dwrite (fh,(char *)&size, sizeof (long));
  325.    count = _dwrite (fh,(char *)Numbers->BufferAnfang,size * sizeof(struct InputEvent));
  326.  
  327.    if (count < 1)
  328.    {
  329.       error = _dclose (fh);
  330.       return (-1);
  331.    }
  332.    error = _dclose (fh);
  333.  
  334.    return (error);
  335. }
  336.  
  337.  
  338. /*  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --
  339.    Funktion  :  LoadEvents
  340.    Parameter :  --
  341.    Rückgabe  :  eventueller DOS-Error!
  342.                 gefüllter Events-Buffer
  343.  
  344.    Aufruf von:  main (InputMain.c)
  345.    UnterFunks:  --
  346.    Autor     :  Floyd
  347.    Datum     :  -?-
  348.    Bemerkung :
  349.    Diese Funktion lädt einen Events-Buffer aus einer Datei.
  350. --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  */
  351. int LoadEvents ()
  352. {
  353.    char FileBuffer [108];
  354.    int fh;
  355.    int error;
  356.    long size;
  357.    unsigned int count;
  358.  
  359.    if (FileName == NULL)
  360.    {  printf ("Dateiname der aufgezeichneten Events: \n");
  361.       FileName = gets (FileBuffer);
  362.    }
  363.  
  364.    fh = _dopen ((char *)FileName,MODE_READWRITE);
  365.    if (fh == -1)
  366.    return (-1);
  367.  
  368.    count = _dread (fh, (char *) &size, sizeof(long));
  369.    count = _dread (fh, (char *)Numbers->BufferAnfang, size * sizeof(struct InputEvent));
  370.    if (count < 1)
  371.    {
  372.       error = _dclose (fh);
  373.       return (-1);
  374.    }
  375.    Numbers->BufferMarke = Numbers->BufferAnfang + size;
  376.    error = _dclose (fh);
  377.  
  378.    return (error);
  379. }
  380.