home *** CD-ROM | disk | FTP | other *** search
/ The Fred Fish Collection 1.5 / ffcollection-1-5-1992-11.iso / ff_disks / 500-599 / ff599.lzh / InputView / Source.lha / InputMain.c < prev    next >
C/C++ Source or Header  |  1992-01-31  |  10KB  |  350 lines
  1. /*----------------------------------------------------------------------------
  2.    File   :    InputMain.c
  3.    Projekt:    InputView ab V0.24
  4.    Inhalt :    OpenDevs (Unterfunktion für OpenAll, die nur Devices behandelt)
  5.                OpenAll  (die berühmte "Öffne-Mir-Alles"-Routine)
  6.                CloseAll (Zumachen tu ich das dann auch wieder)
  7.                ShowHelp (Gibt den Hilfe-Text in CLI-Fenster aus)
  8.                TestArgs (die CLI-Parameter werden ausgewertet)
  9.                main     (zumindest mal ein HauptPrg)
  10.  
  11.    Version:    0.24
  12.    Autor  :    Uwe Röhm
  13.    Adresse:    Auber Str. 25,  W-6209 Hohenstein 4
  14.     (Semester) Wörthstr. 18    W-8390 Passau
  15.    Bemerkung:
  16.    Dies soll ein kurzes TestProgramm werden (eines unter vielen), mit dem
  17.    ich mal die Input-Hander Geschichten ausprobieren kann.
  18.    Zumindest will ich wissen, welche Events wann wieoft erscheinen.
  19. ----------------------------------------------------------------------------*/
  20. short PRGVersion = 0;
  21. short PRGRevision= 24;
  22.  
  23. #include <exec/Types.h>
  24. #include <exec/io.h>
  25. #include <exec/memory.h>
  26. #include <exec/ports.h>
  27. #include <devices/InputEvent.h>
  28. #include <devices/timer.h>
  29. #include <libraries/dos.h>
  30. #include <intuition/intuitionbase.h>
  31. #include <graphics/gfxbase.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. #endif
  40. #include <stdio.h>
  41. #include <stdlib.h>
  42.  
  43. /*  --------------------  Globale Variablen   --------------------  */
  44. struct Interrupt *InputInt;
  45. struct IOStdReq *InputDev;
  46. struct timerequest *TimeRequest;
  47. struct IEZahlen *Numbers;
  48. struct MsgPort *MyPort;
  49. struct Library *TimerBase;
  50. int Priority, WaitTime, BigBuffer;
  51. char *FileName;
  52. BOOL Sperre, Laden, Sichern;
  53.  
  54.  
  55. /*  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --
  56.    Funktion  : OpenDevs
  57.    Parameter : --
  58.    Rückgabe  : BOOL (TRUE+ => alles korrekt geöffnet, sonst FALSE)
  59.  
  60.    Aufruf von: OpenAll (s.u.)
  61.    UnterFunks: --
  62.    Autor     : Uwe Röhm
  63.    Datum     : -?-
  64.    Bemerkung :
  65.    Die benötigten Devices werden geöffnet (der Versuch zählt!).
  66. --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  */
  67. BOOL OpenDevs ()
  68. {
  69.   if ((MyPort = (struct MsgPort *) FindPort (PORTNAME)))
  70.   {   Signal (MyPort->mp_SigTask, SIGBREAKF_CTRL_C);  }
  71.   else
  72.   {
  73.     if (MyPort = CreatePort (PORTNAME, 0) )
  74.     {
  75.       InputDev = (struct IOStdReq *) CreateExtIO (MyPort, sizeof (struct IOStdReq));
  76.       if (InputDev)
  77.       {
  78.         if( OpenDevice ("input.device", NULL,(struct IORequest *) InputDev, NULL) )
  79.         {
  80.           DeleteExtIO ((struct IORequest *) InputDev);
  81.           InputDev = NULL;
  82.         }
  83.         else
  84.         {
  85.            TimeRequest =(struct timerequest *)CreateExtIO(MyPort, sizeof(struct timerequest));
  86.            if (TimeRequest)
  87.            {
  88.               if ( (OpenDevice (TIMERNAME,UNIT_VBLANK,(struct IORequest *)TimeRequest,0)) != NULL)
  89.               {
  90.                  DeleteExtIO ((struct IORequest *) TimeRequest);
  91.                  TimeRequest = NULL;
  92.               }
  93.               else
  94.               {
  95.                  TimerBase = (struct Library*) TimeRequest->tr_node.io_Device;
  96.                  return TRUE;   }
  97.            }
  98.         }
  99.       }
  100.     }
  101.   }
  102.   return FALSE;
  103. }
  104.  
  105.  
  106. /*  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --
  107.    Funktion  : OpenAll
  108.    Parameter : --
  109.    Rückgabe  : BOOL (TRUE+ => alles korrekt geöffnet, sonst FALSE)
  110.  
  111.    Aufruf von: main (s.u.)
  112.    UnterFunks: OpenDevs (s.o.)
  113.    Autor     : Uwe Röhm
  114.    Datum     : -?-
  115.    Bemerkung :
  116.    Die benötigten Devices werden geöffnet (über OpenDevs) und Speicher
  117.    allokiert.
  118. --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  */
  119. BOOL OpenAll ()
  120. {
  121.    if (OpenDevs ())
  122.    {
  123.       if (InputInt = (struct Interrupt*) AllocMem (sizeof (*InputInt), MEMOPTS))
  124.       {
  125.          if (Numbers = (struct IEZahlen*) AllocMem (sizeof (*Numbers), MEMOPTS))
  126.          {
  127.             if (Numbers->BufferAnfang = (struct InputEvent *) AllocMem (BigBuffer * sizeof(struct InputEvent), MEMOPTS))
  128.             {
  129.                Numbers->BufferMarke = Numbers->BufferAnfang;
  130.                Numbers->BufferEnde = Numbers->BufferAnfang + BigBuffer * sizeof (struct InputEvent);
  131.                Numbers->TimerMax = WaitTime * 10; /* Sekunden in Ticks umgerechnet */
  132.                Numbers->MyPort = MyPort;
  133.                if ((Numbers->IESignal = AllocSignal (-1)) != -1)
  134.                {    return TRUE;    }
  135.             }
  136.          }
  137.       }
  138.    }
  139.    return FALSE;
  140. }
  141.  
  142.  
  143. /*  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --
  144.    Funktion  : CloseAll
  145.    Parameter : --
  146.    Rückgabe  : --
  147.  
  148.    Aufruf von: main (s.u.)
  149.    UnterFunks: --
  150.    Autor     : Uwe Röhm
  151.    Datum     : ???
  152.    Bemerkung :
  153.    Meine globale ShowDown-Funktion. Was mit "OpenAll" aufgemacht wurde, sollte
  154.    hier auch wieder geschlossen werden.
  155. --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  */
  156. VOID CloseAll ()
  157. {
  158.    if (Numbers)
  159.    {
  160.       FreeSignal (Numbers->IESignal);
  161.       if (Numbers->BufferAnfang)
  162.       {  FreeMem (Numbers->BufferAnfang, BigBuffer * sizeof (struct InputEvent));
  163.          if (Numbers->IESignal != -1)
  164.             FreeSignal (Numbers->IESignal);
  165.       }
  166.       FreeMem (Numbers, sizeof (*Numbers));
  167.    }
  168.    if (InputInt)
  169.    {  FreeMem (InputInt, sizeof (*InputInt));   }
  170.    if (TimeRequest)
  171.    {
  172.       CloseDevice ((struct IORequest *) TimeRequest);
  173.       DeleteExtIO ((struct IORequest *) TimeRequest);
  174.       TimeRequest = NULL;
  175.    }
  176.    if (InputDev)
  177.    {
  178.       CloseDevice ((struct IORequest *) InputDev);
  179.       DeleteExtIO ((struct IORequest *) InputDev);
  180.       InputDev = NULL;
  181.    }
  182.    if (MyPort)
  183.    {
  184.       DeletePort (MyPort);
  185.       MyPort = NULL;
  186.    }
  187. }
  188.  
  189.  
  190. /*  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --
  191.    Funktion :  ShowHelp
  192.    Parameter:  --
  193.    Rückgabe :  --
  194.  
  195.    Aufruf von: main (s.u.)
  196.    UnterFunks: --
  197.    Autor     : Floyd
  198.    Datum     : ???
  199.    Bemerkung :
  200.    Gibt eine Kurzbeschreibung dieses wahrhaften tollen PRGs aus (wenn ich den
  201.    Sinn mal vergessen sollte, werde ich noch dankbar sein...).
  202. --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  */
  203. VOID ShowHelp ()
  204. {
  205.    printf ("\n   Ich installiere einen kleinen Input-Handler, der mir\n");
  206.    printf ("   eingehende Events kopiert. Nach der angegebenen Zeit\n");
  207.    printf ("   spiele ich sie dann einfach wieder ein. Very nett....\n");
  208.    printf ("   Parameter:\n");
  209.    printf ("   -P# : Die Priorität, mit der mein 'ProudHandler' ge-\n");
  210.    printf ("         startet wird (DEFAULT: %d)\n",HANDLERPRI);
  211.    printf ("   -W# : Ich warte # Sekunden lang (DEFAULT %d)\n",WAITTIME);
  212.    printf ("   -Z# : Eine neue Größe meines Events-Buffers (DEFAULT %d)\n",BUFFERMAX);
  213.    printf ("   -A  : Schaltet die Abfangroutine ein/aus (DEFAULT: %d)\n",Sperre);
  214.    printf ("   -S [<File-Name>]:\n    Die kopierten Events werden in <File-Name> gespeichert\n");
  215.    printf ("   -L [<File-Name>]:\n    Aus <File-Name> werden die Events geladen und abgespielt.\n");
  216. }
  217.  
  218.  
  219. /*  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --
  220.    Funktion  :  TestArgs
  221.    Parameter :  int anz     (Zahl der CLI-Parameter)
  222.                 char *arg[] (einzelne Paramterstrings)
  223.    Rückgabe  :  BOOL  (FALSE => ungültige Parameter oder Hilfe, sonst TRUE)
  224.  
  225.    Aufruf von:  main (s.u.)
  226.    UnterFunks:  ShowHelp (s.o.)
  227.    Autor     :  Uwe
  228.    Datum     :  keine Ahnung
  229.    Bemerkung :
  230.    Ich werte hier die CLI-Parameter aus: Vorangestellte '-' filtere ich aus,
  231.    Groß- und Kleinschreibung unterscheide ich nicht; Der erste Buchstabe
  232.    zählt (einbuchstabige Befehle...).
  233. --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  */
  234. BOOL TestArgs (int anz, char *arg[])
  235. {
  236.    BOOL retcode = TRUE,
  237.         helpme  = FALSE;
  238.    int i,p;
  239.  
  240.    for (i = 1; i < anz; i++)
  241.    {
  242.       if (arg[i][0] == '-')
  243.          p = 1;
  244.       else
  245.          p = 0;
  246.  
  247.       if ( (arg[i][p] == '?') || ((arg[i][p] & 0x5f) == 'H') )
  248.       {  helpme = TRUE; }
  249.  
  250.       switch (arg[i][p] & 0x5f)
  251.       {
  252.          case 'A':
  253.             Sperre = !Sperre;
  254.             break;
  255.          case 'L':
  256.             Laden = TRUE;
  257.             goto getname;
  258.          case 'P':
  259.             Priority = atoi (&arg[i][p+1]);
  260.             break;
  261.          case 'S':
  262.             Sichern = TRUE;
  263. getname:    if (arg[i][p+1] != 0x00)
  264.                FileName = &arg[i][p+1];
  265.             else if (i != (anz-1))
  266.                FileName = arg[++i];
  267.             break;
  268.          case 'W':
  269.             WaitTime = atoi (&arg[i][p+1]);
  270.             break;
  271.          case 'Z':
  272.             BigBuffer = atoi (&arg[i][p+1]);
  273.             break;
  274.          default:
  275.             retcode = FALSE;
  276.             break;
  277.       }
  278.    }
  279.  
  280.    if (!retcode)
  281.    {  if (helpme)
  282.       {  ShowHelp ();   }
  283.       else
  284.       {  printf ("FEHLER in den Parametern....\n");    }
  285.    }
  286.  
  287.    return retcode;
  288. }
  289.  
  290.  
  291. /*  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --
  292.    Funktion  :  main
  293.    Parameter :  int arc      (Zahl der CLI-Parameter)
  294.                 char *argv[] (einzelne Paramterstrings)
  295.    Rückgabe  :  --
  296.  
  297.    Aufruf von:  Benutzer über CLI
  298.    UnterFunks:  TestArgs (s.o.)
  299.                 OpenAll (s.o.)
  300.                 CloseAll (s.o.)
  301.                 LoadEvents (InputHandler.c)
  302.                 SaveEvents (InputHandler.c)
  303.                 LaunchHandler (InputHandler.c)
  304.                 InInputs (InputHandler.c)
  305.    Autor     :  Uwe Röhm
  306.    Datum     : ???
  307.    Bemerkung:
  308.    Vorerst beschränke ich mich auf CLI-Benutzung.
  309. --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  */
  310. VOID main (int argc, char *argv[])
  311. {
  312. ULONG SigMask;
  313.  
  314.    printf (HAILTEXT, PRGVersion, PRGRevision);
  315.    WaitTime = WAITTIME;
  316.    Priority = HANDLERPRI;
  317.    BigBuffer= BUFFERMAX;
  318.    Sperre   = TRUE;
  319.    FileName = NULL;
  320.    Laden    = FALSE;
  321.    Sichern  = FALSE;
  322.  
  323.    if (TestArgs (argc, argv))
  324.    {
  325.       if (OpenAll ())
  326.       {
  327.          if (!Laden)
  328.          {
  329.             LaunchPHandler ();
  330.  
  331.             do
  332.             {   SigMask = Wait (Numbers->IESignal);   }
  333.             while (!(SigMask & Numbers->IESignal));
  334.  
  335.             CatchHandler ();
  336.          }
  337.          else
  338.             LoadEvents ();
  339.  
  340.          if (Sichern)
  341.             SaveEvents ();
  342.          else
  343.             InInput ();
  344.       }
  345.  
  346.       CloseAll ();
  347.    }
  348.  
  349. }
  350.