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