home *** CD-ROM | disk | FTP | other *** search
/ Gold Fish 2 / goldfish_vol2_cd1.bin / files / dev / gui / mui / developer / oberon / txt / muibasics.mod < prev    next >
Text File  |  1994-07-02  |  73KB  |  2,031 lines
  1. (*------------------------------------------
  2.   :Module.      MuiBasics.mod
  3.   :Author.      Albert Weinert  [awn]
  4.   :Address.     Adamsstr. 83; 51063 Köln, Germany
  5.   :EMail.       a.weinert@darkness.gun.de
  6.   :Phone.       +49-221-613100
  7.   :Revision.    R.19
  8.   :Date.        02-Jul-1994
  9.   :Copyright.   FreeWare.
  10.   :Language.    Oberon-2
  11.   :Translator.  AmigaOberon V3.11
  12.   :Contents.    Die Makros die in "mui.h" definiert, waren als Prozeduren für Oberon
  13.   :Imports.     <Importiertes, Name/ShortCut des Autors>
  14.   :Remarks.     Bei VCenter, HCenter, Popup ist es etwas anders.
  15.   :Bugs.        <Bekannte Fehler>
  16.   :Usage.       <Angaben zur Anwendung>
  17.   :History.     .1     [awn] 22-Aug-1993 : Die Prozeduren die in Mui.mod waren nun
  18.   :History.            entfernt und ein seperates Modul daraus gemacht, so das
  19.   :History.            man nicht darauf angewiesen dies in seinem Interfaces zu haben.
  20.   :History.     .2     [awn] 24-Aug-1993 : Kräftig aufgeräumt um den erzeugten
  21.   :History.            Maschinencode so kurz wie möglich zu halten.
  22.   :History.     .3     [awn] 24-Aug-1993 : PopupEnd() so erweitert das nun ein
  23.   :History.            Objekt mit angeben werden kann, dies ist dafür gedacht wenn
  24.   :History.            man das Popup zu einem anderen Objekt anordnet (z.B String )
  25.   :History.     .4     [awn] 24-Aug-1993 : Im Zuge der Popup Änderung wurde eine
  26.   :History.            eigene Speziell auf Mui abgestimmte Hook Parameter übergabe
  27.   :History.            erstellt (Allerdings OS Konform eingebettet). Der Parameter
  28.   :History.            Deklaration der Hook-Prozedur muss nun so aussehen wie der
  29.   :History.            Typ `HookDef'.
  30.   :History.     .5     [awn] 25-Aug-1993 : Tipfehler bei TagItem2() und TagItem3()
  31.   :History.            entfernt.
  32.   :History.     .6     [awn] 25-Aug-1993 : Die Groups und Frames wieder mit der
  33.   :History.            Möglichkeit versehen dort TagListen zu übergeben.
  34.   :History.     .7     [awn] 30-Aug-1993 : PageGroup() hizugefügt.
  35.   :History.     .8     [awn] 14-Sep-1993 : Fehler bei Strings() dort wurde in der
  36.   :History.            Deklaration 2 mal A1 benutzt.
  37.   :History.     .9     [awn] 03-Oct-1993 : Eine einfache Plausibiltätsprüfung eingebaut.
  38.   :History.            Für jede #?Object() Prozedur gibt es nun ein End#?() Prozedure,
  39.   :History.            wenn der Objekt Typ nicht übereinstimmt wird ein NIL zurückgeben.
  40.   :History.            Dies ist dafür um während der Programmentwicklung Abstürze zu
  41.   :History.            umgehen, wenn das Programm einmal steht sind diese nicht mehr
  42.   :History.            notwendig, aber brauchen nicht entfernt zu werden.
  43.   :History.     .10    [awn] 30-Oct-1993 : An MUI 1.4 angepasst, die neuen Objekte
  44.   :History.            hinzugefügt (Coloradjust, Colorfield, Palette, Virtgroup, Scrollgroup
  45.   :History.            und Scrmodelist), die Group Prozeduren gibt es nun auch für Virtgroups
  46.   :History.            z.B. HGroupV(). Sonstige neue Prozeduren, KeyRadio(), Slider(), KeySlider(),
  47.   :History.            LLabelX() und KeyLLabelX().
  48.   :History.     .11    [awn] 31-Jan-1994 : Angepasst an MUI 1.5, Fehler bei SliderObject()
  49.   :History.            entfernt (Rief RadioObject auf). Es gibt nun für *jede* Objekt ein
  50.   :History.            passendes. Bei Popupend() wird nun auch das Background Image gesetzt.
  51.   :History.            [Report: Peter Elzner]
  52.   :History.     .12    [awn] 02-Feb-1994 : INewObject() und IEnd() aufgenommen, der Aufruf
  53.   :History.            von INewObject() ist wie der von Intuition.NewObject() nur ohne
  54.   :History.            Rückgabeparamter. INewObject() muss *anstatt* Intuition.NewObject()
  55.   :History.            aufgerufen werden wenn die Objekte direkt mit ins Layout sollen.
  56.   :History.            INewObject() *muss* ein IEnd() bzw. iEnd() folgen. siehe Class1.mod
  57.   :History.     .13    [awn] 05-Feb-1994 : VSlider() und KeyVSlider() aufgenommen.
  58.   :History.     .14    [awn] 17-Feb-1994 : Bei Checkmark(); KeyCheckmark(), String() und
  59.   :History.            KeyString() ist es nun auch möglich Tags zu übergeben.
  60.   :History.            KeyVSlider() ist nun wirklich ein VSlider. PopButton() hinzugefügt.
  61.   :History.            Der Register.mui Support ist nun auch drin.
  62.   :History.            HBar() und VBar() erstellt, erzeugen die entsprechenden Bars.
  63.   :History.     .15    [awn] 22-Feb-1994 : Integer() und KeyInteger() für Integer-
  64.   :History.            Objekte hinzugefügt.
  65.   :History.     .16    [awn] 27-Feb-1994 : Bei etlichen Prozeduren habe ich vergessen
  66.   :History.            die Register zu retten, so das CheckMark() und KeyCheckMark()
  67.   :History.            nicht zufriedenstellend funktionierte [Report: Volker Rudolph]
  68.   :History.     .17    [awn] 05-Apr-1994 : Bei CheckMark() funktioniert die Initiali-
  69.   :History.            sierung jetzt. Scrollbar(), KeyScrollBar(), VScrollBar() usw.
  70.   :History.            Prozeduren für die entsprechenden Objekte erstellt.
  71.   :History.     .18    [awn] 15-May-1994 : Bei CheckMarkA() die Parameter etwas
  72.   :History.            geändert, so das dieses nun auch richtig funktioniert.
  73.   :History.     .19    [awn] 02-Jul-1994 : ClassTree overview updated, updated
  74.   :History.            to MUI 2.1, major code cleanup (now, produces shorter code).
  75.   :History.            In lack of time, i didn't optimize the label prozedures.
  76.   :History.            The behavior fo the End#?() procedures changes, if the wrong
  77.   :History.            object type, the programm terminates with an RC=100, also
  78.   :History.            now there added end#?() proecedures, so that you don't must
  79.   :History.            check the result if you want only have a little typeguard.
  80.  
  81. --------------------------------------------*)
  82. MODULE MuiBasics;
  83.  
  84. IMPORT e * := Exec,
  85.        I * := Intuition,
  86.        m * := Mui,
  87.        u * := Utility,
  88.        y   :=SYSTEM;
  89.  
  90. CONST   ArrayAdd = 24;
  91.  
  92. TYPE
  93.   TagArray * = UNTRACED POINTER TO ARRAY OF u.TagItem;
  94.   Class    * = UNTRACED POINTER TO ClassDesc;
  95.   Args     * = UNTRACED POINTER TO ArgsDesc;
  96.   Hook     * = UNTRACED POINTER TO HookDesc;
  97.  
  98.   ClassDesc = STRUCT( n : e.Node );
  99.                 name   : ARRAY 32 OF CHAR;
  100.                 iclass : I.IClassPtr;
  101.                 tags   : TagArray;
  102.                 tagnum : LONGINT;
  103.                 tagdata : BOOLEAN;
  104.               END;
  105.  
  106.   ArgsDesc * = STRUCT END;
  107.  
  108.   PopupArgs * = STRUCT ( d : ArgsDesc );
  109.                   linkedObj : m.Object (* Das Objekt zu dem das Popup Object gelinkt ist *)
  110.                 END;
  111.   HookDef * = PROCEDURE ( hook : Hook; object : m.Object; args : Args ):LONGINT;
  112.  
  113.  
  114. (* Hook-Example.
  115.  *
  116.  *  TYPE  PopWindowArgs = STRUCT( d : MuiBasics.ArgsDesc );
  117.  *                          window : m.Object;
  118.  *                        END;
  119.  *
  120.  *  VAR myHook : MuiBasics.Hook;
  121.  *      button : m.Object;
  122.  *      window : m.Object;
  123.  *
  124.  *  PROCEDURE PopWindow( hook : Hook; object : m.Object; args : Args ) : LONGINT;
  125.  *    BEGIN
  126.  *      IF args # NIL THEN
  127.  *        IF args(PopWindowArgs).window # NIL THEN
  128.  *          m.DoMethod( args(PopWindowArgs).window, m.mWindowToFront );
  129.  *        END;
  130.  *      END;
  131.  *      RETURN 0;
  132.  *    END PopWindow;
  133.  *
  134.  *  BEGIN
  135.  *    [... create Application Windows ...]
  136.  *
  137.  *    myHook := MuiBasics.MakeHook( PopWindow );
  138.  *    IF myHook # NIL THEN
  139.  *      m.DoMethod( button, m.mNotify, m.aPressed, e.false,
  140.  *                    button, 3, m.mCallHook, myHook, window );
  141.  *    END;
  142.  *    [... Do the other magic ...]
  143.  *
  144.  * Note: Typed on the fly, no warranty is given that this piece of code reallay work.
  145.  *)
  146.  
  147.   HookDesc * = STRUCT( minNode : e.MinNode );
  148.              entry     : PROCEDURE ( hook{8}   : Hook;
  149.                                      object{10}: m.Object;
  150.                                      args{9}: Args ):LONGINT;
  151.              subEntry  : HookDef;
  152.              a5 : e.APTR;
  153.  
  154.              object : m.Object;
  155.            END;
  156.  
  157. VAR no * : e.List;
  158.  
  159.   (* ---- MuiBasics Hook-Dispatcher ---- *)
  160.   PROCEDURE HookEntry*(hook{8}: Hook;               (* $SaveRegs+ $StackChk- *)
  161.                        object{10}: m.Object;
  162.                        args{9}: Args): LONGINT;
  163.   (*
  164.    * Calls hook.subEntry. The contents of A5 have to be stored in hook.a5,
  165.    * else A5 would not be set correctly.
  166.    *)
  167.   
  168.   BEGIN
  169.     y.SETREG(13,hook.a5);
  170.     RETURN hook.subEntry(hook,object,args);
  171.   END HookEntry;
  172.  
  173.   PROCEDURE MakeHook* ( entry: HookDef ):Hook;
  174.   (*------------------------------------------
  175.     :Input.     entry : Prozedure die gestartet werden soll, wenn der Hook
  176.     :Input.             aufgerufen wird.
  177.     :Output.    Hook der direkt einsatzfähig ist (oder NIL, falls es nicht
  178.     :Output.    geklappt haben sollte).
  179.     :Semantic.  Erstellt einen Hook und bindet die Prozedure ein.
  180.     :Note.
  181.     :Update.    24-Aug-1993 [awn] - erstellt.
  182.   --------------------------------------------*)
  183.     VAR hook : Hook;
  184.   BEGIN
  185.     NEW( hook );
  186.     IF hook # NIL THEN
  187.       hook.entry := HookEntry;
  188.       hook.subEntry := entry;
  189.       hook.a5 := y.REG(13);
  190.     END;
  191.     RETURN hook;
  192.   END MakeHook;
  193.  
  194.   PROCEDURE SetHookObject*( hook : Hook; object : m.Object );
  195.   (*------------------------------------------
  196.     :Input.     hook : Initialisierte Hook;
  197.     :Input.     object : Das Object zu wem der Hook gelinkt ist.
  198.     :Output.
  199.     :Semantic.  Trägt in die Hook-Struktur ein Object ein, so
  200.     :Semantic.  das man später noch darauf zugreifen kann.
  201.     :Note.
  202.     :Update.    24-Aug-1993 [awn] - erstellt.
  203.   --------------------------------------------*)
  204.     BEGIN
  205.       IF hook # NIL THEN
  206.         hook.object := object;
  207.       END;
  208.     END SetHookObject;
  209.  
  210.   PROCEDURE GetHookObject*( hook : Hook ):m.Object;
  211.   (*------------------------------------------
  212.     :Input.     hook : Ein Hook
  213.     :Output.    Das Objekt welches in der Hook Struktur eingetragen ist
  214.     :Semantic.
  215.     :Note.
  216.     :Update.    24-Aug-1993 [awn] - erstellt.
  217.   --------------------------------------------*)
  218.     BEGIN
  219.       IF hook # NIL THEN
  220.         RETURN hook.object;
  221.       END;
  222.     END GetHookObject;
  223.  
  224.   PROCEDURE Init();
  225.     BEGIN
  226.       no.head := y.ADR( no.tail );
  227.       no.tail := NIL;
  228.       no.tailPred := y.ADR( no.head );
  229.     END Init;
  230.  
  231.   PROCEDURE NewClass*();
  232.   (* $SaveRegs+ *)
  233.     VAR cl : Class;
  234.     BEGIN
  235.       NEW( cl );
  236.  
  237.       (* $IF GarbageCollector *)
  238.  
  239.       e.AddTail( no, cl );
  240.  
  241.       (* $ELSE *)
  242.  
  243.       IF cl # NIL THEN
  244.         e.AddTail( no, y.VAL( e.CommonNodePtr, cl ) );
  245.         cl.tagdata := FALSE;
  246.       END;
  247.  
  248.       (* $END *)
  249.     END NewClass;
  250.  
  251.   PROCEDURE CheckAndExpandTags( cl : Class;  n : LONGINT);
  252.   (* $SaveRegs+ *)
  253.     VAR newtags : TagArray;
  254.         ShouldLen, MaxLen, i : LONGINT;
  255.  
  256.     BEGIN
  257.       IF n = 0 THEN RETURN END;
  258.       IF cl.tags # NIL THEN
  259.         ShouldLen := cl.tagnum + n;
  260.         MaxLen := LEN( cl.tags^ )-1;
  261.         IF ShouldLen >= MaxLen THEN
  262.           INC( ShouldLen, ArrayAdd );
  263.           y.ALLOCATE( newtags, ShouldLen );
  264.           FOR i := 0 TO cl.tagnum-1 DO
  265.             newtags[i] := cl.tags[i];
  266.           END;
  267.  
  268.           (* $IF GarbageCollector *)
  269.  
  270.             cl.tags := newtags;
  271.  
  272.           (* $ELSE *)
  273.  
  274.             DISPOSE( cl.tags );
  275.             cl.tags := newtags;
  276.  
  277.           (* $END *)
  278.         END;
  279.       ELSE
  280.         ShouldLen := ArrayAdd + n ;
  281.         NEW( cl.tags, ShouldLen );
  282.         cl.tagnum := 0;
  283.       END;
  284.     END CheckAndExpandTags;
  285.  
  286.   PROCEDURE clTag ( cl : Class;  tag : e.APTR );
  287.   (* $SaveRegs+ *)
  288.     BEGIN
  289.       CheckAndExpandTags( cl, 1 );
  290.       IF cl.tags # NIL THEN
  291.         IF cl.tagdata THEN
  292.           cl.tags[cl.tagnum].data := tag;
  293.           cl.tagdata := FALSE;
  294.           INC( cl.tagnum );
  295.         ELSE
  296.           cl.tags[cl.tagnum].tag := tag;
  297.           cl.tagdata := TRUE;
  298.         END;
  299.       END;
  300.     END clTag;
  301.  
  302.   PROCEDURE clTagItem ( cl : Class;  tag, data : e.APTR );
  303.   (* $SaveRegs+ *)
  304.     BEGIN
  305.       CheckAndExpandTags( cl, 1 );
  306.       IF cl.tags # NIL THEN
  307.         cl.tags[cl.tagnum].data := data;
  308.         cl.tags[cl.tagnum].tag := tag;
  309.         INC( cl.tagnum );
  310.       END;
  311.     END clTagItem;
  312.  
  313.   PROCEDURE countTag( tags{9} : u.TagListPtr) : LONGINT;
  314.   (* $SaveRegs+ *)
  315.     VAR i, j : LONGINT;
  316.     BEGIN
  317.       i := 0; j := 0;
  318.       WHILE (tags # NIL) & (tags[j].tag # u.end) DO
  319.         IF tags[j].tag = u.more THEN
  320.           tags := tags[j].data;
  321.           j := 0;
  322.         ELSE
  323.           INC(i); INC(j);
  324.         END;
  325.       END;
  326.       RETURN i;
  327.     END countTag;
  328.  
  329.   PROCEDURE clTagsA*( cl{8} : Class;  tags{9} : u.TagListPtr );
  330.   (* $SaveRegs+ *)
  331.     VAR  i : LONGINT;
  332.  
  333.     BEGIN
  334.       IF tags = NIL THEN RETURN END;
  335.       CheckAndExpandTags( cl, countTag( tags ) );
  336.       i:=0;
  337.       IF cl.tags # NIL THEN
  338.         WHILE (tags#NIL) & (tags[i].tag # u.end) DO
  339.           IF tags[i].tag = u.more THEN
  340.             tags := tags[i].data;
  341.             i := 0;
  342.           ELSE
  343.             cl.tags[cl.tagnum] := tags[i];
  344.             INC(cl.tagnum); INC(i);
  345.           END;
  346.         END;
  347.       END;
  348.     END clTagsA;
  349.  
  350.   PROCEDURE clTags{"MuiBasics.clTagsA"} ( cl{8} : Class;  tags{9}.. : u.Tag );
  351.  
  352.   PROCEDURE TagsA*( tags{9} : u.TagListPtr );
  353.   (* $SaveRegs+ *)
  354.     BEGIN
  355.       IF no.tailPred # y.ADR( no.head ) THEN;
  356.         clTagsA( y.VAL( Class, no.tailPred ), tags );
  357.       END;
  358.     END TagsA;
  359.  
  360.   PROCEDURE Tags*{"MuiBasics.TagsA"} ( tags{9}.. : u.Tag );
  361.  
  362.   PROCEDURE Tag*( tag : e.APTR );
  363.   (* $SaveRegs+ *)
  364.     BEGIN
  365.       IF no.tailPred # y.ADR( no.head )  THEN
  366.         clTag( y.VAL( Class, no.tailPred ), tag );
  367.       END;
  368.     END Tag;
  369.  
  370.   PROCEDURE TagItem*( tag, data : e.APTR );
  371.   (* $SaveRegs+ *)
  372.     BEGIN
  373.       IF no.tailPred # y.ADR( no.head )  THEN
  374.         clTagItem( y.VAL( Class, no.tailPred ), tag, data );
  375.       END;
  376.     END TagItem;
  377.  
  378.   PROCEDURE TagItem2*( tag1, data1, tag2, data2 : e.APTR );
  379.   (* $SaveRegs+ *)
  380.     BEGIN
  381.       IF no.tailPred # y.ADR( no.head )  THEN
  382.         clTagItem( y.VAL( Class, no.tailPred ), tag1, data1 );
  383.         clTagItem( y.VAL( Class, no.tailPred ), tag2, data2 );
  384.       END;
  385.     END TagItem2;
  386.  
  387.   PROCEDURE TagItem3*( tag1, data1, tag2, data2, tag3, data3 : e.APTR );
  388.   (* $SaveRegs+ *)
  389.     BEGIN
  390.       IF no.tailPred # y.ADR( no.head )  THEN
  391.         clTagItem( y.VAL( Class, no.tailPred ), tag1, data1 );
  392.         clTagItem( y.VAL( Class, no.tailPred ), tag2, data2 );
  393.         clTagItem( y.VAL( Class, no.tailPred ), tag3, data3 );
  394.       END;
  395.     END TagItem3;
  396.  
  397.   PROCEDURE DEnd(mui : BOOLEAN):m.Object;
  398.   (* $SaveRegs+ *)
  399.     VAR cl : e.NodePtr;
  400.         ret : e.APTR;
  401.  
  402.     BEGIN
  403.       ret := NIL;
  404.       cl := no.tailPred;
  405.       WITH cl : Class DO
  406.  
  407.         IF cl.tags # NIL THEN
  408.           cl.tags[cl.tagnum].tag:=u.end;
  409.           IF mui THEN
  410.             ret := m.NewObject( cl.name, u.more, y.ADR(cl.tags^) );
  411.           ELSE
  412.             IF cl.iclass # NIL THEN
  413.               ret := I.NewObject( cl.iclass, NIL, u.more, y.ADR(cl.tags^) );
  414.             ELSE
  415.               ret := I.NewObject( NIL, cl.name, u.more, y.ADR(cl.tags^) );
  416.             END;
  417.           END;
  418.         ELSE
  419.           IF mui THEN
  420.             ret := m.NewObject( cl.name );
  421.           ELSE
  422.             IF cl.iclass # NIL THEN
  423.               ret := I.NewObject( cl.iclass, NIL );
  424.             ELSE
  425.               ret := I.NewObject( NIL, cl.name );
  426.             END;
  427.           END;
  428.         END;
  429.  
  430.         e.Remove( cl );
  431.  
  432.         (* $IFNOT GarbageCollector *)
  433.  
  434.           DISPOSE( cl.tags );
  435.           DISPOSE( cl );
  436.  
  437.         (* $END *)
  438.  
  439.  
  440.         IF no.tailPred # y.ADR( no.head ) THEN
  441.           clTag( y.VAL( Class, no.tailPred ), ret );
  442.         END;
  443.  
  444.       END;
  445.       RETURN ret;
  446.     END DEnd;
  447.  
  448.   PROCEDURE End*():m.Object;
  449.   (* $SaveRegs+ *)
  450.     BEGIN
  451.       RETURN DEnd( TRUE );
  452.     END End;
  453.  
  454.   PROCEDURE end*();
  455.   (* $SaveRegs+ *)
  456.     BEGIN
  457.       y.SETREG( 0, End() );
  458.     END end;
  459.  
  460.   PROCEDURE IEnd*():m.Object;
  461.   (* $SaveRegs+ *)
  462.     BEGIN
  463.       RETURN DEnd( FALSE );
  464.     END IEnd;
  465.  
  466.   PROCEDURE iEnd*();
  467.   (* $SaveRegs+ *)
  468.     BEGIN
  469.       y.SETREG( 0, IEnd() );
  470.     END iEnd;
  471.  
  472.   PROCEDURE EndObject( objname : ARRAY OF CHAR ):m.Object;
  473.     BEGIN
  474.       IF m.cApplication # no.tailPred(Class).name THEN HALT(100) END;
  475.       RETURN End();
  476.     END EndObject;
  477.  
  478.   PROCEDURE endFamily*{"MuiBasics.EndFamily"};
  479.   PROCEDURE EndFamily*():m.Object; BEGIN RETURN EndObject( m.cFamily ) END EndFamily;
  480.   PROCEDURE endMenustrip*{"MuiBasics.EndMenustrip"};
  481.   PROCEDURE EndMenustrip*():m.Object; BEGIN RETURN EndObject( m.cMenustrip ) END EndMenustrip;
  482.   PROCEDURE endMenu*{"MuiBasics.EndMenu"};
  483.   PROCEDURE EndMenu*():m.Object; BEGIN RETURN EndObject( m.cMenu ) END EndMenu;
  484.   PROCEDURE endMenuT*{"MuiBasics.EndMenuT"};
  485.   PROCEDURE EndMenuT*():m.Object; BEGIN RETURN EndObject( m.cMenu ) END EndMenuT;
  486.   PROCEDURE endMenuitem*{"MuiBasics.EndMenuitem"};
  487.   PROCEDURE EndMenuitem*():m.Object; BEGIN RETURN EndObject( m.cMenuitem ) END EndMenuitem;
  488.   PROCEDURE endWindow*{"MuiBasics.EndWindow"};
  489.   PROCEDURE EndWindow*():m.Object; BEGIN RETURN EndObject( m.cWindow ) END EndWindow;
  490.   PROCEDURE endImage*{"MuiBasics.EndImage"};
  491.   PROCEDURE EndImage*():m.Object; BEGIN RETURN EndObject( m.cImage ) END EndImage;
  492.   PROCEDURE endBitmap*{"MuiBasics.EndBitmap"};
  493.   PROCEDURE EndBitmap*():m.Object; BEGIN RETURN EndObject( m.cBitmap ) END EndBitmap;
  494.   PROCEDURE endBodychunk*{"MuiBasics.EndBodychunk"};
  495.   PROCEDURE EndBodychunk*():m.Object; BEGIN RETURN EndObject( m.cImage ) END EndBodychunk;
  496.   PROCEDURE endNotify*{"MuiBasics.EndNotify"};
  497.   PROCEDURE EndNotify*():m.Object; BEGIN RETURN EndObject( m.cNotify ) END EndNotify;
  498.   PROCEDURE endApplication*{"MuiBasics.EndApplication"};
  499.   PROCEDURE EndApplication*():m.Object; BEGIN RETURN EndObject( m.cApplication ) END EndApplication;
  500.   PROCEDURE endText*{"MuiBasics.EndText"};
  501.   PROCEDURE EndText*():m.Object; BEGIN RETURN EndObject( m.cText ) END EndText;
  502.   PROCEDURE endRectangle*{"MuiBasics.EndRectangle"};
  503.   PROCEDURE EndRectangle*():m.Object; BEGIN RETURN EndObject( m.cRectangle ) END EndRectangle;
  504.   PROCEDURE endList*{"MuiBasics.EndList"};
  505.   PROCEDURE EndList*():m.Object; BEGIN RETURN EndObject( m.cList ) END EndList;
  506.   PROCEDURE endProp*{"MuiBasics.EndProp"};
  507.   PROCEDURE EndProp*():m.Object; BEGIN RETURN EndObject( m.cProp ) END EndProp;
  508.   PROCEDURE endString*{"MuiBasics.EndString"};
  509.   PROCEDURE EndString*():m.Object; BEGIN RETURN EndObject( m.cString ) END EndString;
  510.   PROCEDURE endScrollbar*{"MuiBasics.EndScrollbar"};
  511.   PROCEDURE EndScrollbar*():m.Object; BEGIN RETURN EndObject( m.cScrollbar ) END EndScrollbar;
  512.   PROCEDURE endListview*{"MuiBasics.EndListview"};
  513.   PROCEDURE EndListview*():m.Object; BEGIN RETURN EndObject( m.cListview ) END EndListview;
  514.   PROCEDURE endRadio*{"MuiBasics.EndRadio"};
  515.   PROCEDURE EndRadio*():m.Object; BEGIN RETURN EndObject( m.cRadio ) END EndRadio;
  516.   PROCEDURE endVolumelist*{"MuiBasics.EndVolumelist"};
  517.   PROCEDURE EndVolumelist*():m.Object; BEGIN RETURN EndObject( m.cVolumelist ) END EndVolumelist;
  518.   PROCEDURE endFloattext*{"MuiBasics.EndFloattext"};
  519.   PROCEDURE EndFloattext*():m.Object; BEGIN RETURN EndObject( m.cFloattext ) END EndFloattext;
  520.   PROCEDURE endDirlist*{"MuiBasics.EndDirlist"};
  521.   PROCEDURE EndDirlist*():m.Object; BEGIN RETURN EndObject( m.cDirlist ) END EndDirlist;
  522.   PROCEDURE endSlider*{"MuiBasics.EndSlider"};
  523.   PROCEDURE EndSlider*():m.Object; BEGIN RETURN EndObject( m.cSlider ) END EndSlider;
  524.   PROCEDURE endCycle*{"MuiBasics.EndCycle"};
  525.   PROCEDURE EndCycle*():m.Object; BEGIN RETURN EndObject( m.cCycle ) END EndCycle;
  526.   PROCEDURE endGauge*{"MuiBasics.EndGauge"};
  527.   PROCEDURE EndGauge*():m.Object; BEGIN RETURN EndObject( m.cGauge ) END EndGauge;
  528.   PROCEDURE endScale*{"MuiBasics.EndScale"};
  529.   PROCEDURE EndScale*():m.Object; BEGIN RETURN EndObject( m.cScale ) END EndScale;
  530.   PROCEDURE endBoopsi*{"MuiBasics.EndBoopsi"};
  531.   PROCEDURE EndBoopsi*():m.Object; BEGIN RETURN EndObject( m.cBoopsi ) END EndBoopsi;
  532.   PROCEDURE endColorfield*{"MuiBasics.EndColorfield"};
  533.   PROCEDURE EndColorfield*():m.Object; BEGIN RETURN EndObject( m.cColorfield ) END EndColorfield;
  534.   PROCEDURE endColorpanel*{"MuiBasics.EndColorpanel"};
  535.   PROCEDURE EndColorpanel*():m.Object; BEGIN RETURN EndObject( m.cColorpanel ) END EndColorpanel;
  536.   PROCEDURE endColoradjust*{"MuiBasics.EndColoradjust"};
  537.   PROCEDURE EndColoradjust*():m.Object; BEGIN RETURN EndObject( m.cColoradjust ) END EndColoradjust;
  538.   PROCEDURE endPalette*{"MuiBasics.EndPalette"};
  539.   PROCEDURE EndPalette*():m.Object; BEGIN RETURN EndObject( m.cPalette ) END EndPalette;
  540.   PROCEDURE endGroup*{"MuiBasics.EndGroup"};
  541.   PROCEDURE EndGroup*():m.Object; BEGIN RETURN EndObject( m.cGroup ) END EndGroup;
  542.   PROCEDURE endRegister*{"MuiBasics.EndRegister"};
  543.   PROCEDURE EndRegister*():m.Object; BEGIN RETURN EndObject( m.cRegister ) END EndRegister;
  544.   PROCEDURE endVirtgroup*{"MuiBasics.EndVirtgroup"};
  545.   PROCEDURE EndVirtgroup*():m.Object; BEGIN RETURN EndObject( m.cVirtgroup ) END EndVirtgroup;
  546.   PROCEDURE endScrollgroup*{"MuiBasics.EndScrollgroup"};
  547.   PROCEDURE EndScrollgroup*():m.Object; BEGIN RETURN EndObject( m.cScrollgroup ) END EndScrollgroup;
  548.   PROCEDURE endPopstring*{"MuiBasics.EndPopstring"};
  549.   PROCEDURE EndPopstring*():m.Object; BEGIN RETURN EndObject( m.cPopstring ) END EndPopstring;
  550.   PROCEDURE endPopobject*{"MuiBasics.EndPopobject"};
  551.   PROCEDURE EndPopobject*():m.Object; BEGIN RETURN EndObject( m.cPopobject ) END EndPopobject;
  552.   PROCEDURE endPoplist*{"MuiBasics.EndPoplist"};
  553.   PROCEDURE EndPoplist*():m.Object; BEGIN RETURN EndObject( m.cPoplist ) END EndPoplist;
  554.   PROCEDURE endPopasl*{"MuiBasics.EndPopasl"};
  555.   PROCEDURE EndPopasl*():m.Object; BEGIN RETURN EndObject( m.cPopasl ) END EndPopasl;
  556.   PROCEDURE endScrmodelist*{"MuiBasics.EndScrmodelist"};
  557.   PROCEDURE EndScrmodelist*():m.Object; BEGIN RETURN EndObject( m.cScrmodelist ) END EndScrmodelist;
  558.   PROCEDURE endVGroup*{"MuiBasics.EndVGroup"};
  559.   PROCEDURE EndVGroup*():m.Object; BEGIN RETURN EndGroup(); END EndVGroup;
  560.   PROCEDURE endHGroup*{"MuiBasics.EndHGroup"};
  561.   PROCEDURE EndHGroup*():m.Object; BEGIN RETURN EndGroup(); END EndHGroup;
  562.   PROCEDURE endColGroup*{"MuiBasics.EndColGroup"};
  563.   PROCEDURE EndColGroup*():m.Object; BEGIN RETURN EndGroup(); END EndColGroup;
  564.   PROCEDURE endRowGroup*{"MuiBasics.EndRowGroup"};
  565.   PROCEDURE EndRowGroup*():m.Object; BEGIN RETURN EndGroup(); END EndRowGroup;
  566.   PROCEDURE endPageGroup*{"MuiBasics.EndPageGroup"};
  567.   PROCEDURE EndPageGroup*():m.Object; BEGIN RETURN EndGroup(); END EndPageGroup;
  568.   PROCEDURE endVGroupV*{"MuiBasics.EndVGroupV"};
  569.   PROCEDURE EndVGroupV*():m.Object; BEGIN RETURN EndVirtgroup(); END EndVGroupV;
  570.   PROCEDURE endHGroupV*{"MuiBasics.EndHGroupV"};
  571.   PROCEDURE EndHGroupV*():m.Object; BEGIN RETURN EndVirtgroup(); END EndHGroupV;
  572.   PROCEDURE endColGroupV*{"MuiBasics.EndColGroupV"};
  573.   PROCEDURE EndColGroupV*():m.Object; BEGIN RETURN EndVirtgroup(); END EndColGroupV;
  574.   PROCEDURE endRowGroupV*{"MuiBasics.EndRowGroupV"};
  575.   PROCEDURE EndRowGroupV*():m.Object; BEGIN RETURN EndVirtgroup(); END EndRowGroupV;
  576.   PROCEDURE endPageGroupV*{"MuiBasics.EndPageGroupV"};
  577.   PROCEDURE EndPageGroupV*():m.Object; BEGIN RETURN EndVirtgroup(); END EndPageGroupV;
  578.   PROCEDURE endRegisterGroup*{"MuiBasics.EndRegisterGroup"};
  579.   PROCEDURE EndRegisterGroup*():m.Object; BEGIN RETURN EndObject( m.cRegister ) END EndRegisterGroup;
  580.  
  581.   PROCEDURE NewObjectA*( name{8} : e.STRPTR; tags{9} : u.TagListPtr );
  582.   (* $SaveRegs+ *)
  583.     BEGIN
  584.       NewClass();
  585.       COPY( name^, no.tailPred(Class).name );
  586.       TagsA( tags );
  587.     END NewObjectA;
  588.  
  589.   PROCEDURE NewObject{"MuiBasics.NewObjectA"} ( name {8} : ARRAY OF CHAR; tags{9}.. : u.Tag );
  590.  
  591.  
  592.   PROCEDURE INewObjectA*( iclass{8} : I.IClassPtr; name{9}: e.STRPTR; tags{10} : u.TagListPtr );
  593.   (* $SaveRegs+ *)
  594.     BEGIN
  595.       NewClass();
  596.       IF name # NIL THEN
  597.         COPY( name^, no.tailPred(Class).name );
  598.       END;
  599.       no.tailPred(Class).iclass := iclass;
  600.       TagsA( tags );
  601.     END INewObjectA;
  602.  
  603.   PROCEDURE INewObject*{"MuiBasics.INewObjectA"}( iclass{8} : I.IClassPtr; name {9} : ARRAY OF CHAR; tags{10}.. : u.Tag );
  604.  
  605. (***************************************************************************
  606. ** Class Tree
  607. ****************************************************************************
  608. **
  609. ** rootclass               (B00PSI's base class)
  610. ** +--Notify               (implements notification mechanism)
  611. **    +--Family            (handles multiple children)
  612. **    !  +--Menustrip      (describes a complete menu strip)
  613. **    !  +--Menu           (describes a single menu)
  614. **    !  \--Menuitem       (describes a single menu item)
  615. **    +--Application       (main class for all applications)
  616. **    +--Window            (handles intuition window related topics)
  617. **    +--Area              (base class for all GUI elements)
  618. **       +--Rectangle      (creates (empty) rectangles)
  619. **       +--Image          (creates images)
  620. **       +--Text           (creates some text)
  621. **       +--String         (creates a string gadget)
  622. **       +--Prop           (creates a proportional gadget)
  623. **       +--Gauge          (creates a fule gauge)
  624. **       +--Scale          (creates a percentage scale)
  625. **       +--Boopsi         (interface to B00PSI gadgets)
  626. **       +--Colorfield     (creates a field with changeable color)
  627. **       +--List           (creates a line-oriented list)
  628. **       !  +--Floattext   (special list with floating text)
  629. **       !  +--Volumelist  (special list with volumes)
  630. **       !  +--Scrmodelist (special list with screen modes)
  631. **       !  \--Dirlist     (special list with files)
  632. **       +--Group          (groups other GUI elements)
  633. **          +--Register    (handles page groups with titles)
  634. **          +--Virtgroup   (handles virtual groups)
  635. **          +--Scrollgroup (handles virtual groups with scrollers)
  636. **          +--Scrollbar   (creates a scrollbar)
  637. **          +--Listview    (creates a listview)
  638. **          +--Radio       (creates radio buttons)
  639. **          +--Cycle       (creates cycle gadgets)
  640. **          +--Slider      (creates slider gadgets)
  641. **          +--Coloradjust (creates some RGB sliders)
  642. **          +--Palette     (creates a complete palette gadget)
  643. **          +--Colorpanel  (creates a panel of colors)
  644. **          +--Popstring   (base class for popups)
  645. **             +--Popobject(popup a MUI object in a window)
  646. **             \--Popasl   (popup an asl requester)
  647. **
  648. **************************************************************)
  649.  
  650. (**************************************************************************
  651. **
  652. ** Object Generation
  653. ** -----------------
  654. **
  655. ** The xxxObject (and xChilds) procedures generate new instances of MUI classes.
  656. ** Every xxxObject can be followed by tagitems specifying initial create
  657. ** time attributes for the new object and must be terminated with the
  658. ** End macro:
  659. **
  660. ** StringObject;
  661. **          TagItem2( m.aStringContents, "foo",
  662. **                    m.aStringMaxLen  , 40 );
  663. ** obj := End();
  664. **
  665. ** With the Child, SubWindow and WindowContents shortcuts you can
  666. ** construct a complete GUI within one command:
  667. **
  668. ** ApplicationObject;
  669. **
  670. **          ...
  671. **
  672. **          SubWindow; WindowObject;
  673. **             WindowContents; VGroup;
  674. **                Child; String("foo",40);
  675. **                Child; String("bar",50);
  676. **                Child; HGroup;
  677. **                   Child; CheckMark(TRUE);
  678. **                   Child; CheckMark(FALSE);
  679. **                   end;
  680. **                end;
  681. **             end;
  682. **
  683. **          SubWindow; WindowObject;
  684. **             WindowContents; HGroup;
  685. **                Child; ...;
  686. **                Child; ...;
  687. **                end;
  688. **             end;
  689. **
  690. **          ...
  691. **
  692. ** app := End();
  693. **
  694. ***************************************************************************)
  695.  
  696.   PROCEDURE FamilyObject*{"MuiBasics.FamilyObjectA"} ( tags{9}.. : u.Tag);
  697.   PROCEDURE FamilyObjectA*( tags{9} : u.TagListPtr );
  698.   (* $SaveRegs+ *)
  699.     BEGIN
  700.       NewObjectA( y.ADR( m.cFamily ), tags );
  701.     END FamilyObjectA;
  702.  
  703.   PROCEDURE MenustripObject*{"MuiBasics.MenustripObjectA"} ( tags{9}.. : u.Tag);
  704.   PROCEDURE MenustripObjectA*( tags{9} : u.TagListPtr );
  705.   (* $SaveRegs+ *)
  706.     BEGIN
  707.       NewObjectA( y.ADR( m.cMenustrip ), tags );
  708.     END MenustripObjectA;
  709.  
  710.   PROCEDURE MenuObject*{"MuiBasics.MenuObjectA"} ( tags{9}.. : u.Tag);
  711.   PROCEDURE MenuObjectA*( tags{9} : u.TagListPtr );
  712.   (* $SaveRegs+ *)
  713.     BEGIN
  714.       NewObjectA( y.ADR( m.cMenu ), tags );
  715.     END MenuObjectA;
  716.  
  717.   PROCEDURE MenuObjectT*{"MuiBasics.MenuObjectTA"} ( name{8}:e.STRPTR; tags{9}.. : u.Tag);
  718.   PROCEDURE MenuObjectTA*( name{8}:e.STRPTR; tags{9} : u.TagListPtr );
  719.   (* $SaveRegs+ *)
  720.     BEGIN
  721.       MenuObject( m.aMenuTitle, name, u.done );
  722.       TagsA( tags );
  723.     END MenuObjectTA;
  724.  
  725.   PROCEDURE MenuitemObject*{"MuiBasics.MenuitemObjectA"} ( tags{9}.. : u.Tag);
  726.   PROCEDURE MenuitemObjectA*( tags{9} : u.TagListPtr );
  727.   (* $SaveRegs+ *)
  728.     BEGIN
  729.       NewObjectA( y.ADR( m.cMenuitem ), tags );
  730.     END MenuitemObjectA;
  731.  
  732.   PROCEDURE WindowObject*{"MuiBasics.WindowObjectA"} ( tags{9}.. : u.Tag);
  733.   PROCEDURE WindowObjectA*( tags{9} : u.TagListPtr );
  734.   (* $SaveRegs+ *)
  735.     BEGIN
  736.       NewObjectA( y.ADR( m.cWindow ), tags );
  737.     END WindowObjectA;
  738.  
  739.   PROCEDURE ImageObject*{"MuiBasics.ImageObjectA"} ( tags{9}.. : u.Tag);
  740.   PROCEDURE ImageObjectA*( tags{9} : u.TagListPtr );
  741.   (* $SaveRegs+ *)
  742.     BEGIN
  743.       NewObjectA( y.ADR( m.cImage ), tags );
  744.     END ImageObjectA;
  745.  
  746.   PROCEDURE BitmapObject*{"MuiBasics.BitmapObjectA"} ( tags{9}.. : u.Tag);
  747.   PROCEDURE BitmapObjectA*( tags{9} : u.TagListPtr );
  748.   (* $SaveRegs+ *)
  749.     BEGIN
  750.       NewObjectA( y.ADR( m.cBitmap ), tags );
  751.     END BitmapObjectA;
  752.  
  753.   PROCEDURE BodychunkObject*{"MuiBasics.BodychunkObjectA"} ( tags{9}.. : u.Tag);
  754.   PROCEDURE BodychunkObjectA*( tags{9} : u.TagListPtr );
  755.   (* $SaveRegs+ *)
  756.     BEGIN
  757.       NewObjectA( y.ADR( m.cBodychunk ), tags );
  758.     END BodychunkObjectA;
  759.  
  760.   PROCEDURE NotifyObject*{"MuiBasics.NotifyObjectA"} ( tags{9}.. : u.Tag);
  761.   PROCEDURE NotifyObjectA*( tags{9} : u.TagListPtr );
  762.   (* $SaveRegs+ *)
  763.     BEGIN
  764.       NewObjectA( y.ADR( m.cNotify ), tags );
  765.     END NotifyObjectA;
  766.  
  767.   PROCEDURE ApplicationObject*{"MuiBasics.ApplicationObjectA"} ( tags{9}.. : u.Tag);
  768.   PROCEDURE ApplicationObjectA*( tags{9} : u.TagListPtr );
  769.   (* $SaveRegs+ *)
  770.     BEGIN
  771.       NewObjectA( y.ADR( m.cApplication ), tags );
  772.     END ApplicationObjectA;
  773.  
  774.   PROCEDURE TextObject*{"MuiBasics.TextObjectA"} ( tags{9}.. : u.Tag);
  775.   PROCEDURE TextObjectA*( tags{9} : u.TagListPtr );
  776.   (* $SaveRegs+ *)
  777.     BEGIN
  778.       NewObjectA( y.ADR( m.cText ), tags );
  779.     END TextObjectA;
  780.  
  781.   PROCEDURE RectangleObject*{"MuiBasics.RectangleObjectA"} ( tags{9}.. : u.Tag);
  782.   PROCEDURE RectangleObjectA*( tags{9} : u.TagListPtr );
  783.   (* $SaveRegs+ *)
  784.     BEGIN
  785.       NewObjectA( y.ADR( m.cRectangle ), tags );
  786.     END RectangleObjectA;
  787.  
  788.   PROCEDURE ListObject*{"MuiBasics.ListObjectA"} ( tags{9}.. : u.Tag);
  789.   PROCEDURE ListObjectA*( tags{9} : u.TagListPtr );
  790.   (* $SaveRegs+ *)
  791.     BEGIN
  792.       NewObjectA( y.ADR( m.cList ), tags );
  793.     END ListObjectA;
  794.  
  795.   PROCEDURE PropObject*{"MuiBasics.PropObjectA"} ( tags{9}.. : u.Tag);
  796.   PROCEDURE PropObjectA*( tags{9} : u.TagListPtr );
  797.   (* $SaveRegs+ *)
  798.     BEGIN
  799.       NewObjectA( y.ADR( m.cProp ), tags );
  800.     END PropObjectA;
  801.  
  802.   PROCEDURE StringObject*{"MuiBasics.StringObjectA"} ( tags{9}.. : u.Tag);
  803.   PROCEDURE StringObjectA*( tags{9} : u.TagListPtr );
  804.   (* $SaveRegs+ *)
  805.     BEGIN
  806.       NewObjectA( y.ADR( m.cString ), tags );
  807.     END StringObjectA;
  808.  
  809.   PROCEDURE ScrollbarObject*{"MuiBasics.ScrollbarObjectA"} ( tags{9}.. : u.Tag);
  810.   PROCEDURE ScrollbarObjectA*( tags{9} : u.TagListPtr );
  811.   (* $SaveRegs+ *)
  812.     BEGIN
  813.       NewObjectA( y.ADR( m.cScrollbar ), tags );
  814.     END ScrollbarObjectA;
  815.  
  816.   PROCEDURE ListviewObject*{"MuiBasics.ListviewObjectA"} ( tags{9}.. : u.Tag);
  817.   PROCEDURE ListviewObjectA*( tags{9} : u.TagListPtr );
  818.   (* $SaveRegs+ *)
  819.     BEGIN
  820.       NewObjectA( y.ADR( m.cListview), tags );
  821.     END ListviewObjectA;
  822.  
  823.   PROCEDURE RadioObject*{"MuiBasics.RadioObjectA"} ( tags{9}.. : u.Tag);
  824.   PROCEDURE RadioObjectA*( tags{9} : u.TagListPtr );
  825.   (* $SaveRegs+ *)
  826.     BEGIN
  827.       NewObjectA( y.ADR( m.cRadio ), tags );
  828.     END RadioObjectA;
  829.  
  830.   PROCEDURE VolumelistObject*{"MuiBasics.VolumelistObjectA"} ( tags{9}.. : u.Tag);
  831.   PROCEDURE VolumelistObjectA*( tags{9} : u.TagListPtr );
  832.   (* $SaveRegs+ *)
  833.     BEGIN
  834.       NewObjectA( y.ADR( m.cVolumelist), tags );
  835.     END VolumelistObjectA;
  836.  
  837.   PROCEDURE FloattextObject*{"MuiBasics.FloattextObjectA"} ( tags{9}.. : u.Tag);
  838.   PROCEDURE FloattextObjectA*( tags{9} : u.TagListPtr );
  839.   (* $SaveRegs+ *)
  840.     BEGIN
  841.       NewObjectA( y.ADR( m.cFloattext), tags );
  842.     END FloattextObjectA;
  843.  
  844.   PROCEDURE DirlistObject*{"MuiBasics.DirlistObjectA"} ( tags{9}.. : u.Tag);
  845.   PROCEDURE DirlistObjectA*( tags{9} : u.TagListPtr );
  846.   (* $SaveRegs+ *)
  847.     BEGIN
  848.       NewObjectA( y.ADR( m.cDirlist ), tags );
  849.     END DirlistObjectA;
  850.  
  851.   PROCEDURE SliderObject*{"MuiBasics.SliderObjectA"} ( tags{9}.. : u.Tag);
  852.   PROCEDURE SliderObjectA*( tags{9} : u.TagListPtr );
  853.   (* $SaveRegs+ *)
  854.     BEGIN
  855.       NewObjectA( y.ADR( m.cSlider ), tags );
  856.     END SliderObjectA;
  857.  
  858.   PROCEDURE CycleObject*{"MuiBasics.CycleObjectA"} ( tags{9}.. : u.Tag);
  859.   PROCEDURE CycleObjectA*( tags{9} : u.TagListPtr );
  860.   (* $SaveRegs+ *)
  861.     BEGIN
  862.       NewObjectA( y.ADR( m.cCycle ), tags );
  863.     END CycleObjectA;
  864.  
  865.   PROCEDURE GaugeObject*{"MuiBasics.GaugeObjectA"} ( tags{9}.. : u.Tag);
  866.   PROCEDURE GaugeObjectA*( tags{9} : u.TagListPtr );
  867.   (* $SaveRegs+ *)
  868.     BEGIN
  869.       NewObjectA( y.ADR( m.cGauge ), tags );
  870.     END GaugeObjectA;
  871.  
  872.   PROCEDURE ScaleObject*{"MuiBasics.ScaleObjectA"} ( tags{9}.. : u.Tag);
  873.   PROCEDURE ScaleObjectA*( tags{9} : u.TagListPtr );
  874.   (* $SaveRegs+ *)
  875.     BEGIN
  876.       NewObjectA( y.ADR( m.cScale ), tags );
  877.     END ScaleObjectA;
  878.  
  879.   PROCEDURE BoopsiObject*{"MuiBasics.BoopsiObjectA"} ( tags{9}.. : u.Tag);
  880.   PROCEDURE BoopsiObjectA*( tags{9} : u.TagListPtr );
  881.   (* $SaveRegs+ *)
  882.     BEGIN
  883.       NewObjectA( y.ADR( m.cBoopsi ), tags );
  884.     END BoopsiObjectA;
  885.  
  886.   PROCEDURE ColorfieldObject*{"MuiBasics.ColorfieldObjectA"} ( tags{9}.. : u.Tag);
  887.   PROCEDURE ColorfieldObjectA*( tags{9} : u.TagListPtr );
  888.   (* $SaveRegs+ *)
  889.     BEGIN
  890.       NewObjectA( y.ADR( m.cColorfield ), tags );
  891.     END ColorfieldObjectA;
  892.  
  893.   PROCEDURE ColorpanelObject*{"MuiBasics.ColorpanelObjectA"} ( tags{9}.. : u.Tag);
  894.   PROCEDURE ColorpanelObjectA*( tags{9} : u.TagListPtr );
  895.   (* $SaveRegs+ *)
  896.     BEGIN
  897.       NewObjectA( y.ADR( m.cColorpanel ), tags );
  898.     END ColorpanelObjectA;
  899.  
  900.   PROCEDURE ColoradjustObject*{"MuiBasics.ColoradjustObjectA"} ( tags{9}.. : u.Tag);
  901.   PROCEDURE ColoradjustObjectA*( tags{9} : u.TagListPtr );
  902.   (* $SaveRegs+ *)
  903.     BEGIN
  904.       NewObjectA( y.ADR( m.cColoradjust ), tags );
  905.     END ColoradjustObjectA;
  906.  
  907.   PROCEDURE PaletteObject*{"MuiBasics.PaletteObjectA"} ( tags{9}.. : u.Tag);
  908.   PROCEDURE PaletteObjectA*( tags{9} : u.TagListPtr );
  909.   (* $SaveRegs+ *)
  910.     BEGIN
  911.       NewObjectA( y.ADR( m.cPalette ), tags );
  912.     END PaletteObjectA;
  913.  
  914.   PROCEDURE GroupObject*{"MuiBasics.GroupObjectA"} ( tags{9}.. : u.Tag);
  915.   PROCEDURE GroupObjectA*( tags{9} : u.TagListPtr );
  916.   (* $SaveRegs+ *)
  917.     BEGIN
  918.       NewObjectA( y.ADR( m.cGroup), tags );
  919.     END GroupObjectA;
  920.  
  921.   PROCEDURE RegisterObject*{"MuiBasics.RegisterObjectA"} ( tags{9}.. : u.Tag);
  922.   PROCEDURE RegisterObjectA*( tags{9} : u.TagListPtr );
  923.   (* $SaveRegs+ *)
  924.     BEGIN
  925.       NewObjectA( y.ADR( m.cRegister ), tags );
  926.     END RegisterObjectA;
  927.  
  928.   PROCEDURE VirtgroupObject*{"MuiBasics.VirtgroupObjectA"} ( tags{9}.. : u.Tag);
  929.   PROCEDURE VirtgroupObjectA*( tags{9} : u.TagListPtr );
  930.   (* $SaveRegs+ *)
  931.     BEGIN
  932.       NewObjectA( y.ADR( m.cVirtgroup ), tags );
  933.     END VirtgroupObjectA;
  934.  
  935.   PROCEDURE ScrollgroupObject*{"MuiBasics.ScrollgroupObjectA"} ( tags{9}.. : u.Tag);
  936.   PROCEDURE ScrollgroupObjectA*( tags{9} : u.TagListPtr );
  937.   (* $SaveRegs+ *)
  938.     BEGIN
  939.       NewObjectA( y.ADR( m.cScrollgroup ), tags );
  940.     END ScrollgroupObjectA;
  941.  
  942.   PROCEDURE PopstringObject*{"MuiBasics.PopstringObjectA"} ( tags{9}.. : u.Tag);
  943.   PROCEDURE PopstringObjectA*( tags{9} : u.TagListPtr );
  944.   (* $SaveRegs+ *)
  945.     BEGIN
  946.       NewObjectA( y.ADR( m.cPopstring ), tags );
  947.     END PopstringObjectA;
  948.  
  949.   PROCEDURE PopobjectObject*{"MuiBasics.PopobjectObjectA"} ( tags{9}.. : u.Tag);
  950.   PROCEDURE PopobjectObjectA*( tags{9} : u.TagListPtr );
  951.   (* $SaveRegs+ *)
  952.     BEGIN
  953.       NewObjectA( y.ADR( m.cPopobject ), tags );
  954.     END PopobjectObjectA;
  955.  
  956.   PROCEDURE PoplistObject*{"MuiBasics.PoplistObjectA"} ( tags{9}.. : u.Tag);
  957.   PROCEDURE PoplistObjectA*( tags{9} : u.TagListPtr );
  958.   (* $SaveRegs+ *)
  959.     BEGIN
  960.       NewObjectA( y.ADR( m.cPoplist ), tags );
  961.     END PoplistObjectA;
  962.  
  963.   PROCEDURE PopaslObject*{"MuiBasics.PopaslObjectA"} ( tags{9}.. : u.Tag);
  964.   PROCEDURE PopaslObjectA*( tags{9} : u.TagListPtr );
  965.   (* $SaveRegs+ *)
  966.     BEGIN
  967.       NewObjectA( y.ADR( m.cPopasl ), tags );
  968.     END PopaslObjectA;
  969.  
  970.   PROCEDURE ScrmodelistObject*{"MuiBasics.ScrmodelistObjectA"} ( tags{9}.. : u.Tag);
  971.   PROCEDURE ScrmodelistObjectA*( tags{9} : u.TagListPtr );
  972.   (* $SaveRegs+ *)
  973.     BEGIN
  974.       NewObjectA( y.ADR( m.cScrmodelist ), tags );
  975.     END ScrmodelistObjectA;
  976.  
  977.   PROCEDURE VGroup*{"MuiBasics.VGroupA"}( tags{9}.. : u.Tag );
  978.   PROCEDURE VGroupA*( tags{9} : u.TagListPtr );
  979.   (* $SaveRegs+ *)
  980.     BEGIN
  981.       NewObjectA( y.ADR( m.cGroup ), tags );
  982.       TagsA( tags );
  983.     END VGroupA;
  984.  
  985.   PROCEDURE HGroup*{"MuiBasics.HGroupA"}( tags{9}.. : u.Tag );
  986.   PROCEDURE HGroupA*( tags{9} : u.TagListPtr );
  987.   (* $SaveRegs+ *)
  988.     BEGIN
  989.       NewObject( m.cGroup, m.aGroupHoriz, e.true, u.end );
  990.       TagsA( tags );
  991.     END HGroupA;
  992.  
  993.   PROCEDURE ColGroup*{"MuiBasics.ColGroupA"} ( cols{3} : LONGINT; tags{9}.. : u.Tag );
  994.   PROCEDURE ColGroupA*( cols{3} : LONGINT; tags{9} : u.TagListPtr  );
  995.   (* $SaveRegs+ *)
  996.     BEGIN
  997.       NewObject( m.cGroup, m.aGroupColumns, cols, u.end );
  998.       TagsA( tags );
  999.     END ColGroupA;
  1000.  
  1001.   PROCEDURE RowGroup*{"MuiBasics.RowGroupA"}( rows{3} : LONGINT; tags{9}.. : u.Tag  );
  1002.   PROCEDURE RowGroupA*( rows{3} : LONGINT; tags{9} : u.TagListPtr  );
  1003.   (* $SaveRegs+ *)
  1004.     BEGIN
  1005.       NewObject( m.cGroup, m.aGroupRows, rows, u.end );
  1006.       TagsA( tags );
  1007.     END RowGroupA;
  1008.  
  1009.   PROCEDURE PageGroup*{"MuiBasics.PageGroupA"}( tags{9}.. : u.Tag );
  1010.   PROCEDURE PageGroupA*( tags{9} : u.TagListPtr );
  1011.   (* $SaveRegs+ *)
  1012.     BEGIN
  1013.       NewObject( m.cGroup, m.aGroupPageMode, e.true, u.end );
  1014.       TagsA( tags );
  1015.     END PageGroupA;
  1016.  
  1017.   PROCEDURE VGroupV*{"MuiBasics.VGroupAV"}( tags{9}.. : u.Tag );
  1018.   PROCEDURE VGroupAV*( tags{9} : u.TagListPtr );
  1019.   (* $SaveRegs+ *)
  1020.     BEGIN
  1021.       NewObjectA( y.ADR( m.cVirtgroup ), tags );
  1022.       TagsA( tags );
  1023.     END VGroupAV;
  1024.  
  1025.   PROCEDURE HGroupV*{"MuiBasics.HGroupAV"}( tags{9}.. : u.Tag );
  1026.   PROCEDURE HGroupAV*( tags{9} : u.TagListPtr );
  1027.   (* $SaveRegs+ *)
  1028.     BEGIN
  1029.       NewObject( m.cVirtgroup, m.aGroupHoriz, e.true, u.end );
  1030.       TagsA( tags );
  1031.     END HGroupAV;
  1032.  
  1033.   PROCEDURE ColGroupV*{"MuiBasics.ColGroupAV"} ( cols{3} : LONGINT; tags{9}.. : u.Tag );
  1034.   PROCEDURE ColGroupAV*( cols{3} : LONGINT; tags{9} : u.TagListPtr  );
  1035.   (* $SaveRegs+ *)
  1036.     BEGIN
  1037.       NewObject( m.cVirtgroup, m.aGroupColumns, cols, u.end );
  1038.       TagsA( tags );
  1039.     END ColGroupAV;
  1040.  
  1041.   PROCEDURE RowGroupV*{"MuiBasics.RowGroupAV"}( rows{3} : LONGINT; tags{9}.. : u.Tag  );
  1042.   PROCEDURE RowGroupAV*( rows{3} : LONGINT; tags{9} : u.TagListPtr  );
  1043.   (* $SaveRegs+ *)
  1044.     BEGIN
  1045.       NewObject( m.cVirtgroup, m.aGroupRows, rows, u.end );
  1046.       TagsA( tags );
  1047.     END RowGroupAV;
  1048.  
  1049.   PROCEDURE PageGroupV*{"MuiBasics.PageGroupAV"}( tags{9}.. : u.Tag );
  1050.   PROCEDURE PageGroupAV*( tags{9} : u.TagListPtr );
  1051.   (* $SaveRegs+ *)
  1052.     BEGIN
  1053.       NewObject( m.cVirtgroup, m.aGroupPageMode, e.true, u.end );
  1054.       TagsA( tags );
  1055.     END PageGroupAV;
  1056.  
  1057.   PROCEDURE RegisterGroup*{"MuiBasics.RegisterGroupA"}( t{8} : e.APTR; tags{9}.. : u.Tag );
  1058.   PROCEDURE RegisterGroupA*( t{8} : e.APTR; tags{9} : u.TagListPtr );
  1059.   (* $SaveRegs+ *)
  1060.     BEGIN
  1061.       NewObject( m.cRegister, m.aRegisterTitles, t, u.end );
  1062.       TagsA( tags );
  1063.     END RegisterGroupA;
  1064.  
  1065.   PROCEDURE Child*();
  1066.   (* $SaveRegs+ *)
  1067.     BEGIN
  1068.       Tag( m.aGroupChild );
  1069.     END Child;
  1070.  
  1071.   PROCEDURE SubWindow*();
  1072.   (* $SaveRegs+ *)
  1073.     BEGIN
  1074.       Tag( m.aApplicationWindow );
  1075.     END SubWindow;
  1076.  
  1077.   PROCEDURE WindowContents*();
  1078.   (* $SaveRegs+ *)
  1079.     BEGIN
  1080.       Tag( m.aWindowRootObject );
  1081.     END WindowContents;
  1082.  
  1083. (***************************************************************************
  1084. **
  1085. ** Frame Types
  1086. ** -----------
  1087. **
  1088. ** These procedures may be used to specify one of MUI's different frame types.
  1089. ** Note that every procedure consists of one or more { ti_Tag, ti_Data }
  1090. ** pairs.
  1091. **
  1092. ** GroupFrameT() is a special kind of frame that contains a centered
  1093. ** title text.
  1094. **
  1095. ** HGroup; GroupFrameT("Horiz Groups");
  1096. **    Child; RectangleObject; TextFrame  ; end;
  1097. **    Child; RectangleObject; StringFrame; end;
  1098. **    Child; RectangleObject; ButtonFrame; end;
  1099. **    Child; RectangleObject; ListFrame  ; end;
  1100. **    end;
  1101. **
  1102. ***************************************************************************)
  1103.  
  1104.   PROCEDURE NoFrame*{"MuiBasics.NoFrameA"} ( tags{9}.. : u.Tag );
  1105.   PROCEDURE NoFrameA*( tags{9} : u.TagListPtr );
  1106.   (* $SaveRegs+ *)
  1107.     BEGIN
  1108.       TagItem( m.aFrame , m.vFrameNone );
  1109.       TagsA( tags );
  1110.     END NoFrameA;
  1111.  
  1112.   PROCEDURE ButtonFrame*{"MuiBasics.ButtonFrameA"} ( tags{9}.. : u.Tag  );
  1113.   PROCEDURE ButtonFrameA*( tags{9} : u.TagListPtr  );
  1114.   (* $SaveRegs+ *)
  1115.     BEGIN
  1116.       TagItem( m.aFrame , m.vFrameButton );
  1117.       TagsA( tags );
  1118.     END ButtonFrameA;
  1119.  
  1120.   PROCEDURE ImageButtonFrame*{"MuiBasics.ImageButtonFrameA"} ( tags{9}.. : u.Tag );
  1121.   PROCEDURE ImageButtonFrameA*( tags{9} : u.TagListPtr );
  1122.   (* $SaveRegs+ *)
  1123.     BEGIN
  1124.       TagItem( m.aFrame , m.vFrameImageButton );
  1125.       TagsA( tags );
  1126.     END ImageButtonFrameA;
  1127.  
  1128.   PROCEDURE TextFrame*{"MuiBasics.TextFrameA"} ( tags{9}.. : u.Tag );
  1129.   PROCEDURE TextFrameA*( tags{9} : u.TagListPtr );
  1130.   (* $SaveRegs+ *)
  1131.     BEGIN
  1132.       TagItem( m.aFrame , m.vFrameText );
  1133.       TagsA( tags );
  1134.     END TextFrameA;
  1135.  
  1136.   PROCEDURE StringFrame*{"MuiBasics.StringFrameA"} ( tags{9}.. : u.Tag );
  1137.   PROCEDURE StringFrameA*( tags{9} : u.TagListPtr );
  1138.   (* $SaveRegs+ *)
  1139.     BEGIN
  1140.       TagItem( m.aFrame , m.vFrameString );
  1141.       TagsA( tags );
  1142.     END StringFrameA;
  1143.  
  1144.   PROCEDURE ReadListFrame*{"MuiBasics.ReadListFrameA"} ( tags{9}.. : u.Tag );
  1145.   PROCEDURE ReadListFrameA*( tags{9} : u.TagListPtr );
  1146.   (* $SaveRegs+ *)
  1147.     BEGIN
  1148.       TagItem(  m.aFrame , m.vFrameReadList );
  1149.       TagsA( tags );
  1150.     END ReadListFrameA;
  1151.  
  1152.   PROCEDURE InputListFrame*{"MuiBasics.InputListFrameA"} ( tags{9}.. : u.Tag );
  1153.   PROCEDURE InputListFrameA*( tags{9} : u.TagListPtr );
  1154.   (* $SaveRegs+ *)
  1155.     BEGIN
  1156.       TagItem( m.aFrame , m.vFrameInputList );
  1157.       TagsA( tags );
  1158.     END InputListFrameA;
  1159.  
  1160.   PROCEDURE PropFrame*{"MuiBasics.PropFrameA"} ( tags{9}.. : u.Tag );
  1161.   PROCEDURE PropFrameA*( tags{9} : u.TagListPtr );
  1162.   (* $SaveRegs+ *)
  1163.     BEGIN
  1164.       TagItem( m.aFrame , m.vFrameProp );
  1165.       TagsA( tags );
  1166.     END PropFrameA;
  1167.  
  1168.   PROCEDURE SliderFrame*{"MuiBasics.SliderFrameA"} ( tags{9}.. : u.Tag );
  1169.   PROCEDURE SliderFrameA*( tags{9} : u.TagListPtr );
  1170.   (* $SaveRegs+ *)
  1171.     BEGIN
  1172.       TagItem( m.aFrame , m.vFrameSlider );
  1173.       TagsA( tags );
  1174.     END SliderFrameA;
  1175.  
  1176.   PROCEDURE GaugeFrame*{"MuiBasics.GaugeFrameA"} ( tags{9}.. : u.Tag );
  1177.   PROCEDURE GaugeFrameA*( tags{9} : u.TagListPtr );
  1178.   (* $SaveRegs+ *)
  1179.     BEGIN
  1180.       TagItem( m.aFrame , m.vFrameGauge );
  1181.       TagsA( tags );
  1182.     END GaugeFrameA;
  1183.  
  1184.   PROCEDURE VirtualFrame*{"MuiBasics.VirtualFrameA"} ( tags{9}.. : u.Tag );
  1185.   PROCEDURE VirtualFrameA*( tags{9} : u.TagListPtr );
  1186.   (* $SaveRegs+ *)
  1187.     BEGIN
  1188.       TagItem( m.aFrame , m.vFrameVirtual );
  1189.       TagsA( tags );
  1190.     END VirtualFrameA;
  1191.  
  1192.   PROCEDURE GroupFrame*{"MuiBasics.GroupFrameA"} ( tags{9}.. : u.Tag );
  1193.   PROCEDURE GroupFrameA*( tags{9} : u.TagListPtr );
  1194.   (* $SaveRegs+ *)
  1195.     BEGIN
  1196.       TagItem( m.aFrame , m.vFrameGroup );
  1197.       TagsA( tags );
  1198.     END GroupFrameA;
  1199.  
  1200.   PROCEDURE GroupFrameT*{"MuiBasics.GroupFrameTA"}( s{8} : ARRAY OF CHAR; tags{9}.. : u.Tag );
  1201.   PROCEDURE GroupFrameTA*( s{8} : e.STRPTR; tags{9} : u.TagListPtr );
  1202.   (* $SaveRegs+ *)
  1203.     BEGIN
  1204.       TagItem2( m.aFrame, m.vFrameGroup, m.aFrameTitle, s );
  1205.       TagsA( tags );
  1206.     END GroupFrameTA;
  1207.  
  1208. (***************************************************************************
  1209. **
  1210. ** Baring Procedures
  1211. ** ------------------
  1212. **
  1213. ***************************************************************************)
  1214.  
  1215.   PROCEDURE HBar*();
  1216.     BEGIN
  1217.       Tag( m.NewObject( m.cRectangle,
  1218.                         m.aRectangleHBar, e.true,
  1219.                         m.aFixHeight, 2,
  1220.                         u.done ) );
  1221.     END HBar;
  1222.  
  1223.   PROCEDURE VBar*();
  1224.     BEGIN
  1225.       Tag( m.NewObject( m.cRectangle,
  1226.                         m.aRectangleVBar, e.true,
  1227.                         m.aFixWidth, 2,
  1228.                         u.done ) );
  1229.     END VBar;
  1230.  
  1231. (***************************************************************************
  1232. **
  1233. ** Spacing Procedures
  1234. ** ------------------
  1235. **
  1236. ***************************************************************************)
  1237.  
  1238.   PROCEDURE GroupSpacing*( x: LONGINT );
  1239.   (* $SaveRegs+ *)
  1240.     BEGIN
  1241.       TagItem( m.aGroupSpacing, x );
  1242.     END GroupSpacing;
  1243.  
  1244.   PROCEDURE HVSpace*();
  1245.   (* $SaveRegs+ *)
  1246.     BEGIN
  1247.       Tag( m.NewObject( m.cRectangle, u.done ) );
  1248.     END HVSpace;
  1249.  
  1250.   PROCEDURE HSpace*( x : LONGINT );
  1251.   (* $SaveRegs+ *)
  1252.     VAR t : u.Tags3;
  1253.     BEGIN
  1254.       IF x # 0 THEN
  1255.         t[0].tag := m.aFixWidth;
  1256.         t[0].data := x;
  1257.       ELSE
  1258.         t[0].tag := u.ignore;
  1259.       END;
  1260.       t[1] := u.TagItem( m.aVertWeight, 0 );
  1261.       t[2] := u.TagItem( u.done, 0 );
  1262.       Tag( m.NewObjectA( m.cRectangle, t ) );
  1263.     END HSpace;
  1264.  
  1265.   PROCEDURE VSpace*( x : LONGINT );
  1266.   (* $SaveRegs+ *)
  1267.     VAR t : u.Tags3;
  1268.     BEGIN
  1269.       IF x # 0 THEN
  1270.         t[0].tag := m.aFixHeight;
  1271.         t[0].data := x;
  1272.       ELSE
  1273.         t[0].tag := u.ignore;
  1274.       END;
  1275.       t[1] := u.TagItem( m.aHorizWeight, 0 );
  1276.       t[2] := u.TagItem( u.done, 0 );
  1277.       Tag( m.NewObjectA( m.cRectangle, t ) );
  1278.     END VSpace;
  1279.  
  1280.   PROCEDURE HCenterBegin*();
  1281.   (* $SaveRegs+ *)
  1282.     BEGIN
  1283.       HGroup; GroupSpacing( 0 );
  1284.         Child; HSpace( 0 );
  1285.     END HCenterBegin;
  1286.  
  1287.   PROCEDURE HCenterEnd*();
  1288.   (* $SaveRegs+ *)
  1289.     BEGIN
  1290.         Child; HSpace( 0 );
  1291.       end;
  1292.     END HCenterEnd;
  1293.  
  1294.   PROCEDURE VCenterBegin*();
  1295.   (* $SaveRegs+ *)
  1296.     BEGIN
  1297.       VGroup; GroupSpacing( 0 );
  1298.         Child ; VSpace( 0 );
  1299.     END VCenterBegin;
  1300.  
  1301.   PROCEDURE VCenterEnd*();
  1302.   (* $SaveRegs+ *)
  1303.     BEGIN
  1304.         Child ; VSpace( 0 );
  1305.       end;
  1306.     END VCenterEnd;
  1307.  
  1308.   PROCEDURE InnerSpacing*( h, v : LONGINT );
  1309.   (* $SaveRegs+ *)
  1310.     BEGIN
  1311.       Tags( m.aInnerLeft   , h,
  1312.             m.aInnerRight  , h,
  1313.             m.aInnerTop    , v,
  1314.             m.aInnerBottom , v,
  1315.             u.end );
  1316.     END InnerSpacing;
  1317.  
  1318.  
  1319. (***************************************************************************
  1320. **
  1321. ** String-Object
  1322. ** -------------
  1323. **
  1324. ** The following procedure creates a simple string gadget.
  1325. **
  1326. ***************************************************************************)
  1327.  
  1328.   PROCEDURE String * {"MuiBasics.StringA"} ( contents{8} : e.STRPTR; maxlen{3} : LONGINT; tags{9}.. : u.Tag ):m.Object;
  1329.   PROCEDURE string * {"MuiBasics.StringA"} ( contents{8} : e.STRPTR; maxlen{3} : LONGINT; tags{9}.. : u.Tag );
  1330.   PROCEDURE StringA*( contents{8} : e.STRPTR; maxlen{3} : LONGINT; tags{9} : u.TagListPtr ):m.Object;
  1331.   (* $SaveRegs+ *)
  1332.     BEGIN
  1333.       StringObject; StringFrame;
  1334.         TagItem2( m.aStringMaxLen, maxlen,
  1335.                   m.aStringContents, contents );
  1336.         TagsA( tags );
  1337.       RETURN End();
  1338.     END StringA;
  1339.  
  1340.   PROCEDURE KeyString * {"MuiBasics.KeyStringA"} ( contents{8} : e.STRPTR; maxlen{3} : LONGINT; controlchar{4}: CHAR; tags{9}.. : u.Tag ):m.Object;
  1341.   PROCEDURE keyString * {"MuiBasics.KeyStringA"} ( contents{8} : e.STRPTR; maxlen{3} : LONGINT; controlchar{4}: CHAR; tags{9}.. : u.Tag );
  1342.   PROCEDURE KeyStringA*( contents{8} : e.STRPTR; maxlen{3} : LONGINT; controlchar{4} : LONGINT; tags{9} : u.TagListPtr ):m.Object;
  1343.   (* $SaveRegs+ *)
  1344.     BEGIN
  1345.       RETURN String( contents, maxlen, m.aControlChar, controlchar, u.more, tags );
  1346.     END KeyStringA;
  1347.  
  1348. (***************************************************************************
  1349. **
  1350. ** Integer-Object
  1351. ** --------------
  1352. **
  1353. ** The following procedure creates a simple integer string gadget.
  1354. **
  1355. ***************************************************************************)
  1356.  
  1357.   PROCEDURE Integer * {"MuiBasics.IntegerA"} ( contents{2} : LONGINT; maxlen{3} : LONGINT; tags{9}.. : u.Tag ):m.Object;
  1358.   PROCEDURE integer * {"MuiBasics.IntegerA"} ( contents{2} : LONGINT; maxlen{3} : LONGINT; tags{9}.. : u.Tag );
  1359.   PROCEDURE IntegerA*( contents{2} : e.STRPTR; maxlen{3} : LONGINT; tags{9} : u.TagListPtr ):m.Object;
  1360.   (* $SaveRegs+ *)
  1361.     BEGIN
  1362.       StringObject; StringFrame;
  1363.         TagItem3( m.aStringMaxLen, maxlen,
  1364.                   m.aStringInteger, contents,
  1365.                   m.aStringAccept, y.ADR( "0123456789" ) );
  1366.  
  1367.         TagsA( tags );
  1368.       RETURN End();
  1369.     END IntegerA;
  1370.  
  1371.  
  1372.   PROCEDURE KeyInteger * {"MuiBasics.KeyIntegerA"} ( contents{2} : LONGINT; maxlen{3} : LONGINT; controlchar{4}: CHAR; tags{9}.. : u.Tag ):m.Object;
  1373.   PROCEDURE keyInteger * {"MuiBasics.KeyIntegerA"} ( contents{2} : LONGINT; maxlen{3} : LONGINT; controlchar{4}: CHAR; tags{9}.. : u.Tag );
  1374.   PROCEDURE KeyIntegerA*( contents{2} : LONGINT; maxlen{3} : LONGINT; controlchar{4} : LONGINT; tags{9} : u.TagListPtr ):m.Object;
  1375.   (* $SaveRegs+ *)
  1376.     BEGIN
  1377.       RETURN Integer( contents, maxlen, m.aControlChar, controlchar, u.more, tags );
  1378.     END KeyIntegerA;
  1379.  
  1380.  
  1381. (***************************************************************************
  1382. **
  1383. ** CheckMark-Object
  1384. ** ----------------
  1385. **
  1386. ** The following procedure creates a checkmark gadget.
  1387. **
  1388. ***************************************************************************)
  1389.  
  1390.   PROCEDURE CheckMark * {"MuiBasics.CheckMarkA"}( checked{4} : BOOLEAN; tags{9}.. : u.Tag ):m.Object;
  1391.   PROCEDURE checkMark * {"MuiBasics.CheckMarkA"}( checked{4} : BOOLEAN; tags{9}.. : u.Tag );
  1392.   PROCEDURE CheckMarkA*( checked{4} : e.LONGBOOL; tags{9} : u.TagListPtr ):m.Object;
  1393.   (* $SaveRegs+ *)
  1394.    BEGIN
  1395.       ImageObject;
  1396.         ImageButtonFrame;
  1397.           Tags( m.aInputMode , m.vInputModeToggle,
  1398.                 m.aImageSpec    , m.iCheckMark,
  1399.                 m.aImageFreeVert, e.true,
  1400.                 m.aSelected     , checked,
  1401.                 m.aBackground   , m.iButtonBack,
  1402.                 m.aShowSelState , e.false,
  1403.                 u.end );
  1404.           TagsA( tags );
  1405.       RETURN End();
  1406.     END CheckMarkA;
  1407.  
  1408.  
  1409.   PROCEDURE KeyCheckMark *{"MuiBasics.KeyCheckMarkA"}( checked{4} : e.LONGBOOL; key{3} : CHAR; tags{9}.. : u.Tag ):m.Object;
  1410.   PROCEDURE keyCheckMark *{"MuiBasics.KeyCheckMarkA"}( checked{4} : e.LONGBOOL; key{3} : CHAR; tags{9}.. : u.Tag );
  1411.   PROCEDURE KeyCheckMarkA*( checked{4} : e.LONGBOOL; key{3} : LONGINT; tags{9} : u.TagListPtr ):m.Object;
  1412.   (* $SaveRegs+ *)
  1413.    BEGIN
  1414.       RETURN  CheckMark( y.VAL( BOOLEAN, SHORT(SHORT(checked)) ), m.aControlChar, key, u.more, tags );
  1415.     END KeyCheckMarkA;
  1416.  
  1417.  
  1418. (***************************************************************************
  1419. **
  1420. ** Button-Objects
  1421. ** --------------
  1422. **
  1423. ** Note: Use small letters for KeyButtons, e.g.
  1424. **       KeyButton("Cancel",'c')  and not  KeyButton("Cancel",'C') !!
  1425. **
  1426. ***************************************************************************)
  1427.  
  1428.   PROCEDURE SimpleButton * {"MuiBasics.SimpleButtonA"} ( name{8} : ARRAY OF CHAR; tags{9}.. : u.Tag ):m.Object;
  1429.   PROCEDURE simpleButton * {"MuiBasics.SimpleButtonA"} ( name{8} : ARRAY OF CHAR; tags{9}.. : u.Tag );
  1430.   PROCEDURE SimpleButtonA * ( name{8} : e.STRPTR; tags{9} : u.TagListPtr ):m.Object;
  1431.   (* $SaveRegs+ *)
  1432.     BEGIN
  1433.       TextObject;
  1434.         ButtonFrame;
  1435.           Tags( m.aTextContents, name,
  1436.                 m.aTextPreParse, y.ADR("\033c"),
  1437.                 m.aTextSetMax  , e.false,
  1438.                 m.aInputMode   , m.vInputModeRelVerify,
  1439.                 m.aBackground  , m.iButtonBack,
  1440.                 u.end );
  1441.         TagsA( tags );
  1442.       RETURN End();
  1443.     END SimpleButtonA;
  1444.  
  1445.  
  1446.   PROCEDURE KeyButton * {"MuiBasics.KeyButtonA"} ( name{8} : ARRAY OF CHAR; key{4} : CHAR; tags{9}.. : u.TagListPtr ):m.Object;
  1447.   PROCEDURE keyButton * {"MuiBasics.KeyButtonA"} ( name{8} : ARRAY OF CHAR; key{4} : CHAR; tags{9}.. : u.TagListPtr );
  1448.   PROCEDURE KeyButtonA * ( name{8} : e.STRPTR; key{4} : LONGINT; tags{9} : u.TagListPtr ):m.Object;
  1449.   (* $SaveRegs+ *)
  1450.     BEGIN
  1451.       RETURN SimpleButton( name^, m.aTextHiChar, key, m.aControlChar, key, u.more, tags );
  1452.     END KeyButtonA;
  1453.  
  1454. (***************************************************************************
  1455. **
  1456. ** Cycle-Object
  1457. ** ------------
  1458. **
  1459. ***************************************************************************)
  1460.  
  1461.   PROCEDURE Cycle * {"MuiBasics.CycleA"} ( entries{10} : e.APTR; tags{9}.. : u.Tag ):m.Object;
  1462.   PROCEDURE cycle * {"MuiBasics.CycleA"} ( entries{10} : e.APTR; tags{9}.. : u.Tag );
  1463.   PROCEDURE CycleA * ( entries{10} : e.APTR; tags{9} : u.TagListPtr ):m.Object;
  1464.   (* $SaveRegs+ *)
  1465.     BEGIN
  1466.       CycleObject( m.aCycleEntries, entries, u.end );
  1467.         TagsA( tags );
  1468.       RETURN End();
  1469.     END CycleA;
  1470.  
  1471.  
  1472.   PROCEDURE KeyCycle * {"MuiBasics.KeyCycleA"} ( entries{10} : e.APTR; key{4} : CHAR; tags{9}.. : u.Tag ):m.Object;
  1473.   PROCEDURE keyCycle * {"MuiBasics.KeyCycleA"} ( entries{10} : e.APTR; key{4} : CHAR; tags{9}.. : u.Tag );
  1474.   PROCEDURE KeyCycleA * ( entries{10} : e.APTR; key{4} : LONGINT; tags{9} : u.TagListPtr ):m.Object;
  1475.   (* $SaveRegs+ *)
  1476.     BEGIN
  1477.       RETURN  Cycle( entries, m.aControlChar, key, u.more, tags );
  1478.     END KeyCycleA;
  1479.  
  1480.  
  1481. (***************************************************************************
  1482. **
  1483. ** Radio-Object
  1484. ** ------------
  1485. **
  1486. ***************************************************************************)
  1487.  
  1488.   PROCEDURE Radio * {"MuiBasics.RadioA"} ( name{8} : ARRAY OF CHAR; entries{10} : e.APTR; tags{9}.. : u.Tag ):m.Object;
  1489.   PROCEDURE radio * {"MuiBasics.RadioA"} ( name{8} : ARRAY OF CHAR; entries{10} : e.APTR; tags{9}.. : u.Tag );
  1490.   PROCEDURE RadioA * ( name{8}: e.STRPTR; entries{10} : e.APTR; tags{9} : u.TagListPtr ):m.Object;
  1491.   (* $SaveRegs+ *)
  1492.     BEGIN
  1493.       RadioObject;
  1494.         GroupFrameT( name^ );
  1495.           TagItem( m.aRadioEntries, entries );
  1496.         TagsA( tags );
  1497.       RETURN End();
  1498.     END RadioA;
  1499.  
  1500.   PROCEDURE KeyRadio * {"MuiBasics.KeyRadioA"} ( name{8} : ARRAY OF CHAR; entries{10} : e.APTR; key{4} : CHAR; tags{9}.. : u.Tag ):m.Object;
  1501.   PROCEDURE keyRadio * {"MuiBasics.KeyRadioA"} ( name{8} : ARRAY OF CHAR; entries{10} : e.APTR; key{4} : CHAR; tags{9}.. : u.Tag );
  1502.   PROCEDURE KeyRadioA * ( name{8}: e.STRPTR; entries{10} : e.APTR; key{4} : LONGINT; tags{9} : u.TagListPtr ):m.Object;
  1503.   (* $SaveRegs+ *)
  1504.     BEGIN
  1505.       RETURN  Radio(name^, entries, m.aControlChar, key, u.more, tags );
  1506.     END KeyRadioA;
  1507.  
  1508.  
  1509. (***************************************************************************
  1510. **
  1511. ** Slider-Object
  1512. ** -------------
  1513. **
  1514. ***************************************************************************)
  1515.  
  1516.   PROCEDURE Slider * {"MuiBasics.SliderA"} ( min{2}, max{3}, level{4} : LONGINT; tags{9}.. : u.Tag ):m.Object;
  1517.   PROCEDURE slider * {"MuiBasics.SliderA"} ( min{2}, max{3}, level{4} : LONGINT; tags{9}.. : u.Tag );
  1518.   PROCEDURE SliderA * ( min{2}, max{3}, level{4} : LONGINT; tags{9} : u.TagListPtr ):m.Object;
  1519.   (* $SaveRegs+ *)
  1520.     BEGIN
  1521.       SliderObject( m.aSliderMin, min,
  1522.                     m.aSliderMax, max,
  1523.                     m.aSliderLevel, level,
  1524.                     u.end );
  1525.         TagsA( tags );
  1526.       RETURN End();
  1527.     END SliderA;
  1528.  
  1529.   PROCEDURE KeySlider * {"MuiBasics.KeySliderA"} ( min{2}, max{3}, level{4} : LONGINT; key{5} : CHAR; tags{9}.. : u.Tag ):m.Object;
  1530.   PROCEDURE keySlider * {"MuiBasics.KeySliderA"} ( min{2}, max{3}, level{4} : LONGINT; key{5} : CHAR; tags{9}.. : u.Tag );
  1531.   PROCEDURE KeySliderA * ( min{2}, max{3}, level{4}, key{5} : LONGINT; tags{9} : u.TagListPtr ):m.Object;
  1532.   (* $SaveRegs+ *)
  1533.     BEGIN
  1534.       RETURN Slider( min, max, level, m.aControlChar, key, u.more, tags );
  1535.     END KeySliderA;
  1536.  
  1537.   PROCEDURE VSlider * {"MuiBasics.VSliderA"} ( min{2}, max{3}, level{4} : LONGINT; tags{9}.. : u.Tag ):m.Object;
  1538.   PROCEDURE vSlider * {"MuiBasics.VSliderA"} ( min{2}, max{3}, level{4} : LONGINT; tags{9}.. : u.Tag );
  1539.   PROCEDURE VSliderA * ( min{2}, max{3}, level{4} : LONGINT; tags{9} : u.TagListPtr ):m.Object;
  1540.   (* $SaveRegs+ *)
  1541.     BEGIN
  1542.       RETURN Slider( min, max, level, m.aGroupHoriz, e.false, u.more, tags );
  1543.     END VSliderA;
  1544.  
  1545.  
  1546.   PROCEDURE KeyVSlider * {"MuiBasics.KeyVSliderA"} ( min{2}, max{3}, level{4} : LONGINT; key{5} : CHAR; tags{9}.. : u.Tag ):m.Object;
  1547.   PROCEDURE keyVSlider * {"MuiBasics.KeyVSliderA"} ( min{2}, max{3}, level{4} : LONGINT; key{5} : CHAR; tags{9}.. : u.Tag );
  1548.   PROCEDURE KeyVSliderA * ( min{2}, max{3}, level{4}, key{5} : LONGINT; tags{9} : u.TagListPtr ):m.Object;
  1549.   (* $SaveRegs+ *)
  1550.     BEGIN
  1551.       RETURN  VSlider( min, max, level, m.aControlChar, key, u.more, tags );
  1552.     END KeyVSliderA;
  1553.  
  1554.  
  1555. (***************************************************************************
  1556. **
  1557. ** Scrollbar-Object
  1558. ** -------------
  1559. **
  1560. ***************************************************************************)
  1561.  
  1562.   PROCEDURE Scrollbar * {"MuiBasics.ScrollbarA"} ( min{2}, max{3}, level{4} : LONGINT; tags{9}.. : u.Tag ):m.Object;
  1563.   PROCEDURE scrollbar * {"MuiBasics.ScrollbarA"} ( min{2}, max{3}, level{4} : LONGINT; tags{9}.. : u.Tag );
  1564.   PROCEDURE ScrollbarA * ( min{2}, max{3}, level{4} : LONGINT; tags{9} : u.TagListPtr ):m.Object;
  1565.   (* $SaveRegs+ *)
  1566.     BEGIN
  1567.       ScrollbarObject( m.aSliderMin, min,
  1568.                       m.aSliderMax, max,
  1569.                       m.aSliderLevel, level,
  1570.                       m.aGroupHoriz, e.true,
  1571.                       u.end );
  1572.         TagsA( tags );
  1573.       RETURN End();
  1574.     END ScrollbarA;
  1575.  
  1576.   PROCEDURE KeyScrollbar * {"MuiBasics.KeyScrollbarA"} ( min{2}, max{3}, level{4} : LONGINT; key{5} : CHAR; tags{9}.. : u.Tag ):m.Object;
  1577.   PROCEDURE keyScrollbar * {"MuiBasics.KeyScrollbarA"} ( min{2}, max{3}, level{4} : LONGINT; key{5} : CHAR; tags{9}.. : u.Tag );
  1578.   PROCEDURE KeyScrollbarA * ( min{2}, max{3}, level{4}, key{5} : LONGINT; tags{9} : u.TagListPtr ):m.Object;
  1579.   (* $SaveRegs+ *)
  1580.     BEGIN
  1581.       RETURN  Scrollbar( min, max, level, m.aControlChar, key, u.more, tags );
  1582.     END KeyScrollbarA;
  1583.  
  1584.   PROCEDURE VScrollbar * {"MuiBasics.VScrollbarA"} ( min{2}, max{3}, level{4} : LONGINT; tags{9}.. : u.Tag ):m.Object;
  1585.   PROCEDURE vScrollbar * {"MuiBasics.VScrollbarA"} ( min{2}, max{3}, level{4} : LONGINT; tags{9}.. : u.Tag );
  1586.   PROCEDURE VScrollbarA * ( min{2}, max{3}, level{4} : LONGINT; tags{9} : u.TagListPtr ):m.Object;
  1587.   (* $SaveRegs+ *)
  1588.     BEGIN
  1589.       ScrollbarObject(m.aSliderMin, min,
  1590.                     m.aSliderMax, max,
  1591.                     m.aSliderLevel, level,
  1592.                     u.end );
  1593.         TagsA( tags );
  1594.       RETURN End();
  1595.     END VScrollbarA;
  1596.  
  1597.   PROCEDURE KeyVScrollbar * {"MuiBasics.KeyVScrollbarA"} ( min{2}, max{3}, level{4} : LONGINT; key{5} : CHAR; tags{9}.. : u.Tag ):m.Object;
  1598.   PROCEDURE keyVScrollbar * {"MuiBasics.KeyVScrollbarA"} ( min{2}, max{3}, level{4} : LONGINT; key{5} : CHAR; tags{9}.. : u.Tag );
  1599.   PROCEDURE KeyVScrollbarA * ( min{2}, max{3}, level{4}, key{5} : LONGINT; tags{9} : u.TagListPtr ):m.Object;
  1600.   (* $SaveRegs+ *)
  1601.     BEGIN
  1602.       RETURN  VScrollbar( min, max, level, m.aControlChar, key, u.more, tags );
  1603.       RETURN End();
  1604.     END KeyVScrollbarA;
  1605.  
  1606.  
  1607. (***************************************************************************
  1608. **
  1609. ** Button to be used for popup objects
  1610. **
  1611. ***************************************************************************)
  1612.  
  1613.   PROCEDURE PopButton* {"MuiBasics.PopButtonA"} ( img{3} : LONGINT; tags{9}.. : u.Tag ):m.Object;
  1614.   PROCEDURE popButton* {"MuiBasics.PopButtonA"} ( img{3} : LONGINT; tags{9}.. : u.Tag );
  1615.   PROCEDURE PopButtonA*( img{3} : LONGINT; tags{9} : u.TagListPtr ):m.Object;
  1616.   (* $SaveRegs+ *)
  1617.     BEGIN
  1618.       ImageObject;
  1619.         ImageButtonFrame( m.aImageSpec, img,
  1620.                           m.aImageFontMatchWidth, e.true,
  1621.                           m.aImageFreeVert, e.true,
  1622.                           m.aInputMode, m.vInputModeRelVerify,
  1623.                           m.aBackground, m.iBACKGROUND,
  1624.                           u.end );
  1625.         TagsA( tags );
  1626.       RETURN End();
  1627.     END PopButtonA;
  1628.  
  1629.  
  1630. (***************************************************************************
  1631. **
  1632. ** Popup-Object
  1633. ** ------------
  1634. **
  1635. ** An often needed GUI element is a string gadget with a little button
  1636. ** that opens up a (small) window with a list containing possible entries
  1637. ** for this gadget. Together with the Popup and the String macro,
  1638. ** such a thing would look like
  1639. **
  1640. ** VGroup;
  1641. **    Child; PopupBegin;
  1642. **             Child; STFont := String( "helvetica/13", 32 );
  1643. **           PopupEnd( hook, m.iPopUp, STFont );
  1644. **    ...;
  1645. **
  1646. ** STFont will hold a pointer to the embedded string gadget and can
  1647. ** be used to set and get its contents as with every other string object.
  1648. **
  1649. ** For Hook description see below.
  1650. ** The hook will be called with the string gadget as object whenever
  1651. ** the user releases the popup button and could look like this:
  1652. **
  1653. ** PROCEDURE FontReq( hook : Hook; obj : m.Object : args : Args) : LONGINT;
  1654. **   VAR window : I.WindowPtr;
  1655. **       l, t, w, h : LONGINT;
  1656. **       req : ASL.AslRequesterPtr;
  1657. ** BEGIN
  1658. **    ...
  1659. **
  1660. **    (* put our application to sleep while displaying the requester *)
  1661. **      Set( Application, m.aApplicationSleep, e.true );
  1662. **
  1663. **    (* get the calling objects window and position *)
  1664. **      Get( obj, m.aWindow  , window );
  1665. **      Get( obj, m.aLeftEdge, l );
  1666. **      Get( obj, m.aTopEdge , t );
  1667. **      Get( obj, m.aWidth   , w );
  1668. **      Get( obj, m.aHeight  , h );
  1669. **
  1670. **    req := m.AllocAslRequestTags( ASL.fontRequest, u.done )
  1671. **    IF req # NIL THEN
  1672. **
  1673. **       IF (m.AslRequestTags(req,
  1674. **               ASL.foWindow         ,window,
  1675. **               ASL.foPrivateIDCMP   ,TRUE,
  1676. **               ASL.foTitleText      ,"Select Font",
  1677. **               ASL.foInitialLeftEdge,window->LeftEdge + l,
  1678. **               ASL.foInitialTopEdge ,window->TopEdge  + t+h,
  1679. **               ASL.foInitialWidth   ,w,
  1680. **               ASL.foInitialHeight  ,250,
  1681. **               u.done ) ) THEN
  1682. **
  1683. **          (* set the new contents for our string gadget *)
  1684. **                              Set( args(PopupArgs).linkedObj, m.aStringContents, req(ASL.FontRequester).attr.name);
  1685. **       END;
  1686. **       m.FreeAslRequest( req );
  1687. **   END;
  1688. **
  1689. **    (* wake up our application again *)
  1690. **      Set(Application, m.aApplicationSleep, e.false );
  1691. **
  1692. **      RETURN( 0);
  1693. ** END FontReq:
  1694. **
  1695. ** Note: This Procedure is translated to Oberon on the fly, no warranty is given
  1696. **       that this piece of code works.
  1697. **
  1698. ***************************************************************************)
  1699.  
  1700.   PROCEDURE PopupBegin * ();
  1701.   (* $SaveRegs+ *)
  1702.     VAR dummy : m.Object;
  1703.     BEGIN
  1704.       HGroup; GroupSpacing( 1 );
  1705.     END PopupBegin;
  1706.  
  1707.   PROCEDURE popupEnd * {"MuiBasics.PopupEnd"} ( hook : Hook; img : LONGINT; obj : m.Object );
  1708.   PROCEDURE PopupEnd * ( hook : Hook; img : LONGINT; obj : m.Object ):m.Object;
  1709.   (* $SaveRegs+ *)
  1710.     VAR dummy : m.Object;
  1711.     BEGIN
  1712.         Child; ImageObject;
  1713.                  ImageButtonFrame;
  1714.                  Tags( m.aImageSpec, img,
  1715.                        m.aImageFontMatchWidth, e.true,
  1716.                        m.aImageFreeVert, e.true,
  1717.                        m.aInputMode, m.vInputModeRelVerify,
  1718.                        m.aBackground, m.iButtonBack,
  1719.                        u.end );
  1720.                dummy := End();
  1721.                IF (obj # NIL) & (dummy # NIL) & (hook # NIL) THEN
  1722.                  SetHookObject( hook, dummy );
  1723.                  m.DoMethod( dummy, m.mNotify, m.aPressed, e.false,
  1724.                                dummy, 3, m.mCallHook, hook, obj );
  1725.                END;
  1726.       end;
  1727.       RETURN dummy;
  1728.     END PopupEnd;
  1729.  
  1730.  
  1731. (***************************************************************************
  1732. **
  1733. ** Labeling Objects
  1734. ** ----------------
  1735. **
  1736. ** Labeling objects, e.g. a group of string gadgets,
  1737. **
  1738. **   Small: |foo   |
  1739. **  Normal: |bar   |
  1740. **     Big: |foobar|
  1741. **    Huge: |barfoo|
  1742. **
  1743. ** is done using a 2 column group:
  1744. **
  1745. ** ColGroup(2);
  1746. **      Child; Label2( "Small:"  );
  1747. **    Child; StringObject; end;
  1748. **      Child; Label2( "Normal:" );
  1749. **    Child; StringObject; end;
  1750. **      Child; Label2( "Big:"    );
  1751. **    Child; StringObject; end;
  1752. **      Child; Label2( "Huge:"   );
  1753. **    Child; StringObject; end;
  1754. **    end;
  1755. **
  1756. ** Note that we have three versions of the label procedure, depending on
  1757. ** the frame type of the right hand object:
  1758. **
  1759. ** Label1(): For use with standard frames (e.g. checkmarks).
  1760. ** Label2(): For use with double high frames (e.g. string gadgets).
  1761. ** Label() : For use with objects without a frame.
  1762. **
  1763. ** These procedures ensure that your label will look fine even if the
  1764. ** user of your application configured some strange spacing values.
  1765. ** If you want to use your own labeling, you'll have to pay attention
  1766. ** on this topic yourself.
  1767. **
  1768. ***************************************************************************)
  1769.  
  1770.   PROCEDURE Label * ( label : ARRAY OF CHAR ):m.Object;
  1771.   (* $SaveRegs+ *)
  1772.   (* $CopyArrays- *)
  1773.     BEGIN
  1774.       TextObject( m.aTextPreParse, y.ADR( "\033r" ),
  1775.                   m.aTextContents, y.ADR( label ),
  1776.                   m.aWeight      , 0,
  1777.                   m.aInnerLeft   , 0,
  1778.                   m.aInnerRight  , 0,
  1779.                   u.end );
  1780.       RETURN End();
  1781.     END Label;
  1782.  
  1783.   PROCEDURE Label1 * ( label : ARRAY OF CHAR ):m.Object;
  1784.   (* $SaveRegs+ *)
  1785.   (* $CopyArrays- *)
  1786.     BEGIN
  1787.       TextObject( m.aTextPreParse, y.ADR( "\033r" ),
  1788.                   m.aTextContents, y.ADR( label ),
  1789.                   m.aWeight      , 0,
  1790.                   m.aInnerLeft   , 0,
  1791.                   m.aInnerRight  , 0,
  1792.                   u.end );
  1793.         ButtonFrame;
  1794.           TagItem( m.aFramePhantomHoriz, e.true );
  1795.       RETURN End();
  1796.     END Label1;
  1797.  
  1798.   PROCEDURE Label2 * ( label : ARRAY OF CHAR ):m.Object;
  1799.   (* $SaveRegs+ *)
  1800.   (* $CopyArrays- *)
  1801.     BEGIN
  1802.       TextObject( m.aTextPreParse, y.ADR( "\033r" ),
  1803.                   m.aTextContents, y.ADR( label ),
  1804.                   m.aWeight      , 0,
  1805.                   m.aInnerLeft   , 0,
  1806.                   m.aInnerRight  , 0,
  1807.                   u.end );
  1808.         StringFrame;
  1809.          TagItem( m.aFramePhantomHoriz, e.true );
  1810.       RETURN End();
  1811.     END Label2;
  1812.  
  1813.   PROCEDURE LLabel * ( label : ARRAY OF CHAR ):m.Object;
  1814.   (* $SaveRegs+ *)
  1815.   (* $CopyArrays- *)
  1816.     BEGIN
  1817.       TextObject( m.aTextContents, y.ADR( label ),
  1818.                   m.aWeight      , 0,
  1819.                   m.aInnerLeft   , 0,
  1820.                   m.aInnerRight  , 0,
  1821.                   u.end );
  1822.       RETURN End();
  1823.     END LLabel;
  1824.  
  1825.   PROCEDURE LLabel1 * ( label : ARRAY OF CHAR ):m.Object;
  1826.   (* $SaveRegs+ *)
  1827.   (* $CopyArrays- *)
  1828.     BEGIN
  1829.       TextObject( m.aTextContents, y.ADR( label ),
  1830.                   m.aWeight      , 0,
  1831.                   m.aInnerLeft   , 0,
  1832.                   m.aInnerRight  , 0,
  1833.                   u.end );
  1834.         ButtonFrame;
  1835.           TagItem( m.aFramePhantomHoriz, e.true );
  1836.       RETURN End();
  1837.     END LLabel1;
  1838.  
  1839.   PROCEDURE LLabel2 * ( label : ARRAY OF CHAR ):m.Object;
  1840.   (* $SaveRegs+ *)
  1841.   (* $CopyArrays- *)
  1842.     BEGIN
  1843.       TextObject( m.aTextContents, y.ADR( label ),
  1844.                   m.aWeight      , 0,
  1845.                   m.aInnerLeft   , 0,
  1846.                   m.aInnerRight  , 0,
  1847.                   u.end );
  1848.         StringFrame;
  1849.          TagItem( m.aFramePhantomHoriz, e.true );
  1850.       RETURN End();
  1851.     END LLabel2;
  1852.  
  1853.   PROCEDURE KeyLabel * ( label : ARRAY OF CHAR; hichar : CHAR ):m.Object;
  1854.   (* $SaveRegs+ *)
  1855.   (* $CopyArrays- *)
  1856.     BEGIN
  1857.       TextObject( m.aTextPreParse, y.ADR( "\033r" ),
  1858.                   m.aTextContents, y.ADR( label ),
  1859.                   m.aTextHiChar  , ORD( hichar ),
  1860.                   m.aWeight      , 0,
  1861.                   m.aInnerLeft   , 0,
  1862.                   m.aInnerRight  , 0,
  1863.                   u.end );
  1864.       RETURN End();
  1865.     END KeyLabel;
  1866.  
  1867.   PROCEDURE KeyLabel1 * ( label : ARRAY OF CHAR; hichar : CHAR ):m.Object;
  1868.   (* $SaveRegs+ *)
  1869.   (* $CopyArrays- *)
  1870.     BEGIN
  1871.       TextObject( m.aTextPreParse, y.ADR( "\033r" ),
  1872.                   m.aTextContents, y.ADR( label ),
  1873.                   m.aTextHiChar  , ORD( hichar ),
  1874.                   m.aWeight      , 0,
  1875.                   m.aInnerLeft   , 0,
  1876.                   m.aInnerRight  , 0,
  1877.                   u.end );
  1878.         ButtonFrame;
  1879.           TagItem( m.aFramePhantomHoriz, e.true );
  1880.       RETURN End();
  1881.     END KeyLabel1;
  1882.  
  1883.   PROCEDURE KeyLabel2 * ( label : ARRAY OF CHAR; hichar : CHAR ):m.Object;
  1884.   (* $SaveRegs+ *)
  1885.   (* $CopyArrays- *)
  1886.     BEGIN
  1887.       TextObject( m.aTextPreParse, y.ADR( "\033r" ),
  1888.                   m.aTextContents, y.ADR( label ),
  1889.                   m.aTextHiChar  , ORD( hichar ),
  1890.                   m.aWeight      , 0,
  1891.                   m.aInnerLeft   , 0,
  1892.                   m.aInnerRight  , 0,
  1893.                   u.end );
  1894.         StringFrame;
  1895.           TagItem( m.aFramePhantomHoriz, e.true );
  1896.       RETURN End();
  1897.     END KeyLabel2;
  1898.  
  1899.   PROCEDURE KeyLLabel * ( label : ARRAY OF CHAR; hichar : CHAR ):m.Object;
  1900.   (* $SaveRegs+ *)
  1901.   (* $CopyArrays- *)
  1902.     BEGIN
  1903.       TextObject( m.aTextContents, y.ADR( label ),
  1904.                   m.aTextHiChar  , ORD( hichar ),
  1905.                   m.aWeight      , 0,
  1906.                   m.aInnerLeft   , 0,
  1907.                   m.aInnerRight  , 0,
  1908.                   u.end );
  1909.       RETURN End();
  1910.     END KeyLLabel;
  1911.  
  1912.   PROCEDURE KeyLLabel1 * ( label : ARRAY OF CHAR; hichar : CHAR ):m.Object;
  1913.   (* $SaveRegs+ *)
  1914.   (* $CopyArrays- *)
  1915.     BEGIN
  1916.       TextObject( m.aTextContents, y.ADR( label ),
  1917.                   m.aTextHiChar  , ORD( hichar ),
  1918.                   m.aWeight      , 0,
  1919.                   m.aInnerLeft   , 0,
  1920.                   m.aInnerRight  , 0,
  1921.                   u.end );
  1922.         ButtonFrame;
  1923.           TagItem( m.aFramePhantomHoriz, e.true );
  1924.       RETURN End();
  1925.     END KeyLLabel1;
  1926.  
  1927.   PROCEDURE KeyLLabel2 * ( label : ARRAY OF CHAR; hichar : CHAR ):m.Object;
  1928.   (* $SaveRegs+ *)
  1929.   (* $CopyArrays- *)
  1930.     BEGIN
  1931.       TextObject( m.aTextContents, y.ADR( label ),
  1932.                   m.aTextHiChar  , ORD( hichar ),
  1933.                   m.aWeight      , 0,
  1934.                   m.aInnerLeft   , 0,
  1935.                   m.aInnerRight  , 0,
  1936.                   u.end );
  1937.         StringFrame;
  1938.           TagItem( m.aFramePhantomHoriz, e.true );
  1939.       RETURN End();
  1940.     END KeyLLabel2;
  1941.  
  1942.   PROCEDURE label * {"MuiBasics.Label"} ( lab : ARRAY OF CHAR );
  1943.  
  1944.   PROCEDURE label1 * {"MuiBasics.Label1"} ( lab : ARRAY OF CHAR );
  1945.  
  1946.   PROCEDURE label2 * {"MuiBasics.Label2"} ( lab : ARRAY OF CHAR );
  1947.  
  1948.   PROCEDURE lLabel * {"MuiBasics.LLabel"} ( lab : ARRAY OF CHAR );
  1949.  
  1950.   PROCEDURE lLabel1 * {"MuiBasics.LLabel1"} ( lab : ARRAY OF CHAR );
  1951.  
  1952.   PROCEDURE lLabel2 * {"MuiBasics.LLabel2"} ( lab : ARRAY OF CHAR );
  1953.  
  1954.   PROCEDURE keyLabel * {"MuiBasics.KeyLabel"} ( lab : ARRAY OF CHAR; hichar : CHAR );
  1955.  
  1956.   PROCEDURE keyLabel1 * {"MuiBasics.KeyLabel1"} ( lab : ARRAY OF CHAR; hichar : CHAR );
  1957.  
  1958.   PROCEDURE keyLabel2 * {"MuiBasics.KeyLabel2"} ( lab : ARRAY OF CHAR; hichar : CHAR );
  1959.  
  1960.   PROCEDURE lKeyLabel * {"MuiBasics.LKeyLabel"} ( lab : ARRAY OF CHAR; hichar : CHAR );
  1961.  
  1962.   PROCEDURE lKeyLabel1 * {"MuiBasics.LKeyLabel1"} ( lab : ARRAY OF CHAR; hichar : CHAR );
  1963.  
  1964.   PROCEDURE lKeyLabel2 * {"MuiBasics.LKeyLabel2"} ( lab : ARRAY OF CHAR; hichar : CHAR );
  1965.  
  1966. (***************************************************************************
  1967. **
  1968. ** Controlling Objects
  1969. ** -------------------
  1970. **
  1971. ** Set() and Get() are two short stubs for BOOPSI GetAttr() and SetAttrs()
  1972. ** calls:
  1973. **
  1974. **
  1975. **    VAR x : e.STRPTR;
  1976. **
  1977. **    Set(obj,MUIA_String_Contents, y.ADR("foobar") );
  1978. **    Get(obj,MUIA_String_Contents, x);
  1979. **
  1980. **    Dos.PrintF( "gadget contains '%s'\n" , x );
  1981. **
  1982. ** NNset() sets an attribute without triggering a possible notification.
  1983. **
  1984. **
  1985. ***************************************************************************)
  1986.  
  1987.   PROCEDURE Set*( obj : m.Object; attr, value : e.APTR );
  1988.     BEGIN
  1989.       IF I.SetAttrs( obj, attr, value, u.end ) = 0 THEN END
  1990.     END Set;
  1991.  
  1992.   PROCEDURE Get*( obj : m.Object; attr : LONGINT ; VAR store : ARRAY OF e.BYTE );
  1993.     BEGIN
  1994.       IF I.GetAttr( attr, obj, store) = 0 THEN END
  1995.     END Get;
  1996.  
  1997.   PROCEDURE NNSet( obj : m.Object; attr, value : e.APTR );
  1998.     BEGIN
  1999.       IF I.SetAttrs( obj, m.aNoNotify, e.LTRUE, attr, value, u.end ) = 0 THEN END
  2000.     END NNSet;
  2001.  
  2002.   PROCEDURE SetMutex * ( obj : m.Object; n : LONGINT );
  2003.     BEGIN
  2004.       Set( obj, m.aRadioActive, n );
  2005.     END SetMutex;
  2006.  
  2007.   PROCEDURE SetCycle * ( obj : m.Object; n : LONGINT );
  2008.     BEGIN
  2009.       Set( obj, m.aCycleActive, n );
  2010.     END SetCycle;
  2011.  
  2012.   PROCEDURE SetString * ( obj : m.Object; s : e.STRPTR );
  2013.     BEGIN
  2014.       Set( obj, m.aStringContents, s );
  2015.     END SetString;
  2016.  
  2017.   PROCEDURE SetCheckmark * ( obj : m.Object; b : BOOLEAN );
  2018.     BEGIN
  2019.       Set( obj, m.aSelected, y.VAL(SHORTINT,b) );
  2020.     END SetCheckmark;
  2021.  
  2022.   PROCEDURE SetSlider * ( obj : m.Object; l : LONGINT );
  2023.     BEGIN
  2024.       Set( obj, m.aSliderLevel, l );
  2025.     END SetSlider;
  2026.  
  2027. BEGIN
  2028.   Init();
  2029. END MuiBasics.
  2030.  
  2031.