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