home *** CD-ROM | disk | FTP | other *** search
/ Meeting Pearls 3 / Meeting_Pearls_III.iso / Pearls / texmf / source / driver / show / amiga / swin.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-08-05  |  4.1 KB  |  202 lines
  1. /*
  2.  *  Modul swin.c  (This module is PD)
  3.  *
  4.  *  Aufgabe: Fenster einschlaefern, so dass der Benutzer nichts
  5.  *           mehr mit ihnen anfangen kann.
  6.  *           Dazu bekommt das Fenster einen ZZ-Pointer und einen
  7.  *           unsichtbaren Requester.
  8.  *
  9.  *  Schnittstelle:
  10.  *
  11.  *    void SleepWin(struct Window * win);
  12.  *
  13.  *      Schlaefert Window 'win' ein. Kann auch mit einem NULL Pointer
  14.  *      aufgerufen werden. Auch mehrmaliges Einschlaefern eines
  15.  *      Windows bringt keine Prbleme.
  16.  *      Achtung: Ein Window muss aufgeweckt werden, bevor es geschlossen
  17.  *               wird. Am besten einfach WakeUpWin(win) vor jedem
  18.  *               Window Schliessen aufrufen.
  19.  *
  20.  *
  21.  *    void WakeUpWin(struct Window * win);
  22.  *
  23.  *      Weckt ein Window wieder auf.
  24.  *      Es macht nichts, die Funktion mit NULL, oder aber mit einem
  25.  *      Window aufzurufen, das nicht im eingeschlaeferten Zustand ist.
  26.  *
  27.  *
  28.  *    void WakeUpAll(void);
  29.  *
  30.  *      Weckt alle Windows auf.
  31.  *
  32.  *
  33.  *  Voraussetzungen: Laeuft mit allen Betriebssystemversionen > 1.1 :)
  34.  *
  35.  *
  36.  *  5.Aug.92 Georg Hessmann
  37.  *
  38.  */
  39.  
  40.  
  41.  
  42.  
  43. #include <intuition/intuition.h>
  44. #include <clib/intuition_protos.h>
  45. #include <pragmas/intuition_pragmas.h>
  46.  
  47. #include <exec/memory.h>
  48. #include <clib/exec_protos.h>
  49. #include <pragmas/exec_pragmas.h>
  50.  
  51.  
  52.  
  53.  
  54. /*------  P r o t o t y p e n  --------------*/
  55. void SleepWin(struct Window * win);
  56. void WakeUpWin(struct Window * win);
  57. void WakeUpAll(void);
  58. /*-------------------------------------------*/
  59.  
  60.  
  61.  
  62.  
  63.  
  64.  
  65. extern struct ExecBase        * SysBase;
  66. extern struct IntuitionBase    * IntuitionBase;
  67.  
  68.  
  69. struct SWinLst {
  70.   struct Window        * win;
  71.   struct SWinLst    * prev;
  72.   struct SWinLst    * next;
  73.   struct Requester      req;
  74. };
  75.  
  76. static struct SWinLst * SWLst = NULL;
  77.  
  78. #define SIZE    sizeof(struct SWinLst)
  79.  
  80.  
  81. static UWORD __chip SleepPointerData[] = {
  82.     0x0000, 0x0000,    /* vert. and horiz. start posn. */
  83.     0x0400,    0x07C0,
  84.     0x0000,    0x07C0,
  85.     0x0100,    0x0380,
  86.     0x0000,    0x07E0,
  87.     0x07C0,    0x1FF8,
  88.     0x1FF0,    0x3FEC,
  89.     0x3FF8,    0x7FDE,
  90.     0x3FF8,    0x7FBE,
  91.     0x7FFC,    0xFF7F,
  92.     0x7EFC,    0xFFFF,
  93.     0x7FFC,    0xFFFF,
  94.     0x3FF8,    0x7FFE,
  95.     0x3FF8,    0x7FFE,
  96.     0x1FF0,    0x3FFC,
  97.     0x07C0,    0x1FF8,
  98.     0x0000,    0x07E0,
  99.     0x0000, 0x0000,    /* reserved, must be NULL */
  100. };
  101.  
  102.  
  103. // Prototyp der internen Funktion
  104. static struct SWinLst * FindSWin(struct Window * win);
  105.  
  106.  
  107. static struct SWinLst * FindSWin(struct Window * win)
  108. {
  109.   struct SWinLst * hLst;
  110.   
  111.   for (hLst=SWLst; hLst && hLst->win != win; hLst=hLst->next);
  112.   
  113.   return hLst;
  114. }
  115.  
  116.  
  117.  
  118. /*
  119.  *  Funktion zum Einschlaefern von Windows.
  120.  *
  121.  */
  122.  
  123. void SleepWin(struct Window * win)
  124. {
  125.   struct SWinLst * wLst = FindSWin(win);
  126.   
  127.   if (win && !wLst) {
  128.     // ist nicht schon eingeschlaefert
  129.     wLst = (struct SWinLst *) AllocMem(SIZE, MEMF_PUBLIC|MEMF_CLEAR);
  130.     if (wLst) {
  131.       wLst->win = win;
  132.       if (Request(&wLst->req, win)) {
  133.         SetPointer(win, SleepPointerData, 16, 15, 0, 0);
  134.         // nun wLst in die Liste aufnehmen (wird erstes Element)
  135.         if (SWLst) {
  136.           // wLst vor alle anderen Elemente haengen
  137.           SWLst->prev = wLst;
  138.           wLst->next = SWLst;
  139.           SWLst = wLst;
  140.         }
  141.         else {
  142.           // wLst wird erstes Element der Liste
  143.           SWLst = wLst;
  144.           // wLst->next = NULL; ist ohnehin durch CLEAR auf NULL gesetzt
  145.         }
  146.         // wLst->prev = NULL; ist ueberfluessig, da mit CLEAR allociert
  147.       }
  148.       else {
  149.         // Requester ist nicht aufgegangen, gib speicher frei und aergere Dich
  150.         FreeMem(wLst, SIZE);
  151.       }
  152.     }
  153.   }
  154. }
  155.  
  156.  
  157.  
  158. /*
  159.  *  Funktion zum Aufwecken von Windows.
  160.  *
  161.  */
  162.  
  163. void WakeUpWin(struct Window * win)
  164. {
  165.   struct SWinLst * wLst = FindSWin(win);
  166.   
  167.   if (wLst) {
  168.     // schlaeft tatsaechlich
  169.     ClearPointer(wLst->win);
  170.     EndRequest(&wLst->req, wLst->win);
  171.     if (wLst->prev) {
  172.       // wLst aushaengen. prev mit next verbinden
  173.       struct SWinLst * prev, * next;
  174.       prev = wLst->prev;
  175.       next = wLst->next;
  176.       prev->next = next;
  177.       if (next) next->prev = prev;
  178.     }
  179.     else {
  180.       SWLst = wLst->next;
  181.       if (SWLst) SWLst->prev = NULL;
  182.     }
  183.     FreeMem(wLst, SIZE);
  184.   }
  185. }
  186.  
  187.  
  188. /*
  189.  *  Diese Funktion weckt auf ein Mal alle eingeschlaeferten
  190.  *  Windows auf.
  191.  *
  192.  */
  193.  
  194. void WakeUpAll(void)
  195. {
  196.   while (SWLst) {
  197.     WakeUpWin(SWLst->win);
  198.   }
  199. }
  200.  
  201.  
  202.