home *** CD-ROM | disk | FTP | other *** search
/ World of A1200 / World_Of_A1200.iso / programs / monitors / rsys / source.lha / src / RSysBroker.c < prev    next >
C/C++ Source or Header  |  1995-01-09  |  11KB  |  396 lines
  1. /*
  2. ***************************************************************************
  3. *
  4. * Datei:
  5. *    RSysBroker.c
  6. *
  7. * Inhalt:
  8. *    void InstallBroker(void);
  9. *    void RemoveBroker(void);
  10. *    struct Screen *FindFrontPubScr(struct Screen *activescr);
  11. *    void HandleBrokerPort(void);
  12. *
  13. * Bemerkungen:
  14. *    Broker-Verwaltungsroutinen unter Verwendung der Commodities-Library.
  15. *
  16. * Erstellungsdatum:
  17. *    07-Jul-93    Rolf Böhme
  18. *
  19. * Änderungen:
  20. *    07-Jul-93    Rolf Böhme    Erstellung
  21. *
  22. ***************************************************************************
  23. */
  24.  
  25. #include "RSysDebug.h"
  26.    /*
  27.     * Die externen Funktionenreferenzen werden eingelesen.
  28.     */
  29. #include "RSysFunc.h"
  30.  
  31.    /*
  32.     * Der Zeiger auf den Brokerport. An diesem liegen
  33.     * die Nachrichten an, die vom Programm Exchange
  34.     * abgesendet werden.
  35.     */
  36. struct MsgPort *broker_mp = NULL;
  37.  
  38.    /*
  39.     * Die "Objekte", die die Eigenschaften der
  40.     * Nachrichten, die an den Broker gesendet werden
  41.     * sollen, festlegen.
  42.     */
  43. CxObj *broker,
  44.      *filter[HOTKEYS],
  45.      *sender,
  46.      *translate;
  47.  
  48.    /*
  49.     * Die Tastenkombinationen, mit denen RSys gesteuert
  50.     * werden kann.
  51.     */
  52. char  hotkey[HOTKEYS][30];
  53.  
  54.    /*
  55.     * In dieser Struktur werden alle Eigenschaften des
  56.     * Brokers definiert. Insbesondere der Name, die
  57.     * Version (systemabhängig), Eindeutigkeit des
  58.     * verwendeten Broker-Namens und ob Show/Hide-
  59.     * Nachrichten empfangen werden sollen.
  60.     */
  61. struct NewBroker newbroker =
  62. {
  63.    NB_VERSION,
  64.    NAME,
  65.    NAME " " VERSION " - " COPYRIGHT,
  66.    "RSys Commodity Handler",
  67.    NBU_UNIQUE,
  68.    COF_SHOW_HIDE,
  69.    0,
  70.    0,
  71.    0
  72. };
  73.  
  74.    /*
  75.     * Ein Zeiger auf den letzten PublicScreen, auf dem
  76.     * das Hauptfenster von RSys geöffnet wurde.
  77.     */
  78. struct Screen *lastpubscreen = NULL;
  79.  
  80.    /*
  81.     * Die Prozedur InstallHotKeys() bildet für alle zu
  82.     * installierenden HotKeys einen Filter und bindet
  83.     * diese dann in die Broker-Struktur ein.
  84.     */
  85. static void
  86. InstallHotKeys(void)
  87. {
  88.    register int i;
  89.  
  90.    for (i = 0; i < HOTKEYS; i++)
  91.    {
  92.       filter[i] = HotKey((UBYTE *) & hotkey[i][0], broker_mp, (long)(i + 1));
  93.          /*
  94.           * Falls kein Filter erzeugt werden konnte, wird eine
  95.           * Fehlermeldung ausgegeben und das Programm beendet.
  96.           */
  97.       if (NOT(filter[i]))
  98.          ErrorHandle(BROKER_ERR, CREATE_FAIL, KILL);
  99.  
  100.       AttachCxObj(broker, filter[i]);
  101.    }
  102.  
  103.    return;
  104. }
  105.  
  106.    /*
  107.     * InstallBroker() öffnet die commodities.library,
  108.     * richtet einen MessagePort für die Nachrichten vom
  109.     * Broker ein, initialisiert ein Broker-
  110.     * Kontrollstruktur und startet den Broker.
  111.     */
  112. void
  113. InstallBroker(void)
  114. {
  115.    DPOS;
  116.       /*
  117.        * Ein Kommunikations-Port wird erzeugt.
  118.        */
  119.    if (broker_mp = CreatePort((UBYTE *) "RSys-Broker-Port", 0L))
  120.    {
  121.       newbroker.nb_Port = broker_mp;
  122.       newbroker.nb_Pri  = 0;
  123.  
  124.          /*
  125.           * Falls der Broker erzeugt werden konnte, werden die
  126.           * HotKeys installiert und der Broker gestartet.
  127.           */
  128.       if (broker = CxBroker(&newbroker, NULL))
  129.          InstallHotKeys();
  130.       else
  131.          ErrorHandle(BROKER_ERR, CREATE_FAIL, KILL);
  132.  
  133.       ActivateCxObj(broker, TRUE);
  134.    }
  135.    else
  136.          /*
  137.           * Das Programm wird beendet, falls kein Messageport
  138.           * eingerichtet werden konnte.
  139.           */
  140.       ErrorHandle(PORT_ERR, CREATE_FAIL, KILL);
  141.  
  142.    return;
  143. }
  144.  
  145.    /*
  146.     * RemoveBroker() entfernt alle mit dem Broker
  147.     * verbundenen Datenstrukturen aus dem System und
  148.     * schließt die commodities.library.
  149.     */
  150. void
  151. RemoveBroker(void)
  152. {
  153.    DPOS;
  154.  
  155.    if (broker)
  156.       DeleteCxObjAll(broker);
  157.  
  158.    if (broker_mp)
  159.       DeletePort(broker_mp);
  160.  
  161.    return;
  162. }
  163.  
  164.    /*
  165.     * Die Funktion FindFrontPunbScr() ermittelt
  166.     * bezüglich des aktuellen Screens, auf dem das
  167.     * Hauptfenster geöffnet wurde, den nächsten Public
  168.     * screen und gibt den Zeiger auf diesen zurück,
  169.     * falls dieser ungleich dem aktuellen und zugleich
  170.     * der vorderste Screen auf dem Bildschirm ist.
  171.     */
  172. struct Screen *
  173. FindFrontPubScr(struct Screen *activescr)
  174. {
  175.    char  newnamebuffer[MAXPUBSCREENNAME + 1];
  176.    UBYTE *test;
  177.    struct Screen *NewScr;
  178.  
  179.    DPOS;
  180.       /*
  181.        * Der Name des aktuellen Screens, auf dem RSys
  182.        * geöffnet wurde, wird gemerkt.
  183.        */
  184.    strncpy(newnamebuffer, (char *)namebuffer,MAXPUBSCREENNAME);
  185.  
  186.       /*
  187.        * Der Zeiger des neuen Screens wird initialisiert
  188.        * und der nächst Public screen ermittelt.
  189.        */
  190.    NewScr = NULL;
  191.    test = NextPubScreen(activescr, namebuffer);
  192.  
  193.       /*
  194.        * Solange der neue Screen nicht der vorderste
  195.        * Screen und nicht der aktuelle ist, und der neue
  196.        * Screen erfolgreich ermittelt werden konnte, wird
  197.        * dieser neue getestet. Im Erfolgsfall wird ein
  198.        * Zeiger auf diesen neuen Screen zurückgegeben.
  199.        */
  200.    while ((NewScr != IntuitionBase->FirstScreen) &&
  201.           (NewScr != activescr) && test)
  202.    {
  203.       NewScr = LockPubScreen(namebuffer);
  204.  
  205.       if ((NewScr == IntuitionBase->FirstScreen) && (NewScr != activescr))
  206.       {
  207.          UnlockPubScreen(NULL, NewScr);
  208.          return (NewScr);
  209.       }
  210.  
  211.       UnlockPubScreen(NULL, NewScr);
  212.  
  213.       test = NextPubScreen(NewScr, namebuffer);
  214.    }
  215.  
  216.       /*
  217.        * Wenn das Unterprogramm bis hierher kommt, konnte
  218.        * kein weiterer Public screen erkannt werden. Der
  219.        * gemerkte Screen name wird zurückkopiert und der
  220.        * Zeiger auf den aktiven Screen zurückgegeben.
  221.        */
  222.    strncpy((char *)namebuffer, newnamebuffer,MAXPUBSCREENNAME);
  223.  
  224.    return (activescr);
  225. }
  226.  
  227.    /*
  228.     * HandleBrokerPort() verarbeitet alle Nachrichten,
  229.     * die am Broker port eintreffen.
  230.     */
  231. void
  232. HandleBrokerPort(void)
  233. {
  234.    CxMsg *msg;
  235.    ULONG msgid,
  236.          msgtype;
  237.    struct Screen *activescr;
  238.       /*
  239.        * Dieses Feld von Funktionenzeigern enthält alle
  240.        * Funktionen, die entsprechend der MessageID
  241.        * ausgeführt werden.
  242.        */
  243.    void  (*func[HOTKEYS - 1]) (void)=
  244.    {CryptFile, FindFile, FormatDisk, HunkStruct,CRCSum,SaveWindows};
  245.  
  246.    DPOS;
  247.       /*
  248.        * Alle Messages, die am Brokerport anliegen, werden
  249.        * bearbeitet.
  250.        */
  251.    while (msg = (CxMsg *) GetMsg(broker_mp))
  252.    {
  253.          /*
  254.           * Aus der Message werden die notwendigen Daten
  255.           * herauskopiert. Danach wird die Nachricht wieder
  256.           * so schnell wie möglich beantwortet, damit der
  257.           * Broker nicht wartet.
  258.           */
  259.       msgid = CxMsgID(msg);
  260.       msgtype = CxMsgType(msg);
  261.  
  262.       ReplyMsg((struct Message *) msg);
  263.  
  264.          /*
  265.           * Entsprechend dem Typ der Nachricht werden
  266.           * verschiedene Aktionen ausgelöst.
  267.           */
  268.       switch (msgtype)
  269.       {
  270.             /*
  271.              * Es handelt sich um einen Inputevent.
  272.              */
  273.          case CXM_IEVENT:
  274.                /*
  275.                 * Ist die MessageID 1, soll das RSys-Hauptfenster
  276.                 * erscheinen.
  277.                 */
  278.             if(msgid == 1)
  279.             {
  280.                   /*
  281.                    * Falls das Hauptfenster bereits offen ist, wird der
  282.                    * nächst Public screen gesucht und versucht, RSys auf
  283.                    * diesem Screen zu öffnen. War das erfolgreich, wird
  284.                    * das ListView des Hauptfensters aktualisiert.
  285.                    */
  286.                if (SysWnd)
  287.                {
  288.                   activescr = SysWnd->WScreen;
  289.  
  290.                   if (activescr != FindFrontPubScr(activescr))
  291.                   {
  292.                      CloseASysWindow(&SysWnd, &SysGList, &SysMenus);
  293.                      CloseDownScreen();
  294.  
  295.                      OpenMainWindow();
  296.                      RefreshList(LastID);
  297.                   }
  298.                   else
  299.                      ErrorHandle(SCREEN_ERR, FIND_FAIL, NO_KILL);
  300.                }
  301.                else
  302.                {
  303.                      /*
  304.                       * Ist das Hauptfenster noch nicht geöffnet, wird es
  305.                       * mit der Standardprozedur geöffnet und das ListView
  306.                       * aktualisiert.
  307.                       */
  308.                   OpenMainWindow();
  309.                   RefreshList(LastID);
  310.                }
  311.             }
  312.             else
  313.             {
  314.                   /*
  315.                    * Ist die MessageID größer als 1, werden die
  316.                    * entsprechenden Funktionen aus dem
  317.                    * Funktionenzeigerfeld ausgeführt.  Ist das
  318.                    * Hauptfenster noch nicht geöffnet worden, muß der
  319.                    * Screen, auf dem das Fenster der jeweiligen
  320.                    * Funktion geöffnet werden soll, mit SetupScreen()
  321.                    * vorbereitet werden.
  322.                    */
  323.                if (NOT(SysWnd))
  324.                   if (SetupScreen())
  325.                      ErrorHandle(SCREEN_ERR, INFO_FAIL, NO_KILL);
  326.  
  327.                (*func[msgid - 2]) ();
  328.  
  329.                if (NOT(SysWnd))
  330.                   CloseDownScreen();
  331.             }
  332.             break;
  333.  
  334.             /*
  335.              * Es sit eine Nachricht vom Programm Exchange.
  336.              */
  337.          case CXM_COMMAND:
  338.             switch (msgid)
  339.             {
  340.                   /*
  341.                    * Der Broker von RSys soll ausgeschaltet werden.
  342.                    */
  343.                case CXCMD_DISABLE:
  344.                   ActivateCxObj(broker, 0L);
  345.                   break;
  346.  
  347.                   /*
  348.                    * Der Broker von RSys soll eingeschaltet werden.
  349.                    */
  350.                case CXCMD_ENABLE:
  351.                   ActivateCxObj(broker, 1L);
  352.                   break;
  353.  
  354.                   /*
  355.                    * Das Hauptfenster von RSys soll erscheinen.
  356.                    */
  357.                case CXCMD_APPEAR:
  358.                   if (NOT(SysWnd))
  359.                   {
  360.                      OpenMainWindow();
  361.                      RefreshList(LastID);
  362.                   }
  363.  
  364.                   break;
  365.  
  366.                   /*
  367.                    * Das Hauptfenster soll verschwinden und das AppIcon
  368.                    * soll erscheinen.
  369.                    */
  370.                case CXCMD_DISAPPEAR:
  371.                   if (SysWnd)
  372.                      Iconify();
  373.                   break;
  374.  
  375.                   /*
  376.                    * RSys soll ohne Sicherheitsabfrage beendet werden.
  377.                    */
  378.                case CXCMD_KILL:
  379.                   quit(FALSE);
  380.                   break;
  381.  
  382.                case CXCMD_UNIQUE:
  383.                      /*
  384.                       * Ein Programm versucht einen Broker mit dem Namen
  385.                       * RSys einzurichten. Es erscheint eine Fehlermeldung.
  386.                       */
  387.                   ErrorHandle(BROKER_ERR, DUPLICATE_FAIL, NO_KILL);
  388.                   break;
  389.             }
  390.             break;
  391.       }
  392.    }
  393.  
  394.    return;
  395. }
  396.