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