home *** CD-ROM | disk | FTP | other *** search
/ Club Amiga de Montreal - CAM / CAM_CD_1.iso / files / 424.lha / EasyMouse / easymouse.c < prev    next >
C/C++ Source or Header  |  1990-09-29  |  20KB  |  760 lines
  1. /***************************************************************************/
  2. /* Programm : EasyMouse V1.0 (c)1989 Oliver Enseling                       */
  3. /* Funktion : Screenblanker,SunMouse,usw.                                  */
  4. /* Version  : 01.000                                                       */
  5. /* */
  6. /* Autor   Datum    Kommentar                                              */
  7. /* Boller  10.7.89  Erstversion Beginn                                     */
  8. /* Boller  02.9.89  Erstversion testfertig für Lattice 5.02                */
  9. /* Boller  05.10.89 noch im debugging                                      */
  10. /***************************************************************************/
  11.  
  12. #include <exec/types.h>
  13. #include <exec/memory.h>
  14. #include <exec/devices.h>
  15. #include <intuition/intuition.h>
  16. #include <intuition/intuitionbase.h>
  17. #include <graphics/gfxmacros.h>
  18. #include <hardware/custom.h>
  19. #include <hardware/dmabits.h>
  20. #include <devices/inputevent.h>
  21. #include <devices/input.h>
  22. #include <stdlib.h>
  23. #include <stdio.h>
  24. #include <dos.h>
  25. #include <string.h>
  26. #include <proto/all.h>
  27.  
  28. #define DEUTSCH
  29.  
  30. #include "easymouse.i"
  31.  
  32. extern struct Custom far custom;
  33.  
  34. /* HotKeys + Qualifier Keys */
  35.  
  36. #define LEFT  (0x4f | 0x80)
  37. #define RIGHT (0x4e | 0x80)
  38. #define UP    (0x4c | 0x80)
  39. #define DOWN  (0x4d | 0x80)
  40. #define Q     (0x10 | 0x80)
  41. #define F     (0x23 | 0x80)
  42. #define B     (0x35 | 0x80)
  43. #define A     (0x20 | 0x80)
  44. #define MINUS (0x3a | 0x80)
  45. #define KOMMA (0x38 | 0x80)
  46. #define PUNKT (0x39 | 0x80)
  47. #define DEL   (0x46 | 0x80)
  48. #define LSHIFT 0x60
  49. #define RSHIFT 0x61
  50. #define CTRL  0x63
  51. #define LALT  0x64
  52. #define RALT  0x65
  53. #define CAPS  0x62
  54. #define COMMODORE 0x66
  55. #define RAMIGA 0x67
  56.  
  57. /* Konstante Werte */
  58.  
  59. #define MY_QUALIFIER (IEQUALIFIER_LCOMMAND | IEQUALIFIER_LSHIFT)
  60. #define OPTION_NAME "s:EasyMouse.config"
  61.  
  62. /* Struktur mit den veränderbaren Einstellungen des Programmes */
  63.  
  64. struct Options {
  65.   WORD            MinMem, MouseDelay, ScreenDelay, MouseAccel,
  66.                   MouseTresh, FrontClicks, WindowX, WindowY;
  67.   BOOL            Flag_Click2Back, Flag_CollectQuals, Flag_AutoActivate, Flag_ClockFront,
  68.                   Out_Time, Out_Mem, Out_Chip, Out_Fast;
  69. }               Options =
  70. {
  71.   1, 4, 5, 3, 2, 1, 0, 0, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  72. };
  73.  
  74. LONG            MouseDelay[] =
  75. {0x7fffffff, 1, 2, 3, 5, 10, 15, 30, 60};
  76. LONG            ScreenDelay[] =
  77. {0x7fffffff, 30, 60, 120, 180, 300, 600, 900, 1800};
  78. LONG            MinMem[] =
  79. {25 * 1024, 50 * 1024, 75 * 1024, 100 * 1024, 150 * 1024,
  80.  200 * 1024, 250 * 1024, 500 * 1025, 1024 * 1024};
  81. BOOL            EndIt = FALSE;
  82. char            OutputStr[80];
  83.  
  84. /* Menudefinition */
  85.  
  86. #include "menu.c"
  87.  
  88. /* globale Variablen zur Auswertung einer IntuiMessage */
  89.  
  90. ULONG           class;
  91. USHORT          code, qualifier;
  92. APTR            iaddress;
  93.  
  94. struct IntuitionBase *IntuitionBase;
  95.  
  96. struct DOSLibrary *DOSBase;
  97. struct LayersBase *LayersBase;
  98. extern struct ExecBase *SysBase;
  99. struct Window  *Window;
  100. struct NewWindow NW =
  101. {0, 0, 500, 10, 0, 1, CLOSEWINDOW | MENUPICK, SMART_REFRESH, NULL, NULL,
  102.  (UBYTE *) "EasyMouse V1.0", NULL, NULL, 0, 0, 0, 0, WBENCHSCREEN};
  103. struct Screen  *myscreen;
  104. struct NewScreen NS =
  105. {0, 0, 320, 200, 1, 1, 0, NULL, CUSTOMSCREEN | SCREENQUIET};
  106.  
  107. /* globale Vars */
  108.  
  109. LONG            MouseTimer, ScreenTimer;
  110. struct IOStdReq *InputBlock;
  111.  
  112. /*
  113.  * TestMsg: Testen, ob eine Message da ist und ggf Werte
  114.  * bereitstellen
  115.  */
  116.  
  117. BOOL 
  118. TestMsg(win)
  119.     struct Window  *win;
  120. {
  121.   struct IntuiMessage *msg;
  122.  
  123.   if (msg = (struct IntuiMessage *) GetMsg(win->UserPort)) {
  124.     class = msg->Class;
  125.     code = msg->Code;
  126.     iaddress = msg->IAddress;
  127.  
  128.     ReplyMsg((struct Message *) msg);
  129.     return (TRUE);
  130.   }
  131.   return (FALSE);
  132. }
  133.  
  134. /* GetDeviceBlock: Device-Block anlegen und initialisieren */
  135.  
  136. void           *
  137. GetDeviceBlock(size)
  138.     ULONG           size;
  139. {
  140.   struct MsgPort *device_port = NULL;
  141.   APTR            device_request = NULL;
  142.  
  143.   device_port = (struct MsgPort *) CreatePort(0L, 0L);
  144.   if (device_port == 0L)
  145.     return (NULL);
  146.   device_request = (APTR) CreateExtIO(device_port, size);
  147.   if (device_request == 0L) {
  148.     DeletePort(device_port);
  149.     return (NULL);
  150.   }
  151.   return (device_request);
  152. }
  153.  
  154. /* FreeDeviceBlock: Device-Block freigeben                           */
  155.  
  156. void 
  157. FreeDeviceBlock(iorequest)
  158.     struct IORequest *iorequest;
  159. {
  160.   if (iorequest != 0L) {
  161.     if (iorequest->io_Message.mn_ReplyPort != 0L)
  162.       DeletePort(iorequest->io_Message.mn_ReplyPort);
  163.     DeleteExtIO(iorequest);
  164.   }
  165. }
  166.  
  167. /* Open_A_Device: Device öffnen                                    */
  168.  
  169. BOOL 
  170. Open_A_Device(name, unit, device_request, flags, size)
  171.     char           *name;
  172.     ULONG           unit;
  173.     struct IORequest **device_request;
  174.     ULONG           flags, size;
  175. {
  176.   UWORD           error;
  177.  
  178.   if (size != 0L)
  179.     if (!(*device_request = GetDeviceBlock(size)))
  180.       return (FALSE);
  181.   error = OpenDevice(name, unit, *device_request, flags);
  182.   if (error != 0L) {
  183.     return (FALSE);
  184.   }
  185.   return (TRUE);
  186. }
  187.  
  188. /* Close_A_Device: Device schließen und Device-Block freigeben      */
  189.  
  190. void 
  191. Close_A_Device(iorequest)
  192.     struct IORequest *iorequest;
  193. {
  194.   if (iorequest != 0L) {
  195.     if (iorequest->io_Message.mn_ReplyPort != 0L)
  196.       DeletePort(iorequest->io_Message.mn_ReplyPort);
  197.     if (iorequest->io_Device != 0L)
  198.       CloseDevice(iorequest);
  199.     DeleteExtIO(iorequest);
  200.   }
  201. }
  202.  
  203. /* Do_Command: Device-Kommando ausführen                        */
  204.  
  205. void 
  206. Do_Command(deviceblock, command)
  207.     struct IORequest *deviceblock;
  208.     UWORD           command;
  209. {
  210.   deviceblock->io_Command = command;
  211.   DoIO(deviceblock);
  212. }
  213.  
  214. struct Interrupt Input_Handler;
  215.  
  216. /* Input_AddHandler: Eigene C-Routine in Input-Handler einbinden             */
  217.  
  218. void 
  219. Input_AddHandler(ireq, handler, data)
  220.     struct IOStdReq *ireq;
  221.     void           *handler;
  222.     APTR            data;
  223. {
  224.   Input_Handler.is_Data = data;
  225.   Input_Handler.is_Code = handler;
  226.   Input_Handler.is_Node.ln_Pri = 51;
  227.   ireq->io_Data = (APTR) & Input_Handler;
  228.   Do_Command(ireq, (UWORD) IND_ADDHANDLER);
  229. }
  230.  
  231. /* Input_RemHandler: Input-Handler ausschalten                               */
  232.  
  233. void 
  234. Input_RemHandler(ireq)
  235.     struct IOStdReq *ireq;
  236. {
  237.   ireq->io_Data = (APTR) & Input_Handler;
  238.   Do_Command(ireq, (UWORD) IND_REMHANDLER);
  239. }
  240.  
  241. /* CloseAll: Alles ordnungsgemäß schließen                                     */
  242.  
  243. void 
  244. CloseAll(str)
  245.     register char  *str;
  246. {
  247.   char            buffer[80];
  248.  
  249.   if (str) {
  250.     if (IntuitionBase) {
  251.       strcpy(buffer + 3, str);
  252.       buffer[0] = 0;
  253.       buffer[1] = 40;
  254.       buffer[2] = 20;
  255.       DisplayAlert(RECOVERY_ALERT, buffer, 50L);
  256.     } else
  257.       puts(str);
  258.   }
  259.   if (InputBlock) {
  260.     Input_RemHandler(InputBlock);
  261.     Close_A_Device(InputBlock);
  262.   }
  263.   if (Window) {
  264.     ClearMenuStrip(Window);
  265.     CloseWindow(Window);
  266.   }
  267.   if (GfxBase)
  268.     CloseLibrary(GfxBase);
  269.   if (LayersBase)
  270.     CloseLibrary(LayersBase);
  271.   if (DOSBase)
  272.     CloseLibrary(DOSBase);
  273.   if (IntuitionBase)
  274.     CloseLibrary((struct Library *) IntuitionBase);
  275.   Exit(TRUE);
  276. }
  277.  
  278. /* Optionen im Menu einstellen */
  279.  
  280. void 
  281. SetOptions()
  282. {
  283.   MinMemSub[8 - Options.MinMem].Flags |= CHECKED;
  284.   MouseDelaySub[8 - Options.MouseDelay].Flags |= CHECKED;
  285.   ScreenDelaySub[8 - Options.ScreenDelay].Flags |= CHECKED;
  286.   MouseAccelSub[8 - Options.MouseAccel].Flags |= CHECKED;
  287.   MouseTreshSub[8 - Options.MouseTresh].Flags |= CHECKED;
  288.   FrontClicksSub[2 - Options.FrontClicks].Flags |= CHECKED;
  289.   if (Options.Flag_Click2Back)
  290.     Click2BackItem.Flags |= CHECKED;
  291.   if (Options.Flag_CollectQuals)
  292.     CollectQualsItem.Flags |= CHECKED;
  293.   if (Options.Flag_AutoActivate)
  294.     AutoActivateItem.Flags |= CHECKED;
  295.   if (Options.Flag_ClockFront)
  296.     ClockFrontItem.Flags |= CHECKED;
  297.   if (Options.Out_Time)
  298.     TimeSub.Flags |= CHECKED;
  299.   if (Options.Out_Mem)
  300.     MemSub.Flags |= CHECKED;
  301.   if (Options.Out_Chip)
  302.     ChipSub.Flags |= CHECKED;
  303.   if (Options.Out_Fast)
  304.     FastSub.Flags |= CHECKED;
  305. }
  306.  
  307. /* Fenster schließen, an Werte aus Options anpassen und wieder öffnen */
  308.  
  309. void 
  310. SetWindow()
  311. {
  312.   if (Window) {
  313.     Options.WindowX = Window->LeftEdge;
  314.     Options.WindowY = Window->TopEdge;
  315.     ClearMenuStrip(Window);
  316.     CloseWindow(Window);
  317.   }
  318.   NW.LeftEdge = Options.WindowX;
  319.   NW.TopEdge = Options.WindowY;
  320.   NW.Width = 38;
  321.   if (Options.Out_Time)
  322.     NW.Width += 15 * 8;
  323.   if (Options.Out_Mem)
  324.     NW.Width += 17 * 8;
  325.   if (Options.Out_Chip)
  326.     NW.Width += 13 * 8;
  327.   if (Options.Out_Fast)
  328.     NW.Width += 13 * 8;
  329.   NW.Width = max(NW.Width, 142);
  330.   NW.Flags = WINDOWCLOSE | WINDOWDRAG | SMART_REFRESH;
  331.   if (!Options.Flag_ClockFront) {
  332.     NW.Flags |= WINDOWDEPTH;
  333.     NW.Width += 52;
  334.   }
  335.   if (!(Window = OpenWindow(&NW)))
  336. #ifdef DEUTSCH
  337.     CloseAll("EasyMouse kann kein Fenster öffnen !!!");
  338. #else
  339.     CloseAll("Unable to open window\n");
  340. #endif
  341.   SetMenuStrip(Window, &Menu1);
  342. }
  343.  
  344. /* Window unter der Maus ermitteln */
  345.  
  346. struct Window  *
  347. MouseWindow()
  348. {
  349.   SHORT           x, y;
  350.   struct Layer_Info *li;
  351.   struct Layer   *l;
  352.  
  353.   li = &IntuitionBase->FirstScreen->LayerInfo;
  354.   x = IntuitionBase->FirstScreen->MouseX;
  355.   y = IntuitionBase->FirstScreen->MouseY;
  356.   l = WhichLayer(li, (LONG) x, (LONG) y);
  357.   return ((struct Window *) l->Window);
  358. }
  359.  
  360. /* Bildschirm ein- und ausschalten */
  361.  
  362. void 
  363. BlackScreen()
  364. {
  365.   if (myscreen == 0) {
  366.     myscreen = OpenScreen(&NS);
  367.     SetRGB4(&(myscreen->ViewPort), 0, 0, 0, 0);
  368.   }
  369.   OFF_DISPLAY
  370.     OFF_SPRITE
  371. }
  372.  
  373. void 
  374. NormalScreen()
  375. {
  376.   ON_DISPLAY
  377.   if (myscreen)
  378.     CloseScreen(myscreen);
  379.   myscreen = 0;
  380. }
  381.  
  382. /* IHandler: Input-Handler */
  383.  
  384. struct InputEvent *__saveds __interrupt 
  385. IHandler()
  386. {
  387.   struct InputEvent *masterevent = (struct InputEvent *) getreg(REG_A0), **event = &masterevent;
  388.   static ULONG    extraquals;
  389.   static LONG     nmics, nsecs, omics, osecs;
  390.   struct Window  *w = MouseWindow();
  391.   struct Screen  *s = IntuitionBase->FirstScreen;
  392.   ULONG           ilock = LockIBase(0);
  393.  
  394.   while (*event) {
  395.     USHORT          iecode = (*event)->ie_Code, iequal = (*event)->ie_Qualifier, ieclass = (*event)->ie_Class;
  396.     static USHORT   lastcode;
  397.     BOOL            deleteevent = FALSE;
  398.  
  399.     switch (ieclass) {
  400.     case IECLASS_RAWKEY:
  401.  
  402.       if (iecode >= 0x80) {
  403.     if (iecode == lastcode | 0x80) {
  404.       deleteevent = TRUE;
  405.       lastcode = 0;
  406.     }
  407.       } else {
  408.     ScreenTimer = ScreenDelay[Options.ScreenDelay];
  409.     if (Options.Flag_CollectQuals) {
  410.       if (iecode >= LSHIFT && iecode <= RAMIGA) {
  411.         lastcode = iecode;
  412.         deleteevent = TRUE;
  413.         switch (iecode) {
  414.         case LSHIFT:
  415.           extraquals |= IEQUALIFIER_LSHIFT;
  416.           break;
  417.         case RSHIFT:
  418.           extraquals |= IEQUALIFIER_RSHIFT;
  419.           break;
  420.         case CTRL:
  421.           extraquals |= IEQUALIFIER_CONTROL;
  422.           break;
  423.         case LALT:
  424.           extraquals |= IEQUALIFIER_LALT;
  425.           break;
  426.         case RALT:
  427.           extraquals |= IEQUALIFIER_RALT;
  428.           break;
  429.         case COMMODORE:
  430.           extraquals |= IEQUALIFIER_LCOMMAND;
  431.           break;
  432.         case RAMIGA:
  433.           extraquals |= IEQUALIFIER_RCOMMAND;
  434.           break;
  435.         default:
  436.           lastcode = 0;
  437.           deleteevent = FALSE;
  438.           extraquals = NULL;
  439.           break;
  440.         }
  441.       } else {
  442.         iequal |= extraquals;
  443.         (*event)->ie_Qualifier |= extraquals;
  444.         extraquals = 0;
  445.       }
  446.     }
  447.       }
  448.  
  449.       if ((iequal & MY_QUALIFIER) == MY_QUALIFIER) {
  450.     deleteevent = TRUE;
  451.     switch (iecode) {
  452.     case LEFT:
  453.       MoveWindow(w, -w->LeftEdge, 0);
  454.       break;
  455.     case RIGHT:
  456.       MoveWindow(w, s->Width - w->LeftEdge - w->Width, 0);
  457.       break;
  458.     case UP:
  459.       MoveWindow(w, 0, -w->TopEdge);
  460.       break;
  461.     case DOWN:
  462.       MoveWindow(w, 0, s->Height - w->TopEdge - w->Height);
  463.       break;
  464.     case F:
  465.       if (!(w->Flags & BACKDROP))
  466.         WindowToFront(w);
  467.       break;
  468.     case B:
  469.       WindowToBack(w);
  470.       break;
  471.     case A:
  472.       if (w = MouseWindow())
  473.         ActivateWindow(w);
  474.       break;
  475.     case Q:
  476.       EndIt = TRUE;
  477.       break;
  478.     case MINUS:
  479.       ScreenToBack(s);
  480.       break;
  481.     case KOMMA:
  482.       if (w->Flags & WINDOWSIZING)
  483.         SizeWindow(w, w->MinWidth - w->Width,
  484.                w->MinHeight - w->Height);
  485.       break;
  486.     case PUNKT:
  487.       if (w->Flags & WINDOWSIZING)
  488.         SizeWindow(w,
  489.                min(w->MaxWidth - w->Width,
  490.                s->Width - w->Width -
  491.                w->LeftEdge),
  492.                min(w->MaxHeight - w->Height,
  493.                s->Height - w->Height -
  494.                w->TopEdge));
  495.       break;
  496.     case DEL:
  497.       MouseTimer = ScreenTimer = 0;
  498.     }                   /* switch */
  499.       }                       /* if */
  500.       break;
  501.  
  502.       /* Bei Mausbewegung Maus einschalten und Maustimer zurücksetzen */
  503.       /* evtl. ClickToFront/Back oder SunMouse + beschleunigen        */
  504.     case IECLASS_RAWMOUSE:
  505.       MouseTimer = MouseDelay[Options.MouseDelay];
  506.       ScreenTimer = ScreenDelay[Options.ScreenDelay];
  507.       switch (iecode) {
  508.       case IECODE_RBUTTON:
  509.     if ((iequal & IEQUALIFIER_LEFTBUTTON) && Options.Flag_Click2Back)
  510.       if (w)
  511.         WindowToBack(w);
  512.     break;
  513.       case IECODE_LBUTTON:
  514.     if (w)
  515.       switch (Options.FrontClicks) {
  516.       case 1:
  517.         if (!(w->Flags & BACKDROP))
  518.           WindowToFront(w);
  519.         break;
  520.       case 2:
  521.         osecs = nsecs;
  522.         omics = nmics;
  523.         CurrentTime(&nsecs, &nmics);
  524.         if (DoubleClick(osecs, omics, nsecs, nmics))
  525.           if (!(w->Flags & BACKDROP))
  526.         WindowToFront(w);
  527.       }                   /* switch */
  528.     break;
  529.       case IECODE_NOBUTTON:
  530.     if ((abs((*event)->ie_X) > Options.MouseTresh) ||
  531.         (abs((*event)->ie_Y) > Options.MouseTresh)) {
  532.       (*event)->ie_X *= Options.MouseAccel;
  533.       (*event)->ie_Y *= Options.MouseAccel;
  534.     }                   /* if */
  535.     if (Options.Flag_AutoActivate)
  536.       if (!(iequal & IEQUALIFIER_LEFTBUTTON))
  537.         if (w != IntuitionBase->ActiveWindow)
  538.           ActivateWindow(w);
  539.       }                       /* switch */
  540.       break;
  541.  
  542.     case IECLASS_TIMER:
  543.       if (((*event)->ie_TimeStamp.tv_micro % 10) == 0) {
  544.     MouseTimer--;
  545.     ScreenTimer--;
  546.       }                       /* if */
  547.     }                       /* switch */
  548.     if (ScreenTimer <= 0)
  549.       BlackScreen();
  550.     else
  551.       NormalScreen();
  552.     if (MouseTimer <= 0)
  553.       OFF_SPRITE
  554.       else
  555.                       ON_SPRITE
  556.       if              (deleteevent)
  557.                    *event = (*event)->ie_NextEvent;
  558.       else
  559.     event = &((*event)->ie_NextEvent);
  560.   }                       /* while */
  561.   UnlockIBase(ilock);
  562.   return (masterevent);
  563. }                       /* function */
  564.  
  565. /* OpenAll: Alles ordnungsgemäß öffnen */
  566.  
  567. void 
  568. OpenAll()
  569. {
  570.   BPTR            fh;
  571.  
  572.   if (!(IntuitionBase = (struct IntuitionBase *)
  573.     OpenLibrary("intuition.library", 0L)))
  574. #ifdef DEUTSCH
  575.     CloseAll("Intuition.Library kann nicht geöffnet werden !!!");
  576. #else
  577.     CloseAll("Unable to open intuition.library\n");
  578. #endif
  579.   if (!(DOSBase = (struct DOSLibrary *) OpenLibrary("dos.library", 0)))
  580. #ifdef DEUTSCH
  581.     CloseAll("Dos.Library kann nicht geöffnet werden !!!");
  582. #else
  583.     CloseAll("Unable to open dos.library\n");
  584. #endif
  585.   if (!(LayersBase = (struct LayersBase *) OpenLibrary("layers.library", 0)))
  586. #ifdef DEUTSCH
  587.     CloseAll("Layers.Library kann nicht geöffnet werden !!!");
  588. #else
  589.     CloseAll("Unable to open layers.library\n");
  590. #endif
  591.   if (!(GfxBase = (struct GfxBase *) OpenLibrary("graphics.library", 0)))
  592. #ifdef DEUTSCH
  593.     CloseAll("Graphics.Library kann nicht geöffnet werden !!!");
  594. #else
  595.     CloseAll("Unable to open graphics.library\n");
  596. #endif
  597.   if (fh = Open(OPTION_NAME, MODE_OLDFILE)) {
  598.     Read(fh, (char *) &Options, sizeof(Options));
  599.     Close(fh);
  600.   }
  601.   SetOptions();
  602.   SetWindow();
  603.   if (!(Open_A_Device("input.device", 0L, &InputBlock, 0L, sizeof(*InputBlock))))
  604. #ifdef DEUTSCH
  605.     CloseAll("Input.Device kann nicht geöffnet werden !!!");
  606. #else
  607.     CloseAll("Unable to open input.device\n");
  608. #endif
  609.   Input_AddHandler(InputBlock, IHandler, NULL);
  610. }
  611.  
  612. /*
  613.  * Main: Hauptprogramm,Menüabfrage,Update von Uhr- und
  614.  * Speicheranzeige
  615.  */
  616.  
  617. void 
  618. main(argc, argv)
  619.     int             argc;
  620.     char          **argv;
  621. {
  622.   LONG            fast, chipmem, mem;
  623.   BPTR            fh;
  624.  
  625.   OpenAll();
  626.   MouseTimer = MouseDelay[Options.MouseDelay];
  627.   ScreenTimer = ScreenDelay[Options.ScreenDelay];
  628.   FOREVER
  629.   {
  630.     struct Window  *w = IntuitionBase->ActiveWindow;
  631.     struct Screen  *s = IntuitionBase->FirstScreen;
  632.     char            buffer[40];
  633.  
  634.     if (EndIt)
  635.       CloseAll(NULL);
  636.     Delay(50);
  637.     if (Options.Flag_ClockFront)
  638.       UpfrontLayer(&Window->WScreen->LayerInfo, Window->WLayer);
  639.     fast = AvailMem(MEMF_FAST);
  640.     chipmem = AvailMem(MEMF_CHIP);
  641.     mem = chipmem + fast;
  642.     OutputStr[0] = 0;
  643.     if (Options.Out_Time) {
  644.       long            sec, mic;
  645.       CurrentTime(&sec, &mic);
  646. #ifdef DEUTSCH
  647.       sprintf(buffer, " Zeit %2d:%2d:%2d ", sec / 3600 % 24, sec / 60 % 60, sec % 60);
  648. #else
  649.       sprintf(buffer, " Time %2d:%2d:%2d ", sec / 3600 % 24, sec / 60 % 60, sec % 60);
  650. #endif
  651.       strcat(OutputStr, buffer);
  652.     }
  653.     if (Options.Out_Mem) {
  654. #ifdef DEUTSCH
  655.       sprintf(buffer, " Speicher %-7d", mem);
  656. #else
  657.       sprintf(buffer, " Memory %-7d", mem);
  658. #endif
  659.       strcat(OutputStr, buffer);
  660.     }
  661.     if (Options.Out_Chip) {
  662.       sprintf(buffer, " CHIP %-7d", chipmem);
  663.       strcat(OutputStr, buffer);
  664.     }
  665.     if (Options.Out_Fast) {
  666.       sprintf(buffer, " FAST %-7d ", fast);
  667.       strcat(OutputStr, buffer);
  668.     }
  669.     OutputText.FrontPen = mem < MinMem[Options.MinMem] ? 3 : 1;
  670.     PrintIText(Window->RPort, &OutputText,
  671.            Window->WScreen->ViewPort.Modes & HIRES ? 0 : -14, 0);
  672.     if (TestMsg(Window)) {
  673.       switch (class) {
  674.       case CLOSEWINDOW:
  675.     CloseAll(NULL);
  676.       case MENUPICK:
  677.     switch (MENUNUM(code)) {
  678.     case 0:               /* Aktionen */
  679.       switch (ITEMNUM(code)) {
  680.       case 0:               /* Display off */
  681.         ScreenTimer = 0;
  682.         break;
  683.       case 1:               /* Screen2Back */
  684.         ScreenToBack(s);
  685.         break;
  686.       case 6:               /* Window links */
  687.         WindowToFront(w);
  688.         MoveWindow(w, -w->LeftEdge, 0);
  689.         break;
  690.       case 7:               /* Window rechts */
  691.         WindowToFront(w);
  692.         MoveWindow(w, s->Width - w->LeftEdge - w->Width, 0);
  693.         break;
  694.       case 8:               /* Window oben */
  695.         WindowToFront(w);
  696.         MoveWindow(w, 0, -w->TopEdge);
  697.         break;
  698.       case 9:               /* Window unten */
  699.         WindowToFront(w);
  700.         MoveWindow(w, 0, s->Height - w->TopEdge - w->Height);
  701.         break;
  702.       case 12:               /* Ende */
  703.         CloseAll(NULL);
  704.       }
  705.       break;
  706.     case 1:               /* Optionen */
  707.       switch (ITEMNUM(code)) {
  708.       case 1:               /* Number of Clicks-To-Front */
  709.         if ((SUBNUM(code) >= 0) && (SUBNUM(code) <= 2))
  710.           Options.FrontClicks = SUBNUM(code);
  711.         break;
  712.       case 4:               /* Mindestspeicher */
  713.         if ((SUBNUM(code) >= 0) && (SUBNUM(code) <= 8))
  714.           Options.MinMem = SUBNUM(code);
  715.         break;
  716.       case 5:               /* Anzeige */
  717.         Options.Out_Time = TimeSub.Flags & CHECKED;
  718.         Options.Out_Mem = MemSub.Flags & CHECKED;
  719.         Options.Out_Chip = ChipSub.Flags & CHECKED;
  720.         Options.Out_Fast = FastSub.Flags & CHECKED;
  721.         break;
  722.       case 6:               /* ScreenBlank */
  723.         if ((SUBNUM(code) >= 0) && (SUBNUM(code) <= 8))
  724.           Options.ScreenDelay = SUBNUM(code);
  725.         break;
  726.       case 7:               /* N]ouseBlank */
  727.         if ((SUBNUM(code) >= 0) && (SUBNUM(code) <= 8))
  728.           Options.MouseDelay = SUBNUM(code);
  729.         break;
  730.       case 8:               /* Mouse-Acceleration */
  731.         if ((SUBNUM(code) >= 0) && (SUBNUM(code) <= 8))
  732.           Options.MouseAccel = SUBNUM(code) + 1;
  733.         break;
  734.       case 9:               /* Mouse-Acceleration-Treshhold
  735.                         *  */
  736.         if ((SUBNUM(code) >= 0) && (SUBNUM(code) <= 8))
  737.           Options.MouseTresh = SUBNUM(code);
  738.         break;
  739.       case 11:               /* Save Options */
  740.         if (fh = Open(OPTION_NAME, MODE_NEWFILE)) {
  741.           Options.WindowX = Window->LeftEdge;
  742.           Options.WindowY = Window->TopEdge;
  743.           Write(fh, (char *) &Options, sizeof(Options));
  744.           Close(fh);
  745.         } else
  746.           DisplayBeep(NULL);
  747.       }
  748.       Options.Flag_Click2Back = Click2BackItem.Flags & CHECKED;
  749.       Options.Flag_CollectQuals = CollectQualsItem.Flags & CHECKED;
  750.       Options.Flag_AutoActivate = AutoActivateItem.Flags & CHECKED;
  751.       Options.Flag_ClockFront = ClockFrontItem.Flags & CHECKED;
  752.       SetWindow();
  753.       break;
  754.     }
  755.     break;
  756.       }
  757.     }
  758.   }
  759. }
  760.