home *** CD-ROM | disk | FTP | other *** search
/ Gold Fish 3 / goldfish_volume_3.bin / files / fish / disks / d1115.lha / Programs / CX / Quelltext / CXCommodity.mod < prev    next >
Encoding:
Modula Implementation  |  1995-07-11  |  9.2 KB  |  335 lines
  1. IMPLEMENTATION MODULE CXCommodity;
  2.  
  3.    (* CXCommodity.mod - Brokerroutinen
  4.     * Version     : $VER: CXCommodity.mod 2.3 (© 1995 Fin Schuppenhauer)
  5.     * Autor       : Fin Schuppenhauer
  6.     *               Braußpark 10
  7.     *               20537 Hamburg
  8.     *               (Germany)
  9.     * E-Mail      : 1schuppe@informatik.uni-hamburg.de
  10.     * Erstellt am : 28 Jan 1995
  11.     * Letzte Änd. : 11 Jul 1995
  12.     *)
  13.  
  14.     (*$ DEFINE DEBUG:=FALSE *)
  15.  
  16. IMPORT
  17.     ed:ExecD, el:ExecL, es:ExecSupport,
  18.     cd:CommoditiesD, cl:CommoditiesL, cs:CommoditiesSupport,
  19.     ll:LocaleL,
  20.     String,
  21.     cp:CommoditiesPrivate,
  22.     lan:ListsAndNodes,
  23.     cxl:CXLokal,
  24.     cxw:CXWindow,
  25.     cxf:CXFileIO;
  26.  
  27. (*$ IF DEBUG *)
  28.     IMPORT io:InOut;
  29. (*$ ENDIF *)
  30.  
  31. FROM SYSTEM IMPORT
  32.     ADR, ADDRESS, CAST;
  33.  
  34.  
  35.  
  36. CONST
  37.     HOTKEY_DEFAULT = "control alt help";
  38.     EVENT_HOTKEY = 1;
  39.  
  40.     YES = "YES";
  41.     ON = "ON";
  42.  
  43. VAR
  44.     brokerport: ed.MsgPortPtr;
  45.     broker: cd.CxObjPtr;
  46.     hotkey: StrPtr;
  47.  
  48. (* --------------------------------------------------------------- *)
  49.  
  50. PROCEDURE ExtractArguments;
  51. (* Die übergebenen Argumente und Tooltypes auswerten: *)
  52. VAR
  53.     str: StrPtr;
  54. BEGIN
  55.     (*$ IF DEBUG *)
  56.         io.WriteString ("cxc.ExtractArguments...\n");
  57.     (*$ ENDIF *)
  58.  
  59.     WITH arguments DO
  60.         priority := cs.ArgInt(ADR("CX_PRIORITY"), 0);
  61.         hotkey := cs.ArgString(ADR("CX_POPKEY"), ADR(HOTKEY_DEFAULT));
  62.  
  63.         str := cs.ArgString(ADR("CX_POPUP"), ADR(YES));
  64.         popup := String.Compare(str^, YES) = 0;
  65.     END;
  66. END ExtractArguments;
  67.  
  68. (* --------------------------------------------------------------- *)
  69.  
  70. PROCEDURE InitBroker (): BOOLEAN;
  71. (* Richtet mein Exchange-Commodity ein. *)
  72. VAR
  73.     newbroker: cd.NewBroker;
  74.     error: LONGCARD;
  75.     filter: cd.CxObjPtr;      
  76.  
  77.     bool: BOOLEAN;
  78.     str: StrPtr;     
  79.     success : BOOLEAN;
  80. BEGIN
  81.     (*$ IF DEBUG *)
  82.         io.WriteString ("cxc.InitBroker...\n");
  83.     (*$ ENDIF *)
  84.  
  85.     (* Zunächst muß ein Message-Port für unser Commodity ein-
  86.      * gerichtet werden:
  87.      *)
  88.     success := FALSE;
  89.     brokerport := el.CreateMsgPort();
  90.     IF brokerport # NIL THEN
  91.         (* Na prima, das hat geklappt. Jetzt initialisieren wir
  92.          * unseren Broker (sozusagen den Chef unseres Commodities):
  93.          *)
  94.         WITH newbroker DO
  95.             version := cd.nbVersion;
  96.                 (* Der Name MUSS "Exchange" sein, da wir sonst bestimmte
  97.                  * Nachrichten (nämlich wenn sich was an den Commodities
  98.                  * verändert hat) bekommen.
  99.                  *)
  100.             name := ADR("Exchange");
  101.             title := ADR("CX V2.3 © 1994/5 Fin Schuppenhauer");
  102.             descr := ll.GetCatalogStr(cxw.catalog, cxl.BROKERDESCR, ADR(cxl.BROKERDESCRSTR));;
  103.             unique := cd.UniqueFlagSet{cd.unique, cd.notify};
  104.             flags := cd.NewBrokerFlagSet{cd.showHide};
  105.             pri := arguments.priority;
  106.             port := brokerport;
  107.         END;
  108.         broker := cl.CxBroker(newbroker, error);
  109.  
  110.         IF error = cd.cberrOk THEN                              
  111.             (* Wunderbar. Da unser Commodity über einen Hotkey auch
  112.              * erscheinen soll, basteln wir uns das entsprechende
  113.              * CxObj dazu:
  114.              *)
  115.             hotkey := arguments.hotkey;
  116.             filter := cs.HotKey(hotkey, brokerport, EVENT_HOTKEY);
  117.  
  118.             IF filter # NIL THEN
  119.                 cl.AttachCxObj (broker, filter);
  120.                 (* Wir wollen die dafür notwendige Tastaturkombination
  121.                  * auch im Fenstertitel anzeigen (ein Teil des Fenster-
  122.                  * titels wurde bereits in CXWindow.mod definiert):
  123.                  *)
  124.                 String.Concat (cxw.wintitle, " <");
  125.                 String.Concat (cxw.wintitle, hotkey^);
  126.                 String.ConcatChar (cxw.wintitle, ">");
  127.             END;
  128.  
  129.             (* Jetzt ermitteln wir noch schnell das Signal
  130.              * für unseren Wait-Aufruf in CX.mod ...
  131.              *)
  132.             brokersignal := brokerport^.sigBit;
  133.             (* ... und aktivieren unseren Broker: *)
  134.             bool := cl.ActivateCxObj(broker, TRUE);
  135.                
  136.             (* Falls gewünscht, öffnen wir noch schnell unser
  137.              * Fenster:
  138.              *)
  139.             IF arguments.popup THEN
  140.                 cxw.ShowWindow;
  141.             END;
  142.             success := TRUE;
  143.         END;
  144.     END;      
  145.     RETURN success;
  146. END InitBroker;
  147.  
  148. PROCEDURE FreeBroker;
  149. BEGIN
  150.     (*$ IF DEBUG *)
  151.         io.WriteString ("cxc.FreeBroker()\n");
  152.     (*$ ENDIF *)
  153.     cl.DeleteCxObjAll(broker);
  154.     el.DeleteMsgPort (brokerport);
  155.     brokerport := NIL;
  156. END FreeBroker;
  157.  
  158. (* --------------------------------------------------------------- *)
  159.  
  160. PROCEDURE InitBrokerList (VAR count: INTEGER);
  161. (* Rückgabewerte:
  162.  *      list    : ListPtr auf die sortierte Liste der Broker
  163.  *      count   : Anzahl der Broker in der Liste
  164.  *)
  165. VAR
  166.     li: LONGINT;
  167.     node: ed.NodePtr;
  168. BEGIN
  169.     (*$ IF DEBUG *)
  170.         io.WriteString ("cxc.InitBrokerList (");
  171.         io.WriteInt (count,0); io.WriteString (") => ");
  172.     (*$ ENDIF *)
  173.  
  174.     count := 0;
  175.     brokerlist := el.AllocMem(SIZE(ed.List), ed.MemReqSet{ed.public});
  176.     IF brokerlist # NIL THEN
  177.         es.NewList (brokerlist);
  178.         li := cp.CopyBrokerList (brokerlist);
  179.         lan.SortExecList(brokerlist, lan.ALLNODES);
  180.         count := INTEGER(lan.CountNodes(brokerlist));
  181.     END;
  182.     (*$ IF DEBUG *)
  183.         io.WriteInt (count,0); io.WriteLn;
  184.     (*$ ENDIF *)
  185. END InitBrokerList;
  186.  
  187. PROCEDURE FreeBrokerList;
  188. VAR
  189.     count: LONGINT;
  190. BEGIN
  191.     (*$ IF DEBUG *)
  192.         io.WriteString ("cxc.FreeBrokerList()\n");
  193.     (*$ ENDIF *)
  194.  
  195.     IF brokerlist # NIL THEN
  196.         count := cp.FreeBrokerList(brokerlist);
  197.         el.FreeMem (brokerlist, SIZE(ed.List));
  198.         brokerlist := NIL;
  199.     END;
  200. END FreeBrokerList;
  201.  
  202. (* --------------------------------------------------------------- *)
  203.  
  204. PROCEDURE GetBrokerCopy (num: INTEGER) : cp.BrokerCopyPtr;
  205. VAR
  206.     node: ed.NodePtr;
  207.     i: INTEGER;
  208. BEGIN
  209.     (*$ IF DEBUG *)
  210.         io.WriteString ("cxc.GetBrokerCopy...\n");
  211.     (*$ ENDIF *)
  212.  
  213.     node := brokerlist^.head;
  214.     FOR i := 1 TO num DO
  215.         node := node^.succ;
  216.     END;
  217.     RETURN CAST(cp.BrokerCopyPtr, node);
  218. END GetBrokerCopy;
  219.  
  220. PROCEDURE GetBrokerCopyByName (name: StrPtr) : cp.BrokerCopyPtr;
  221. (* Wird von CXARexx.mod aufgerufen. *)
  222. VAR
  223.     node: ed.NodePtr;
  224. BEGIN
  225.     (*$ IF DEBUG *)
  226.         io.WriteString ("cxc.GetBrokerCopyByName...\n");
  227.     (*$ ENDIF *)
  228.  
  229.     node := brokerlist^.head;
  230.     WHILE node # NIL DO
  231.         IF String.Compare(CAST(cp.BrokerCopyPtr, node)^.name, name^) = 0 THEN
  232.             RETURN CAST(cp.BrokerCopyPtr, node);
  233.         ELSE
  234.             node := node^.succ;
  235.         END;
  236.     END;
  237.     RETURN NIL;
  238. END GetBrokerCopyByName;
  239.  
  240. PROCEDURE SendBrokerCommand (num: INTEGER; cmd: LONGCARD);
  241. VAR
  242.     bc: cp.BrokerCopyPtr;
  243.     li: LONGINT;
  244. BEGIN
  245.     (*$ IF DEBUG *)
  246.        io.WriteString ("cxc.SendBrokerCommand(");
  247.        io.WriteInt (num,0); io.Write (","); io.WriteCard(cmd,0);
  248.        io.WriteString (")\n");
  249.     (*$ ENDIF *)
  250.  
  251.     bc := GetBrokerCopy(num);
  252.     IF cmd = activeToggle THEN
  253.         IF cp.active IN bc^.flags THEN
  254.             cmd := cd.cxcmdDisable;
  255.         ELSE
  256.             cmd := cd.cxcmdEnable;
  257.         END;
  258.     END;
  259.     li := cp.BrokerCommand (ADR(bc^.name), cmd);
  260. END SendBrokerCommand;
  261.  
  262. PROCEDURE SendAllBrokerCommand (cmd: LONGCARD);
  263. (* Der Broker-Befehl "cmd" wird an alle Broker verschickt: *)
  264. VAR
  265.     bc: cp.BrokerCopyPtr;
  266.     li: LONGINT;
  267. BEGIN
  268.     (*$ IF DEBUG *)
  269.         io.WriteString ("cxc.SendAllBrokerCommand...\n");
  270.     (*$ ENDIF *)
  271.  
  272.     bc := CAST(cp.BrokerCopyPtr, brokerlist^.head);
  273.     WHILE bc # NIL DO
  274.         li := cp.BrokerCommand (ADR(bc^.name), cmd);
  275.         bc := CAST(cp.BrokerCopyPtr, bc^.node.succ);
  276.     END;
  277. END SendAllBrokerCommand;
  278.  
  279. (* --------------------------------------------------------------- *)
  280.  
  281. PROCEDURE HandleBrokerMsg (VAR done: BOOLEAN);
  282. VAR
  283.     msg: cd.CxMsgPtr;
  284.     msgid: LONGINT;
  285.     msgtype: LONGCARD;
  286.     bool: BOOLEAN;
  287. BEGIN
  288.     (*$ IF DEBUG *)
  289.         io.WriteString ("cxc.HandleBrokerMsg()\n");
  290.     (*$ ENDIF *)
  291.  
  292.     LOOP
  293.         msg := CAST(cd.CxMsgPtr, el.GetMsg (brokerport));
  294.         IF msg = NIL THEN EXIT; END;
  295.         msgid := cl.CxMsgID(msg);
  296.         msgtype := cl.CxMsgType(msg);
  297.         el.ReplyMsg (CAST(ADDRESS,msg));
  298.  
  299.         CASE msgtype OF
  300.             cd.cxmIevent:
  301.             IF msgid = EVENT_HOTKEY THEN
  302.                 (*$ IF DEBUG *)
  303.                     io.WriteString ("- Hotkey\n");
  304.                 (*$ ENDIF *)
  305.                 cxw.ShowWindow;
  306.             END;
  307.           | cd.cxmCommand:
  308.             (*$ IF DEBUG *)
  309.                 io.WriteString ("- cxmCommand = ");
  310.                 io.WriteCard (msgid,0); io.WriteLn;
  311.             (*$ ENDIF *)
  312.             CASE msgid OF
  313.                 cd.cxcmdDisable: bool := cl.ActivateCxObj (broker, FALSE);
  314.               | cd.cxcmdEnable: bool := cl.ActivateCxObj (broker, TRUE);
  315.               | cd.cxcmdKill: done := TRUE;
  316.               | cd.cxcmdDisappear: cxw.CloseWindow;
  317.               | cd.cxcmdAppear, cd.cxcmdUnique: cxw.ShowWindow;
  318.               | cd.cxcmdListChg: cxw.RefreshListview;
  319.             ELSE
  320.             END;
  321.         ELSE
  322.         END;
  323.     END;
  324. END HandleBrokerMsg;
  325.  
  326. (* --------------------------------------------------------------- *)
  327.  
  328. BEGIN (* main *)
  329.     (*$ IF DEBUG *)
  330.         io.WriteString ("Module CXCommodity loaded...\n");
  331.     (*$ ENDIF *)
  332.  
  333.     ExtractArguments;
  334. END CXCommodity.
  335.