home *** CD-ROM | disk | FTP | other *** search
/ Amiga ISO Collection / AmigaUtilCD2.iso / Misc / cx22.lha / CX2.2 / Quelltext / CXWindow.mod < prev    next >
Encoding:
Modula Implementation  |  1995-05-29  |  38.4 KB  |  1,132 lines
  1. IMPLEMENTATION MODULE CXWindow;
  2.  
  3.    (* CXWindow.mod - Modul für Layout-Tütelkram
  4.     * Version     : $VER: CXWindow.mod 2.1 (© 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 : 24 Jan 1995
  11.     * Letzte Änd. : 29 Mai 1995
  12.     *)
  13.  
  14.     (*$ DEFINE DEBUG:=FALSE *)
  15.  
  16. IMPORT
  17.     id:IntuitionD, il:IntuitionL, im:IntuiMacros,
  18.     gtd:GadToolsD, gtl:GadToolsL,
  19.     gd:GraphicsD, gl:GraphicsL,
  20.     ed:ExecD, el:ExecL, es:ExecSupport,
  21.     ld:LocaleD, ll:LocaleL,
  22.     iv:InputEvent,
  23.     String,
  24.     ASCII,
  25.     cd:CommoditiesD, cs:CommoditiesSupport, cp:CommoditiesPrivate,
  26.     cxl:CXLokal,
  27.     cxc:CXCommodity,
  28.     cxf:CXFileIO;
  29.  
  30. FROM UtilityD IMPORT
  31.     tagEnd;
  32. FROM SYSTEM IMPORT
  33.     ADR, ADDRESS, TAG, CAST, LONGSET;
  34.  
  35.  
  36.  
  37. CONST
  38.     (* Gadget-IDs *)
  39.     LISTVIEW = 0;
  40.     SHOWWINDOW = 1;
  41.     HIDEWINDOW = 2;
  42.     INACTIVE = 3;
  43.     REMOVE = 4;
  44.     DE_ACTIVEALL = 5;
  45.     REMOVEALL =6;
  46.     BROKERTITLE  = 7;
  47.     BROKERDESCRIPTION = 8;
  48.  
  49.     (* Menu-IDs *)
  50.     PROJECT = 0;
  51.         ABOUT = 0;
  52.         HIDE = 2;
  53.         QUIT = 3;
  54.     CONTROL = 1;
  55.         DISABLEALL = 0;
  56.         ENABLEALL = 1;
  57.         KILLALL = 3;
  58.     OPTIONS = 2;
  59.         MAUTOSIZE = 0;
  60.         MSIZEABLE = 1;
  61.         MREQUESTER = 2;
  62.         MREMOVEONLY = 3;
  63.         SAVEOPTIONS = 5;
  64.         LOADOPTIONS = 6;
  65.     MENUCOUNT = 18;
  66.                                       
  67. CONST
  68.     (* KEY_xxx *)
  69.     KEY_UP = 1;     (* vorigen Eintrag im Listview *)
  70.     KEY_DOWN = 0;   (* nächsten Eintrag im Listview *)
  71.     KEY_show = 2;   (* Interface entfernen *)
  72.     KEY_SHOW = 3;
  73.     KEY_hide = 4;   (* Interface öffnen *)
  74.     KEY_HIDE = 5;   (* dto., aber als SHIFT-Code *)
  75.     KEY_disenable = 6; (* Broker de-/aktivieren *)
  76.     KEY_DISENABLE = 7;
  77.     KEY_remove = 8; (* Broker entfernen *)
  78.     KEY_REMOVE = 9;
  79.     KEY_disenableall = 10;
  80.     KEY_DISENABLEALL = 11;
  81.     KEYCOUNT = 12;
  82.  
  83. CONST
  84.     DEF_REMOVELISTNAME = "S:CX.remlist";
  85.  
  86. TYPE
  87.     BevelInfo = RECORD
  88.         left, top: INTEGER;     (* Position der Bevelbox *)
  89.         width, height: INTEGER; (* Größe der Bevelbox *)
  90.     END;
  91.     CycleList = ARRAY [0..2] OF ADDRESS;
  92.     FontInfo = RECORD
  93.       userfont: gd.TextAttrPtr;
  94.       ysize,
  95.       xsize: INTEGER;
  96.     END;
  97.     LVItem = ARRAY [0..39] OF CHAR;
  98.     StrPtr = POINTER TO ARRAY [0..1023] OF CHAR;
  99.     Time = RECORD
  100.         secs, micros: LONGCARD;
  101.         END;
  102.     WindowInfo = RECORD
  103.         xoffset: INTEGER;       (* Abstand vom rechten linken Fensterrand (inkl. Rand) *)
  104.         yoffset: INTEGER;       (* dto. von oben (inkl. Rand) *)
  105.         leftEdge, topEdge: INTEGER;   (* Position des Fensters *)
  106.         width, height: INTEGER;       (* Größe des Fensters *)
  107.         maxWidth, maxHeight: INTEGER; (* maximale Größe des Fensters *)
  108.         minWidth, minHeight: INTEGER; (* minimale Größe *)
  109.         rBorder, bBorder: INTEGER;    (* rechter und unterer Rand *)
  110.         lBorder, tBorder: INTEGER;    (* linker und oberer Rand *)
  111.         END;
  112.  
  113. VAR
  114.     (* main window *)
  115.     window: id.WindowPtr;
  116.     WINDOW: WindowInfo;
  117.     BEVELBOX: BevelInfo;
  118.     PUBSCREEN: id.ScreenPtr;
  119.     pubscreenstr: StrPtr;
  120.     visualinfo: ADDRESS;
  121.     glist: id.GadgetPtr;
  122.     lvglist: id.GadgetPtr;
  123.     keyshortcut: StrPtr;
  124.     disenableAllState: BOOLEAN;
  125.     removeListName: ARRAY [0..127] OF CHAR;
  126.  
  127.     lvItems: POINTER TO ARRAY [1..64] OF LVItem;
  128.     lvList: ed.ListPtr;
  129.  
  130.     (* fontsensitive *)
  131.     FONT: FontInfo;
  132.     usertextfont: gd.TextFontPtr;
  133.  
  134.     (* broker *)
  135.     brokercount: INTEGER;                  
  136.     lvitem: INTEGER;    (* aktueller angezeigter Broker i.d. Liste *)
  137.     (* gadgets *)
  138.     gadgets: ARRAY [0..8] OF id.GadgetPtr;
  139.     inActiveCycleList: CycleList;
  140.     deActiveAllCycleList: CycleList;
  141.  
  142.     (* Menü *)
  143.     menu: POINTER TO ARRAY [0..MENUCOUNT] OF gtd.NewMenu;
  144.     menustrip: id.MenuPtr;
  145.  
  146.     (* Katalog: *)
  147.  
  148.  
  149. PROCEDURE UpdateBroker (num: INTEGER); FORWARD;
  150. PROCEDURE RescaleListview; FORWARD;
  151. PROCEDURE CreateLVList; FORWARD;
  152.  
  153.  
  154. PROCEDURE GetKeyShortcuts;
  155. BEGIN
  156.     keyshortcut := ll.GetCatalogStr(catalog, cxl.KEYSHORTCUTS, ADR(cxl.KEYSHORTCUTSSTR));
  157. END GetKeyShortcuts;
  158.  
  159. (* --------------------------------------------------------------- *)
  160.  
  161. PROCEDURE Init;
  162. BEGIN
  163.     pubscreenstr := cs.ArgString(ADR("PUBSCREEN"), ADR("Workbench"));
  164.     WITH options DO
  165.         REQUESTER := String.Compare(CAST(StrPtr, cs.ArgString(ADR("REQUESTER"),ADR("YES")))^,"YES") = 0;
  166.         AUTOSIZE  := String.Compare(CAST(StrPtr, cs.ArgString(ADR("AUTOSIZE"), ADR("NO")))^,"YES") = 0;
  167.         REMOVEONLY := String.Compare(CAST(StrPtr, cs.ArgString(ADR("REMOVEONLY"), ADR("YES")))^,"YES") = 0;
  168.         SIZEABLE := String.Compare(CAST(StrPtr, cs.ArgString(ADR("SIZEABLE"), ADR("YES")))^,"YES") = 0;
  169.     END;
  170.     removeListName := DEF_REMOVELISTNAME;
  171.     String.Copy (removeListName, CAST(StrPtr, cs.ArgString(ADR("REMOVELIST"), ADR(DEF_REMOVELISTNAME)))^);
  172.     cxf.LoadRemoveList (ADR(removeListName));
  173. END Init;
  174.  
  175. PROCEDURE Initialisieren;
  176. BEGIN
  177.     PUBSCREEN := il.LockPubScreen(pubscreenstr);
  178.     IF PUBSCREEN = NIL THEN
  179.         PUBSCREEN := il.LockPubScreen(NIL);
  180.     END;
  181.     IF PUBSCREEN # NIL THEN
  182.         visualinfo := gtl.GetVisualInfoA(PUBSCREEN, NIL);
  183.         WITH FONT DO
  184.             userfont := PUBSCREEN^.font;
  185.             ysize := PUBSCREEN^.rastPort.txHeight;
  186.             xsize := PUBSCREEN^.rastPort.txWidth;
  187.         END;
  188.         usertextfont := gl.OpenFont(FONT.userfont);
  189.         WITH WINDOW DO
  190.             yoffset := 0; (*PUBSCREEN^.wBorTop + FONT.ysize + 1;*)
  191.             xoffset := 0; (*PUBSCREEN^.wBorLeft;*)
  192.             tBorder := PUBSCREEN^.wBorTop + FONT.ysize + 1;
  193.             lBorder := PUBSCREEN^.wBorLeft;
  194.             IF gd.hires IN PUBSCREEN^.viewPort.modes THEN
  195.                 rBorder := 18;
  196.             ELSE
  197.                 rBorder := 13;
  198.             END;
  199.             bBorder := PUBSCREEN^.wBorBottom;
  200.             maxWidth := lBorder+rBorder +       (* Fensterrahmen *)
  201.                         3*(20*FONT.xsize+16) +  (* drei Gadgets  *)
  202.                         8;                      (* Abstände dazwischen *)
  203.             maxHeight := tBorder+bBorder +      (* Fensterrahmen *)
  204.                         2*FONT.ysize +          (* Abstand zur BBox *)
  205.                         2*FONT.ysize + 6 +      (* Höhe der Bevelbox *)
  206.                         3*(FONT.ysize + 4) +    (* Schalterhöhen *)
  207.                         8;                      (* Abstände *)
  208.             minWidth := lBorder+rBorder +
  209.                         20*FONT.ysize+16 +
  210.                         4;
  211.             minHeight := tBorder+bBorder +
  212.                         2*FONT.ysize +
  213.                         4*FONT.ysize +
  214.                         2;
  215.             leftEdge := cs.ArgInt(ADR("WINLEFT"),50);
  216.             topEdge := cs.ArgInt(ADR("WINTOP"),50);
  217.             width := cs.ArgInt(ADR("WINWIDTH"),maxWidth);
  218.             IF width < minWidth THEN
  219.                 width := minWidth;
  220.             ELSIF width > maxWidth THEN
  221.                 width := maxWidth;
  222.             END;
  223.             height := cs.ArgInt(ADR("WINHEIGHT"),maxHeight);
  224.             IF height < minHeight THEN
  225.                 height := minHeight;
  226.             ELSIF height > maxHeight THEN
  227.                 height := maxHeight;
  228.             END;
  229.         END;
  230.         WITH BEVELBOX DO
  231.             left   := WINDOW.xoffset + 20*FONT.xsize+16 + 4;
  232.             top    := WINDOW.yoffset + 2*FONT.ysize;
  233.             height := 2*FONT.ysize + 6;
  234.             width  := 2*(20*FONT.xsize+16);
  235.         END;
  236.  
  237.         IF NOT(options.SIZEABLE) THEN
  238.             DEC (WINDOW.width, WINDOW.rBorder-2);
  239.         END;
  240.     END;
  241. END Initialisieren;
  242.  
  243. PROCEDURE DeInitialisieren;
  244. BEGIN
  245.     IF visualinfo # NIL THEN
  246.         gtl.FreeVisualInfo (visualinfo);
  247.         visualinfo := NIL;
  248.     END;
  249.     IF usertextfont # NIL THEN
  250.         gl.CloseFont(usertextfont);
  251.         usertextfont := NIL;
  252.     END;
  253. END DeInitialisieren;
  254.  
  255. (* --------------------------------------------------------------- *)
  256.  
  257. PROCEDURE DefiniereGadgets;
  258. VAR
  259.     ng: gtd.NewGadget;
  260.     g: id.GadgetPtr;
  261.     tl: ARRAY [0..15] OF LONGINT;
  262.     a,b,c: INTEGER;
  263. BEGIN
  264.     (*$ IF DEBUG *)
  265.         io.WriteString ("cxw.DefiniereGadgets()\n");
  266.     (*$ ENDIF *)
  267.  
  268.     IF visualinfo # NIL THEN
  269.         lvglist := NIL;
  270.         g := gtl.CreateContext(lvglist);
  271.  
  272. (** "Listview-Gadget" *)
  273.         IF options.AUTOSIZE THEN
  274.             a := brokercount*FONT.ysize + 4;    (* 4 = Rahmen des LV *)
  275.             b := 3*(FONT.ysize+4+2);
  276.             c := a-b;
  277.             IF c < BEVELBOX.height+2 THEN
  278.                 (* Nicht genügend Platz für die BevelBox *)
  279.                 a := a + BEVELBOX.height-c + 2;
  280.             END;
  281.             WITH WINDOW DO
  282.                 maxHeight := tBorder + bBorder + yoffset + 2*FONT.ysize + a;
  283.                 height := maxHeight;
  284.             END;
  285.         ELSE
  286.             a := WINDOW.height - WINDOW.tBorder - WINDOW.bBorder - 2 -
  287.                  2*FONT.ysize;
  288.         END;
  289.         CreateLVList;
  290.         WITH ng DO
  291.             leftEdge := WINDOW.xoffset + 2;
  292.             topEdge := WINDOW.yoffset + 2*FONT.ysize;
  293.             width := 20*FONT.xsize + 16;
  294.             height := a;
  295.             gadgetText := ll.GetCatalogStr(catalog, cxl.GAD_LISTVIEW, ADR(cxl.GAD_LISTVIEWSTR));
  296.             textAttr := FONT.userfont;
  297.             gadgetID := LISTVIEW;
  298.             flags := gtd.NewGadgetFlagSet{gtd.placetextAbove};
  299.             visualInfo := visualinfo;
  300.             userData := NIL;
  301.         END;
  302.         g := gtl.CreateGadgetA(gtd.listviewKind, g^, ng, TAG(tl,
  303.             gtd.gtUnderscore, "_",
  304.             gtd.gtlvLabels, lvList, (*cxc.brokerlist,*)
  305.             gtd.gtlvShowSelected, NIL,
  306.             gtd.gtlvSelected, lvitem,
  307.             gtd.gtlvMakeVisible, lvitem,
  308.             tagEnd));
  309.         gadgets[LISTVIEW] := g;
  310. (**)
  311.  
  312.         glist := NIL;
  313.         g := gtl.CreateContext (glist);
  314.  
  315. (** "Show-Window-Gadget" *)
  316.         WITH ng DO
  317.             topEdge     := BEVELBOX.top + BEVELBOX.height + 2;
  318.             leftEdge    := BEVELBOX.left;
  319.             height      := FONT.ysize + 4;
  320.             gadgetText  := ll.GetCatalogStr(catalog, cxl.GAD_SHOWWINDOW, ADR(cxl.GAD_SHOWWINDOWSTR));
  321.             gadgetID    := SHOWWINDOW;
  322.             flags       := gtd.NewGadgetFlagSet{gtd.placetextIn,gtd.ngHighlabel};
  323.         END;
  324.         g := gtl.CreateGadgetA(gtd.buttonKind, g^, ng, TAG(tl,
  325.             gtd.gtUnderscore, "_",
  326.             tagEnd));
  327.         gadgets[SHOWWINDOW] := g;
  328. (**)
  329. (** "De-/Aktiv Cycle-Gadget" *)
  330.         inActiveCycleList[0] := ll.GetCatalogStr(catalog, cxl.GAD_ACTIVE, ADR(cxl.GAD_ACTIVESTR));
  331.         inActiveCycleList[1] := ll.GetCatalogStr(catalog, cxl.GAD_INACTIVE, ADR(cxl.GAD_INACTIVESTR));
  332.         inActiveCycleList[2] := NIL;
  333.         WITH ng DO
  334.             topEdge     := topEdge + height + 2;
  335.             gadgetText  := NIL;
  336.             gadgetID    := INACTIVE;
  337.         END;
  338.         g := gtl.CreateGadgetA(gtd.cycleKind, g^, ng, TAG(tl,
  339.             gtd.gtUnderscore, "_",
  340.             gtd.gtcyLabels, ADR(inActiveCycleList[0]),
  341.             gtd.gtcyActive, 0,
  342.             tagEnd));
  343.         gadgets[INACTIVE] := g;
  344. (**)          
  345. (** "De-/Aktivate all Cycle-Gadget" *)
  346.         disenableAllState := TRUE; (* Alle deaktivieren *)
  347.         deActiveAllCycleList[1] := ll.GetCatalogStr(catalog, cxl.GAD_ACTIVATEALL, ADR(cxl.GAD_ACTIVATEALLSTR));
  348.         deActiveAllCycleList[0] := ll.GetCatalogStr(catalog, cxl.GAD_DEACTIVATEALL, ADR(cxl.GAD_DEACTIVATEALLSTR));
  349.         deActiveAllCycleList[2] := NIL;
  350.         WITH ng DO
  351.             topEdge     := topEdge + height + 2;
  352.             gadgetID    := DE_ACTIVEALL;
  353.         END;
  354.         g := gtl.CreateGadgetA(gtd.cycleKind, g^, ng, TAG(tl,
  355.             gtd.gtUnderscore, "_",
  356.             gtd.gtcyLabels, ADR(deActiveAllCycleList[0]),
  357.             gtd.gtcyActive, 0,
  358.             tagEnd));
  359.         gadgets[DE_ACTIVEALL] := g;
  360. (**)
  361.  
  362. (** "Remove-All-Gadget" *)
  363.         WITH ng DO
  364.             leftEdge    := leftEdge + width + 2;
  365.             gadgetText  := ll.GetCatalogStr(catalog, cxl.GAD_REMOVEALL, ADR(cxl.GAD_REMOVEALLSTR));
  366.             flags       := gtd.NewGadgetFlagSet{gtd.placetextIn};
  367.             gadgetID    := REMOVEALL;
  368.         END;
  369.         g := gtl.CreateGadgetA(gtd.buttonKind, g^, ng, TAG(tl,
  370.             gtd.gtUnderscore, "_",
  371.             tagEnd));
  372.         gadgets[REMOVEALL] := g;
  373. (**)
  374. (** "Entfernen-Gadget" *)
  375.         WITH ng DO
  376.             topEdge     := topEdge - height - 2;
  377.             gadgetText  := ll.GetCatalogStr(catalog, cxl.GAD_REMOVE, ADR(cxl.GAD_REMOVESTR));
  378.             gadgetID    := REMOVE;
  379.         END;
  380.         g := gtl.CreateGadgetA(gtd.buttonKind, g^, ng, TAG(tl,
  381.             gtd.gtUnderscore, "_",
  382.             tagEnd));
  383.         gadgets[REMOVE] := g;
  384. (**)
  385. (** "Hide-Window-Gadget" *)
  386.         WITH ng DO
  387.             topEdge     := topEdge - height - 2;
  388.             gadgetText  := ll.GetCatalogStr(catalog, cxl.GAD_HIDEWINDOW, ADR(cxl.GAD_HIDEWINDOWSTR));
  389.             gadgetID    := HIDEWINDOW;
  390.         END;
  391.         g := gtl.CreateGadgetA(gtd.buttonKind, g^, ng, TAG(tl,
  392.             gtd.gtUnderscore, "_",
  393.             tagEnd));
  394.         gadgets[HIDEWINDOW] := g;
  395. (**)
  396.  
  397.  
  398. (** "Text-Gadget für Broker-Titel u. -Beschreibung" *)
  399.         WITH ng DO
  400.             topEdge     := BEVELBOX.top;
  401.             leftEdge    := BEVELBOX.left+3;
  402.             gadgetID    := BROKERTITLE;
  403.             gadgetText  := NIL;
  404.         END;
  405.         g := gtl.CreateGadgetA(gtd.textKind, g^, ng, TAG(tl,
  406.             gtd.gtUnderscore, "_",
  407.             gtd.gttxText, ADR('"Then came the sad day. Her test was'),
  408.             tagEnd));
  409.         gadgets[BROKERTITLE] := g;
  410.         WITH ng DO
  411.             topEdge     := BEVELBOX.top + FONT.ysize + 2;
  412.             gadgetText  := NIL;
  413.             gadgetID    := BROKERDESCRIPTION;
  414.         END;
  415.         g := gtl.CreateGadgetA(gtd.textKind, g^, ng, TAG(tl,
  416.             gtd.gtUnderscore, "_",
  417.             gtd.gttxText, ADR('positive." Fight AIDS - save love!'),
  418.             tagEnd));   
  419.         gadgets[BROKERDESCRIPTION] := g;
  420. (**)
  421.     END;
  422. END DefiniereGadgets;
  423.  
  424.  
  425.  
  426. PROCEDURE DefiniereMenues;
  427. (* Generiert die Menüs: *)
  428. PROCEDURE SetMenuItem (VAR nm: gtd.NewMenu; text: StrPtr);
  429. BEGIN
  430.     WITH nm DO
  431.         type := gtd.nmItem;
  432.         IF (text^[1] = "o") OR (text^[1] = 0C) THEN
  433.             commKey := text;
  434.             INC(text,2);
  435.         END;
  436.         label := text;
  437.     END;
  438. END SetMenuItem;
  439.  
  440. BEGIN
  441.     (*$ IF DEBUG *)
  442.         io.WriteString ("cxw.DefiniereMenues()\n");
  443.     (*$ ENDIF *)
  444.     menu := el.AllocMem((MENUCOUNT+1)*SIZE(gtd.NewMenu), ed.MemReqSet{ed.memClear});
  445.     IF menu # NIL THEN
  446.         WITH menu^[0] DO
  447.             type := gtd.nmTitle;
  448.             label := ll.GetCatalogStr(catalog, cxl.MENU_PROJECT, ADR(cxl.MENU_PROJECTSTR));
  449.         END;
  450.         SetMenuItem (menu^[1], ll.GetCatalogStr(catalog, cxl.MENU_ABOUT, ADR(cxl.MENU_ABOUTSTR)));
  451.         WITH menu^[2] DO
  452.             type := gtd.nmItem;
  453.             label := gtd.nmBarlabel;
  454.         END;
  455.         SetMenuItem (menu^[3], ll.GetCatalogStr(catalog, cxl.MENU_HIDE, ADR(cxl.MENU_HIDESTR)));
  456.         SetMenuItem (menu^[4], ll.GetCatalogStr(catalog, cxl.MENU_QUIT, ADR(cxl.MENU_QUITSTR)));
  457.  
  458.         WITH menu^[5] DO
  459.             type := gtd.nmTitle;
  460.             label := ll.GetCatalogStr(catalog, cxl.MENU_CONTROL, ADR(cxl.MENU_CONTROLSTR));
  461.         END;
  462.         SetMenuItem (menu^[6], ll.GetCatalogStr(catalog, cxl.MENU_DISABLEALL, ADR(cxl.MENU_DISABLEALLSTR)));
  463.         SetMenuItem (menu^[7], ll.GetCatalogStr(catalog, cxl.MENU_ENABLEALL, ADR(cxl.MENU_ENABLEALLSTR)));
  464.         WITH menu^[8] DO
  465.             type := gtd.nmItem;
  466.             label := gtd.nmBarlabel;
  467.         END;
  468.         SetMenuItem (menu^[9], ll.GetCatalogStr(catalog, cxl.MENU_KILLALL, ADR(cxl.MENU_KILLALLSTR)));
  469.  
  470.         WITH menu^[10] DO
  471.             type  := gtd.nmTitle;
  472.             label := ll.GetCatalogStr(catalog, cxl.MENU_OPTIONS, ADR(cxl.MENU_OPTIONSSTR));
  473.         END;
  474.         SetMenuItem (menu^[11], ll.GetCatalogStr(catalog, cxl.MENU_AUTOSIZE, ADR(cxl.MENU_AUTOSIZESTR)));
  475.         menu^[11].itemFlags := id.MenuItemFlagSet{id.checkIt,id.menuToggle};
  476.         IF options.AUTOSIZE THEN
  477.             INCL (menu^[11].itemFlags, id.checked);
  478.         END;
  479.         SetMenuItem (menu^[12], ll.GetCatalogStr(catalog, cxl.MENU_SIZEABLE, ADR(cxl.MENU_SIZEABLESTR)));
  480.         menu^[12].itemFlags := id.MenuItemFlagSet{id.checkIt,id.menuToggle};
  481.         IF options.SIZEABLE THEN
  482.             INCL (menu^[12].itemFlags, id.checked);
  483.         END;
  484.         SetMenuItem (menu^[13], ll.GetCatalogStr(catalog, cxl.MENU_REQUESTER, ADR(cxl.MENU_REQUESTERSTR)));
  485.         menu^[13].itemFlags := id.MenuItemFlagSet{id.checkIt,id.menuToggle};
  486.         IF options.REQUESTER THEN
  487.             INCL (menu^[13].itemFlags, id.checked);
  488.         END;
  489.         SetMenuItem (menu^[14], ll.GetCatalogStr(catalog, cxl.MENU_REMOVEONLY, ADR(cxl.MENU_REMOVEONLYSTR)));
  490.         menu^[14].itemFlags := id.MenuItemFlagSet{id.checkIt,id.menuToggle};
  491.         IF options.REMOVEONLY THEN
  492.             INCL (menu^[14].itemFlags, id.checked);
  493.         END;
  494.         WITH menu^[15] DO
  495.             type := gtd.nmItem;
  496.             label := gtd.nmBarlabel;
  497.         END;
  498.         SetMenuItem (menu^[16], ll.GetCatalogStr(catalog, cxl.MENU_SAVEOPT, ADR(cxl.MENU_SAVEOPTSTR)));
  499.         WITH menu^[17] DO
  500.             type    := gtd.nmItem;
  501.             label   := ll.GetCatalogStr(catalog, cxl.MENU_LOADOPT, ADR(cxl.MENU_LOADOPTSTR));
  502.         END;
  503.         WITH menu^[18] DO
  504.             type := gtd.nmEnd;
  505.         END;
  506.     END;
  507. END DefiniereMenues;
  508.  
  509.  
  510.  
  511. PROCEDURE OeffneFenster;
  512. VAR
  513.     tl: ARRAY [0..39] OF LONGINT;
  514.     a: INTEGER;
  515.     bool: BOOLEAN;
  516. BEGIN
  517.     (*$ IF DEBUG *)
  518.         io.WriteString ("cxw.OeffneFenster()\n");
  519.     (*$ ENDIF *)
  520.     window := il.OpenWindowTagList(NIL, TAG(tl,
  521.         id.waLeft,      WINDOW.leftEdge,
  522.         id.waTop,       WINDOW.topEdge,
  523.         id.waWidth,     WINDOW.width,
  524.         id.waHeight,    WINDOW.height,
  525.         id.waMaxWidth,  WINDOW.maxWidth,
  526.         id.waMaxHeight, WINDOW.maxHeight,
  527.         id.waMinWidth,  WINDOW.minWidth,
  528.         id.waMinHeight, WINDOW.minHeight,
  529.         id.waGimmeZeroZero, TRUE,
  530.         id.waIDCMP,     id.IDCMPFlagSet{id.closeWindow, id.menuPick,
  531.                             id.refreshWindow, id.rawKey, id.vanillaKey,
  532.                             id.newSize} +
  533.                         gtd.listviewIDCMP +
  534.                         gtd.buttonIDCMP +
  535.                         gtd.textIDCMP,
  536.         id.waGadgets,   glist,
  537.         id.waTitle,     ADR(wintitle),
  538.         id.waPubScreen, PUBSCREEN,
  539.         id.waSizeGadget,options.SIZEABLE,
  540.         id.waDragBar,   TRUE,
  541.         id.waDepthGadget,TRUE,
  542.         id.waCloseGadget,TRUE,
  543.         id.waActivate,  TRUE,
  544.         id.waNewLookMenus,TRUE,
  545.         tagEnd));
  546.     IF window # NIL THEN
  547.         (* Fenster ist offen, der PubScreen kann wieder freigegeben
  548.          * werden.
  549.          *)
  550.         il.UnlockPubScreen(NIL, PUBSCREEN);
  551.         PUBSCREEN := NIL;
  552.  
  553.         (* Menüs erzeugen, layouten und ans Fenster hängen: *)
  554.         menustrip := gtl.CreateMenusA(CAST(gtd.NewMenuPtr,menu), TAG(tl,
  555.             gtd.gtmnFrontPen, 1,
  556.             tagEnd));
  557.         IF menustrip # NIL THEN
  558.             IF gtl.LayoutMenusA(menustrip, visualinfo, NIL) THEN
  559.                 bool := il.SetMenuStrip(window, menustrip);
  560.             END;
  561.         END;
  562.  
  563.         (* Das ListView-Gadget darstellen: *)
  564.         a := il.AddGList(window, lvglist, -1, -1, NIL);
  565.         il.RefreshGList (lvglist, window, NIL, -1);
  566.         gtl.GTRefreshWindow(window, NIL);
  567.  
  568.         windowsignal := window^.userPort^.sigBit;
  569.         (*$ IF DEBUG *)
  570.             io.WriteString ("- windowsignal = ");
  571.             io.WriteCard (windowsignal,0); io.WriteLn;
  572.         (*$ ENDIF *)
  573.  
  574.         (* Rahmen um die Commodity-Informationen zeichnen: *)
  575.         gtl.DrawBevelBoxA (window^.rPort, BEVELBOX.left, BEVELBOX.top,
  576.             BEVELBOX.width, BEVELBOX.height, TAG(tl,
  577.                 gtd.gtVisualInfo, visualinfo,
  578.                 gtd.gtbbRecessed, TRUE,
  579.                 tagEnd));
  580.         a := String.Length(CAST(StrPtr, ll.GetCatalogStr(catalog, cxl.GAD_INFORMATION, ADR(cxl.GAD_INFORMATIONSTR)))^);
  581.         gl.Move (window^.rPort, BEVELBOX.left + (BEVELBOX.width-(a*FONT.xsize)) DIV 2,
  582.             BEVELBOX.top-(FONT.ysize DIV 2)-2);
  583.         gl.SetAPen (window^.rPort, 1);
  584.         gl.SetFont (window^.rPort, usertextfont);
  585.         gl.Text (window^.rPort, ll.GetCatalogStr(catalog, cxl.GAD_INFORMATION, ADR(cxl.GAD_INFORMATIONSTR)), a);
  586.         RefreshListview;
  587.         RescaleListview;
  588.         UpdateBroker (lvitem);
  589.     END;
  590. END OeffneFenster;
  591.  
  592.  
  593.  
  594. PROCEDURE ShowWindow;
  595. BEGIN
  596.     (*$ IF DEBUG *)
  597.         io.WriteString ("cxw.ShowWindow()\n");
  598.     (*$ ENDIF *)
  599.  
  600.     IF window # NIL THEN
  601.         il.WindowToFront(window);
  602.         il.ActivateWindow(window);
  603.     ELSE
  604.         Initialisieren;
  605.         IF PUBSCREEN # NIL THEN
  606.             DefiniereGadgets;
  607.             DefiniereMenues;
  608.             OeffneFenster;
  609.         END;
  610.     END;
  611. END ShowWindow;
  612.  
  613. PROCEDURE CloseWindow;
  614. BEGIN
  615.     (*$ IF DEBUG *)
  616.         io.WriteString ("cxw.CloseWindow()\n");
  617.     (*$ ENDIF *)
  618.  
  619.     IF window # NIL THEN
  620.         (* Position und Ausdehnung des Fensters merken *)
  621.         WITH WINDOW DO
  622.             WINDOW.leftEdge := window^.leftEdge;
  623.             WINDOW.topEdge  := window^.topEdge;
  624.             WINDOW.width := window^.width;
  625.             WINDOW.height := window^.height;
  626.         END;
  627.         IF menustrip # NIL THEN
  628.             il.ClearMenuStrip(window);
  629.             gtl.FreeMenus(menustrip);
  630.             menustrip := NIL;
  631.         END;
  632.         IF menu # NIL THEN
  633.             el.FreeMem(menu, (MENUCOUNT+1)*SIZE(gtd.NewMenu));
  634.             menu := NIL;
  635.         END;
  636.         il.CloseWindow (window);
  637.         window := NIL;
  638.         gtl.FreeGadgets(glist);
  639.         (*gtl.FreeGadgets(lvglist);*)
  640.     END;
  641. END CloseWindow;
  642.  
  643. (* --------------------------------------------------------------- *)
  644.  
  645. PROCEDURE UpdateBroker (num: INTEGER);
  646. (* Die Informationen und Gadgets zu dem num-ten Broker in der
  647.  * Liste werden aktualisiert.
  648.  *)
  649. VAR
  650.     brokercopy: cp.BrokerCopyPtr;
  651.     interface: BOOLEAN;
  652.     active: BOOLEAN;
  653.     tl: ARRAY [0..7] OF LONGINT;
  654.     adr: ADDRESS;
  655. BEGIN
  656.     (*$ IF DEBUG *)
  657.         io.WriteString ("cxw.UpdateBroker (");
  658.         io.WriteInt (num,0); io.WriteString (")\n");
  659.     (*$ ENDIF *)
  660.     brokercopy := cxc.GetBrokerCopy (num);
  661.     interface := NOT(cp.showhide IN brokercopy^.flags);
  662.     gtl.GTSetGadgetAttrsA (gadgets[SHOWWINDOW], window, NIL, TAG(tl,
  663.         id.gaDisabled, interface,
  664.         tagEnd));
  665.     gtl.GTSetGadgetAttrsA (gadgets[HIDEWINDOW], window, NIL, TAG(tl,
  666.         id.gaDisabled, interface,
  667.         tagEnd));
  668.     IF cp.active IN brokercopy^.flags THEN
  669.         gtl.GTSetGadgetAttrsA (gadgets[INACTIVE], window, NIL, TAG(tl,
  670.             gtd.gtcyActive, 0,
  671.             tagEnd));
  672.     ELSE
  673.         gtl.GTSetGadgetAttrsA (gadgets[INACTIVE], window, NIL, TAG(tl,
  674.             gtd.gtcyActive, 1,
  675.             tagEnd));     
  676.     END;
  677.     adr := ADR(brokercopy^.title);
  678.     gtl.GTSetGadgetAttrsA (gadgets[BROKERTITLE], window, NIL, TAG(tl,
  679.         gtd.gttxText, adr,
  680.         tagEnd));
  681.     adr := ADR(brokercopy^.descr);
  682.     gtl.GTSetGadgetAttrsA (gadgets[BROKERDESCRIPTION], window, NIL, TAG(tl,
  683.         gtd.gttxText, adr,
  684.         tagEnd));
  685. END UpdateBroker;
  686.  
  687. (* --------------------------------------------------------------- *)
  688.  
  689. PROCEDURE UpdateListview (lvitem: INTEGER);
  690. VAR
  691.     tl: ARRAY [0..7] OF LONGINT;
  692. BEGIN
  693.     gtl.GTSetGadgetAttrsA (gadgets[LISTVIEW], window, NIL, TAG(tl,
  694.         gtd.gtlvSelected, lvitem,
  695.         gtd.gtlvMakeVisible, lvitem,
  696.         tagEnd));
  697.     UpdateBroker (lvitem);     
  698. END UpdateListview;
  699.  
  700. PROCEDURE RescaleListview;
  701. (* Wird aufgerufen, nachdem der User die Fenstergröße verändert
  702.  * hat. Das Listview-Gadget wird den neuen Verhältnissen ange-
  703.  * paßt.
  704.  *)
  705. VAR
  706.     ng: gtd.NewGadget;
  707.     g: id.GadgetPtr;
  708.     tl: ARRAY [0..15] OF LONGINT;
  709.     li: LONGINT;
  710.     i: INTEGER;
  711. BEGIN
  712.     gl.SetAPen (window^.rPort, 0);
  713.     gl.RectFill (window^.rPort, WINDOW.xoffset + 2, 0,
  714.         WINDOW.xoffset+18+20*FONT.xsize, window^.height);
  715.     li := il.RemoveGList(window, lvglist, -1);
  716.     gtl.FreeGadgets (lvglist);
  717.     lvglist := NIL;
  718.     g := gtl.CreateContext(lvglist);
  719.     WITH ng DO
  720.         leftEdge    := WINDOW.xoffset + 2;
  721.         topEdge     := WINDOW.yoffset + 2*FONT.ysize;
  722.         width       := 20*FONT.xsize+16;
  723.         height      := window^.height - window^.borderTop - window^.borderBottom - 2*FONT.ysize;
  724.         gadgetText  := ll.GetCatalogStr(catalog, cxl.GAD_LISTVIEW, ADR(cxl.GAD_LISTVIEWSTR));
  725.         textAttr    := FONT.userfont;
  726.         gadgetID    := LISTVIEW;
  727.         flags       := gtd.NewGadgetFlagSet{gtd.placetextAbove};
  728.         visualInfo  := visualinfo;
  729.         userData    := NIL;
  730.      END;
  731.      g := gtl.CreateGadgetA(gtd.listviewKind, g^, ng, TAG(tl,
  732.             gtd.gtUnderscore, "_",
  733.             gtd.gtlvLabels, lvList, (*cxc.brokerlist,*)
  734.             gtd.gtlvShowSelected, NIL,
  735.             gtd.gtlvSelected, lvitem,
  736.             gtd.gtlvMakeVisible, lvitem,
  737.             tagEnd));
  738.      gadgets[LISTVIEW] := g;
  739.      i := il.AddGList (window, lvglist, -1, -1, NIL);
  740.      il.RefreshGList (lvglist, window, NIL, -1);
  741.      gtl.GTRefreshWindow (window, NIL);
  742. END RescaleListview;
  743.  
  744. PROCEDURE FreeLVList;
  745. VAR
  746.     node, nnode: ed.NodePtr;
  747. BEGIN
  748.     IF lvList # NIL THEN
  749.         IF lvItems # NIL THEN
  750.             node := lvList^.head;
  751.             WHILE node^.succ # NIL DO
  752.                 nnode := node^.succ;
  753.                 el.FreeMem(node, SIZE(ed.Node)); (*el.Remove (node);*)
  754.                 node := nnode;
  755.             END;
  756.             el.FreeMem(lvItems, SIZE(LVItem)*brokercount);
  757.             lvItems := NIL;
  758.         END;
  759.         el.FreeMem(lvList, SIZE(ed.List));
  760.         lvList := NIL;
  761.     END;
  762. END FreeLVList;
  763.  
  764. PROCEDURE CreateLVList;
  765. VAR
  766.     nnode, bnode: ed.NodePtr;
  767.     n: INTEGER;
  768. BEGIN
  769.     lvList := el.AllocMem(SIZE(ed.List), ed.MemReqSet{ed.memClear});
  770.     IF lvList # NIL THEN
  771.         es.NewList (lvList);
  772.         lvItems := el.AllocMem(SIZE(LVItem)*brokercount, ed.MemReqSet{ed.memClear});
  773.         IF lvItems # NIL THEN
  774.             bnode := cxc.brokerlist^.head;
  775.             FOR n := 1 TO brokercount DO
  776.                 nnode := el.AllocMem(SIZE(ed.Node), ed.MemReqSet{ed.memClear});
  777.                 IF nnode # NIL THEN
  778.                     String.Copy (lvItems^[n], CAST(StrPtr, bnode^.name)^);
  779.                     IF options.REMOVEONLY THEN
  780.                         IF cxf.IsInRemoveList(bnode^.name) THEN
  781.                             String.Insert(lvItems^[n], 0, "* ");
  782.                         ELSE
  783.                             String.Insert(lvItems^[n], 0, "  ");
  784.                         END;
  785.                     END;
  786.                     nnode^.name := ADR(lvItems^[n]);
  787.                     el.AddTail (lvList, nnode);
  788.                 END;
  789.                 bnode := bnode^.succ;
  790.             END;
  791.         END;
  792.     END;
  793. END CreateLVList;
  794.  
  795. PROCEDURE RefreshListview;
  796. (* Wird von CXCommodity.mod aufgerufen, falls sich etwas an
  797.  * der Brokerliste verändert haben sollte.
  798.  *)
  799. VAR
  800.     tl: ARRAY [0..7] OF LONGINT;
  801.     dummylist: LONGINT;
  802.     dummylistadr: ADDRESS;
  803. BEGIN
  804.     IF window # NIL THEN
  805.         (*dummylist := 0FFFFH;
  806.         dummylistadr := ADR(dummylist);*)
  807.         (*gtl.GTSetGadgetAttrsA (gadgets[LISTVIEW], window, NIL, TAG(tl,
  808.             gtd.gtlvLabels,     dummylist,
  809.             tagEnd));*)
  810.  
  811.         FreeLVList;
  812.         cxc.FreeBrokerList();
  813.         cxc.InitBrokerList (brokercount);
  814.         CreateLVList;
  815.  
  816.         lvitem := lvitem MOD brokercount;
  817.         gtl.GTSetGadgetAttrsA (gadgets[LISTVIEW], window, NIL, TAG(tl,
  818.             gtd.gtlvLabels, lvList, (*cxc.brokerlist,*)
  819.             gtd.gtlvSelected, lvitem,
  820.             gtd.gtlvMakeVisible, lvitem,
  821.             tagEnd));
  822. (*        el.Permit();    *)
  823.         UpdateBroker (lvitem);
  824.     END;
  825. END RefreshListview;
  826.  
  827. (* --------------------------------------------------------------- *)
  828.  
  829. PROCEDURE DisEnableAll (VAR state: BOOLEAN);
  830. BEGIN
  831.     IF state THEN
  832.         cxc.SendAllBrokerCommand (cd.cxcmdDisable);
  833.     ELSE
  834.         cxc.SendAllBrokerCommand (cd.cxcmdEnable);
  835.     END;
  836.     state := NOT(state);
  837. END DisEnableAll;
  838.  
  839. PROCEDURE KillAll;
  840. (* User möchte, das alle Commodities entfernt werden. Wir fragen
  841.  * aber sicherheitshalber nochmal nach:
  842.  *)
  843. VAR
  844.    easyreq  : id.EasyStruct;
  845.    idcmp    : id.IDCMPFlagSet;
  846.    num      : LONGINT;
  847.    bnode    : ed.NodePtr;
  848. BEGIN
  849.    num := 1;
  850.    IF options.REQUESTER THEN
  851.        idcmp := id.IDCMPFlagSet{};
  852.        WITH easyreq DO
  853.           structSize  := SIZE(id.EasyStruct);
  854.           flags       := LONGSET{};
  855.           title       := ll.GetCatalogStr(catalog, cxl.REQ_REMOVEALL_TITLE, ADR(cxl.REQ_REMOVEALL_TITLESTR));
  856.           textFormat  := ll.GetCatalogStr(catalog, cxl.REQ_REMOVEALL_BODY, ADR(cxl.REQ_REMOVEALL_BODYSTR));
  857.           gadgetFormat:= ll.GetCatalogStr(catalog, cxl.REQ_REMOVEALL_FORMAT, ADR(cxl.REQ_REMOVEALL_FORMATSTR));
  858.        END;
  859.        num := il.EasyRequestArgs(window, easyreq, idcmp, NIL);
  860.     END;
  861.     IF num = 1 THEN
  862.         IF options.REMOVEONLY THEN
  863.             bnode := cxc.brokerlist^.head;
  864.             WHILE bnode^.succ # NIL DO
  865.                 IF cxf.IsInRemoveList(bnode^.name) THEN
  866.                     num := cp.BrokerCommand (bnode^.name, cd.cxcmdKill);
  867.                 END;
  868.                 bnode := bnode^.succ;
  869.             END;
  870.         ELSE
  871.             cxc.SendAllBrokerCommand (cd.cxcmdKill);
  872.         END;
  873.     END;
  874. END KillAll;
  875.  
  876. PROCEDURE About;
  877. VAR
  878.    easyreq  : id.EasyStruct;
  879.    idcmp    : id.IDCMPFlagSet;
  880.    num: LONGINT;
  881. BEGIN
  882.    idcmp := id.IDCMPFlagSet{};
  883.    WITH easyreq DO
  884.       structSize  := SIZE(id.EasyStruct);
  885.       flags       := LONGSET{};
  886.       title       := ll.GetCatalogStr(catalog, cxl.REQ_ABOUT_TITLE, ADR(cxl.REQ_ABOUT_TITLESTR));
  887.       textFormat  := ll.GetCatalogStr(catalog, cxl.REQ_ABOUT_BODY, ADR(cxl.REQ_ABOUT_BODYSTR));
  888.       gadgetFormat:= ll.GetCatalogStr(catalog, cxl.REQ_ABOUT_FORMAT, ADR(cxl.REQ_ABOUT_FORMATSTR));
  889.    END;
  890.    num := il.EasyRequestArgs(window, easyreq, idcmp, NIL);
  891. END About;
  892.  
  893. (* --------------------------------------------------------------- *)
  894.  
  895. PROCEDURE LoadOptions;
  896. (* Optionen laden und Menüleiste auffrischen. *)
  897. VAR
  898.     menuNum: CARDINAL;
  899.     menuItem: id.MenuItemPtr;
  900.     b: BOOLEAN;
  901. BEGIN
  902.     cxf.LoadOptions (options);
  903.     il.ClearMenuStrip (window);
  904.     WITH options DO
  905.         menuNum := im.ShiftMenu(OPTIONS)+im.ShiftItem(MAUTOSIZE);
  906.         menuItem := il.ItemAddress(menustrip, menuNum);
  907.         IF AUTOSIZE THEN
  908.             INCL (menuItem^.flags, id.checked);
  909.         ELSE
  910.             EXCL (menuItem^.flags, id.checked);
  911.         END;
  912.  
  913.         menuNum := im.ShiftMenu(OPTIONS)+im.ShiftItem(MSIZEABLE);
  914.         menuItem := il.ItemAddress(menustrip, menuNum);
  915.         IF SIZEABLE THEN
  916.             INCL (menuItem^.flags, id.checked);
  917.         ELSE
  918.             EXCL (menuItem^.flags, id.checked);
  919.         END;
  920.  
  921.         menuNum := im.ShiftMenu(OPTIONS)+im.ShiftItem(MREQUESTER);
  922.         menuItem := il.ItemAddress(menustrip, menuNum);
  923.         IF REQUESTER THEN
  924.             INCL (menuItem^.flags, id.checked);
  925.         ELSE
  926.             EXCL (menuItem^.flags, id.checked);
  927.         END;
  928.  
  929.         menuNum := im.ShiftMenu(OPTIONS)+im.ShiftItem(MREMOVEONLY);
  930.         menuItem := il.ItemAddress(menustrip, menuNum);
  931.         IF REMOVEONLY THEN
  932.             INCL (menuItem^.flags, id.checked);
  933.         ELSE
  934.             EXCL (menuItem^.flags, id.checked);
  935.         END;
  936.     END;
  937.     b := il.ResetMenuStrip (window, menustrip);
  938. END LoadOptions;
  939.  
  940. (* --------------------------------------------------------------- *)
  941.  
  942. VAR
  943.     time, ttime : Time;
  944.     lastitem    : INTEGER;  (* zuletzt selektierter Eintrag für korrekten Doppelklick *)
  945.  
  946. PROCEDURE HandleWindowMsg (VAR done: BOOLEAN);
  947. VAR
  948.     imsg: id.IntuiMessagePtr;
  949.     class: id.IDCMPFlagSet;
  950.     gadget: id.GadgetPtr;
  951.     code: CARDINAL;
  952.     qualifier: iv.QualifierSet;
  953.     char: CHAR;
  954.     a: INTEGER;
  955.     li: LONGINT;
  956.     tl: ARRAY [0..7] OF LONGINT;
  957. BEGIN
  958.     (*$ IF DEBUG *)
  959.         io.WriteString ("cxw.HandleWindowMsg()\n");
  960.     (*$ ENDIF *)
  961.     LOOP
  962.         imsg := gtl.GTGetIMsg(window^.userPort);
  963.         IF imsg # NIL THEN
  964.             class := imsg^.class;
  965.             gadget := CAST(id.GadgetPtr, imsg^.iAddress);
  966.             code := imsg^.code;
  967.             qualifier := imsg^.qualifier;
  968.             ttime.secs := imsg^.seconds;
  969.             ttime.micros := imsg^.micros;
  970.             gtl.GTReplyIMsg (imsg);
  971.  
  972.             IF id.closeWindow IN class THEN
  973.                 CloseWindow;
  974.             ELSIF id.newSize IN class THEN
  975.                 RescaleListview;
  976.             ELSIF id.gadgetUp IN class THEN
  977.                 (* In diesem Teil werden die Gadgets ausgewertet: *)
  978.                 CASE gadget^.gadgetID OF
  979.                     SHOWWINDOW: cxc.SendBrokerCommand (lvitem, cd.cxcmdAppear);
  980.                   | HIDEWINDOW: cxc.SendBrokerCommand (lvitem, cd.cxcmdDisappear);
  981.                   | INACTIVE: cxc.SendBrokerCommand (lvitem, cxc.activeToggle);
  982.                   | REMOVE: cxc.SendBrokerCommand (lvitem, cd.cxcmdKill);
  983.                   | DE_ACTIVEALL:
  984.                         DisEnableAll (disenableAllState);
  985.                   | REMOVEALL: KillAll;
  986.                   | LISTVIEW:
  987.                         lvitem := code;
  988.                         UpdateBroker (code);
  989.                         IF (il.DoubleClick(time.secs, time.micros, ttime.secs, ttime.micros))
  990.                            AND (lvitem = lastitem) THEN
  991.                             cxc.SendBrokerCommand (lvitem, cd.cxcmdAppear);
  992.                         ELSE
  993.                             (*time := ttime;*)
  994.                             time.secs := ttime.secs;
  995.                             time.micros := ttime.micros;
  996.                         END;
  997.                         lastitem := lvitem;
  998.                 ELSE
  999.                 END;
  1000.  
  1001.             ELSIF id.menuPick IN class THEN
  1002.                 (* Menüs auswerten: *)
  1003.                 CASE im.MenuNum(code) OF
  1004.                     PROJECT:
  1005.                     CASE im.ItemNum(code) OF
  1006.                         ABOUT: About;
  1007.                       | HIDE: CloseWindow;
  1008.                       | QUIT: done := TRUE;
  1009.                       ELSE
  1010.                     END;
  1011.                   | CONTROL:
  1012.                     CASE im.ItemNum(code) OF
  1013.                         ENABLEALL: cxc.SendAllBrokerCommand(cd.cxcmdEnable);
  1014.                       | DISABLEALL: cxc.SendAllBrokerCommand(cd.cxcmdDisable);
  1015.                       | KILLALL: KillAll;
  1016.                       ELSE
  1017.                     END;
  1018.                   | OPTIONS:
  1019.                     WITH options DO
  1020.                         CASE im.ItemNum(code) OF
  1021.                             MAUTOSIZE: AUTOSIZE := NOT(AUTOSIZE);
  1022.                           | MSIZEABLE:
  1023.                              CloseWindow;
  1024.                              SIZEABLE := ~SIZEABLE;
  1025.                              ShowWindow;
  1026.                           | MREQUESTER: REQUESTER := ~REQUESTER;
  1027.                           | MREMOVEONLY: REMOVEONLY := ~REMOVEONLY;
  1028.                                          RefreshListview;
  1029.                           | LOADOPTIONS: LoadOptions;
  1030.                           | SAVEOPTIONS: cxf.SaveOptions (options);
  1031.                           ELSE
  1032.                         END;
  1033.                     END;
  1034.                 ELSE
  1035.                 END;
  1036.  
  1037.             ELSIF id.refreshWindow IN class THEN
  1038.                 gtl.GTBeginRefresh(window);
  1039.                 gtl.DrawBevelBoxA (window^.rPort, BEVELBOX.left,
  1040.                     BEVELBOX.top, BEVELBOX.width, BEVELBOX.height,
  1041.                     TAG(tl, gtd.gtVisualInfo, visualinfo,
  1042.                         gtd.gtbbRecessed, TRUE,
  1043.                         tagEnd));
  1044.                 a := String.Length(CAST(StrPtr, ll.GetCatalogStr(catalog, cxl.GAD_INFORMATION, ADR(cxl.GAD_INFORMATIONSTR)))^);
  1045.                 gl.Move (window^.rPort, BEVELBOX.left + (BEVELBOX.width-(a*FONT.xsize)) DIV 2,
  1046.                     BEVELBOX.top-(FONT.ysize DIV 2)-2);
  1047.                 gl.SetAPen (window^.rPort, 1);
  1048.                 gl.Text (window^.rPort, ll.GetCatalogStr(catalog, cxl.GAD_INFORMATION, ADR(cxl.GAD_INFORMATIONSTR)), a);
  1049.                 gtl.GTEndRefresh(window, TRUE);
  1050.                 (*il.RefreshWindowFrame (window);*)
  1051.             ELSIF id.vanillaKey IN class THEN
  1052.                 char := CHAR(code);
  1053.                 IF char = ASCII.esc THEN CloseWindow;
  1054.                 ELSIF char = keyshortcut^[KEY_UP] THEN
  1055.                     lvitem := (lvitem-1) MOD brokercount;
  1056.                     UpdateListview (lvitem);
  1057.                 ELSIF char = keyshortcut^[KEY_DOWN] THEN
  1058.                     lvitem := (lvitem+1) MOD brokercount;
  1059.                     UpdateListview (lvitem);
  1060.                 ELSIF (char = ASCII.cr) OR (CAP(char) = keyshortcut^[KEY_SHOW]) THEN
  1061.                     cxc.SendBrokerCommand (lvitem, cd.cxcmdAppear);
  1062.                 ELSIF CAP(char) = keyshortcut^[KEY_HIDE] THEN
  1063.                     cxc.SendBrokerCommand (lvitem, cd.cxcmdDisappear);
  1064.                 ELSIF CAP(char) = keyshortcut^[KEY_DISENABLE] THEN
  1065.                     cxc.SendBrokerCommand (lvitem, cxc.activeToggle);
  1066.                 ELSIF CAP(char) = keyshortcut^[KEY_DISENABLEALL] THEN
  1067.                     DisEnableAll (disenableAllState);
  1068.                 ELSIF (char = ASCII.del) OR (CAP(char) = keyshortcut^[KEY_REMOVE]) THEN
  1069.                     cxc.SendBrokerCommand (lvitem, cd.cxcmdKill);
  1070.                 ELSE
  1071.                 END;
  1072.             ELSIF id.rawKey IN class THEN
  1073.                 CASE code OF
  1074.                     id.cursorUp:
  1075.                         IF (iv.lShift IN qualifier) OR
  1076.                            (iv.rShift IN qualifier) THEN
  1077.                             lvitem := 0;
  1078.                         ELSE
  1079.                             lvitem := (lvitem-1) MOD brokercount;
  1080.                         END;
  1081.                         UpdateListview (lvitem);
  1082.                   | id.cursorDown:
  1083.                         IF (iv.lShift IN qualifier) OR
  1084.                            (iv.rShift IN qualifier) THEN
  1085.                             lvitem := brokercount-1;
  1086.                         ELSE
  1087.                             lvitem := (lvitem+1) MOD brokercount;
  1088.                         END;
  1089.                         UpdateListview (lvitem);
  1090.                 ELSE
  1091.                 END;
  1092.             ELSE
  1093.             END;
  1094.         ELSE
  1095.             EXIT;
  1096.         END;
  1097.     END;
  1098. END HandleWindowMsg;
  1099.  
  1100. (* --------------------------------------------------------------- *)
  1101.  
  1102. VAR
  1103.     taglist: ARRAY [0..7] OF LONGINT;
  1104.     dummy: StrPtr;
  1105.  
  1106. BEGIN (* main *)
  1107.     Init;
  1108.  
  1109.     lvitem := 0;
  1110.  
  1111.     (* Katalog *)
  1112.     catalog := ll.OpenCatalogA (NIL, ADR("CX.catalog"), NIL);
  1113.     dummy := ll.GetCatalogStr(catalog, cxl.WINDOWTITLE, ADR(cxl.WINDOWTITLESTR));
  1114.     String.Copy (wintitle, dummy^);
  1115.     GetKeyShortcuts;
  1116.  
  1117.     cxc.InitBrokerList (brokercount);
  1118.     INC (brokercount);  (* Wir zählen schon mal jetzt Exchange noch
  1119.                          * dazu, damit das beim AUTOSIZE-Layouten auch
  1120.                          * richtig gut aussieht. *)
  1121.  
  1122. CLOSE
  1123.     CloseWindow;
  1124.     cxc.FreeBrokerList;
  1125.     IF catalog # NIL THEN
  1126.         ll.CloseCatalog(catalog);
  1127.         catalog := NIL;
  1128.     END;
  1129.     DeInitialisieren;
  1130. END CXWindow.
  1131.  
  1132.