(*------------------------------------------

  :Module.      MuiSimple.mod
  :Author.      Albert Weinert  [awn]
  :Address.     Molkestr. 68, 50859 Köln, Germany
  :EMail.       a.weinert@darkness.gun.de
  :Phone.       +49-2234-480800
  :Revision.    R.5
  :Date.        19-Nov-1995
  :Copyright.   Albert Weinert
  :Language.    Oberon-2
  :Translator.  AmigaOberon V3.20
  :Contents.    Contains the object creation on a simple manner (but not so easy)
  :Contents.    This Module is for "GenCodeOberon" which comes with MuiBuilder 2.0.
  :Remarks.     *Don't mix MuiBasics.mod and MuiSimple.mod objects!!* Do that
  :Remarks.     only if you want do dynamic object creation.
  :Remarks.     Currently, there ist no Version for Oberon-2, 'cause V1.6 lacks
  :Remakrs.     of a little feature.
  :Bugs.        <Bekannte Fehler>
  :Usage.       <Angaben zur Anwendung>
  :History.     .1     [awn] 02-Jul-1994 : Erstellt
  :History.     .2     [awn] 19-Aug-1994 : Do some work at the Module,
  :History.     .3     [awn] 26-Sep-1994 : Requires now muimaster.library V8
  :History.            Must changed some object creation to work with MakeObject()
  :History.            because MuiBuilder 2.0 use features oft this function.
  :History.     .4     [awn] 08-Nov-1994 : All e.STRPTR replaced with e.LSTRPTR,
  :History.            know the Module needs the V40 Interfaces.
  :History.     .5     [awn] 19-Nov-1995 : Updated to MUI 3.1 (V12)

--------------------------------------------*)
MODULE MuiSimple;

IMPORT e := Exec,
       I := Intuition,
       m := Mui,
       u := Utility,
       y :=SYSTEM;

TYPE
(* <*IF OberonA THEN*> $IF OberonA *)
  Args      * = POINTER [2] TO ArgsDesc;
  ArgsDesc  * = RECORD [2] END;
(* <* ELSE *> $ELSE *)
  Args      * = UNTRACED POINTER TO ArgsDesc;
  ArgsDesc  * = STRUCT END;
(* <*END*> $END *)

  HookDef * = PROCEDURE ( hook : u.HookPtr; object : m.Object; args : Args ):LONGINT;

  PROCEDURE MakeHook* ( VAR hook : u.Hook; entry: HookDef );
    BEGIN
      u.InitHook( y.ADR( hook ), y.VAL( u.HookFunc, entry ) );
    END MakeHook;

  PROCEDURE SemaphoreObject*{"MuiSimple.SemaphoreObjectA"} ( tags{9}.. : u.Tag):m.Object;
  PROCEDURE SemaphoreObjectA*( tags{9} : u.TagListPtr ):m.Object;
    BEGIN (* SaveReg+ *)
      RETURN m.NewObject( m.cSemaphore, u.more, tags );
    END SemaphoreObjectA;

  PROCEDURE DataspaceObject*{"MuiSimple.DataspaceObjectA"} ( tags{9}.. : u.Tag):m.Object;
  PROCEDURE DataspaceObjectA*( tags{9} : u.TagListPtr ):m.Object;
    BEGIN (* SaveReg+ *)
      RETURN m.NewObject( m.cDataspace, u.more, tags );
    END DataspaceObjectA;

  PROCEDURE ConfigdataObject*{"MuiSimple.ConfigdataObjectA"} ( tags{9}.. : u.Tag):m.Object;
  PROCEDURE ConfigdataObjectA*( tags{9} : u.TagListPtr ):m.Object;
    BEGIN (* SaveReg+ *)
      RETURN m.NewObject( m.cConfigdata, u.more, tags );
    END ConfigdataObjectA;

  PROCEDURE FamilyObject*{"MuiSimple.FamilyObjectA"} ( tags{9}.. : u.Tag):m.Object;
  PROCEDURE FamilyObjectA*( tags{9} : u.TagListPtr ):m.Object;
    BEGIN (* SaveReg+ *)
      RETURN m.NewObject( m.cFamily, u.more, tags );
    END FamilyObjectA;

  PROCEDURE MenustripObject*{"MuiSimple.MenustripObjectA"} ( tags{9}.. : u.Tag):m.Object;
  PROCEDURE MenustripObjectA*( tags{9} : u.TagListPtr ):m.Object;
    BEGIN (* SaveReg+ *)
      RETURN m.NewObject( m.cMenustrip, u.more, tags );
    END MenustripObjectA;

  PROCEDURE MenuObject*{"MuiSimple.MenuObjectA"} ( tags{9}.. : u.Tag):m.Object;
  PROCEDURE MenuObjectA*( tags{9} : u.TagListPtr ):m.Object;
    BEGIN (* SaveReg+ *)
      RETURN m.NewObject( m.cMenu, u.more, tags );
    END MenuObjectA;

  PROCEDURE MenuTObject*{"MuiSimple.MenuTObjectA"} ( name {8}: ARRAY OF CHAR; tags{9}.. : u.Tag):m.Object;
  PROCEDURE MenuTObjectA*( name {8}: e.LSTRPTR; tags{9} : u.TagListPtr ):m.Object;
    BEGIN (* SaveReg+ *)
      RETURN m.NewObject( m.cMenu, m.aMenuTitle, name, u.more, tags );
    END MenuTObjectA;

  PROCEDURE MenuitemObject*{"MuiSimple.MenuitemObjectA"} ( tags{9}.. : u.Tag):m.Object;
  PROCEDURE MenuitemObjectA*( tags{9} : u.TagListPtr ):m.Object;
    BEGIN (* SaveReg+ *)
      RETURN m.NewObject( m.cMenuitem, u.more, tags );
    END MenuitemObjectA;

  PROCEDURE WindowObject*{"MuiSimple.WindowObjectA"} ( tags{9}.. : u.Tag):m.Object;
  PROCEDURE WindowObjectA*( tags{9} : u.TagListPtr ):m.Object;
    BEGIN (* SaveReg+ *)
      RETURN m.NewObject( m.cWindow, u.more, tags );
    END WindowObjectA;

  PROCEDURE ImageObject*{"MuiSimple.ImageObjectA"} ( tags{9}.. : u.Tag): m.Object;
  PROCEDURE ImageObjectA*( tags{9} : u.TagListPtr ): m.Object;
    BEGIN (* SaveReg+ *)
      RETURN m.NewObject( m.cImage, u.more, tags );
    END ImageObjectA;

  PROCEDURE BitmapObject*{"MuiSimple.BitmapObjectA"} ( tags{9}.. : u.Tag):m.Object;
  PROCEDURE BitmapObjectA*( tags{9} : u.TagListPtr ):m.Object;
    BEGIN (* SaveReg+ *)
      RETURN m.NewObject( m.cBitmap, u.more, tags );
    END BitmapObjectA;

  PROCEDURE BodychunkObject*{"MuiSimple.BodychunkObjectA"} ( tags{9}.. : u.Tag):m.Object;
  PROCEDURE BodychunkObjectA*( tags{9} : u.TagListPtr ):m.Object;
    BEGIN (* SaveReg+ *)
      RETURN m.NewObject( m.cBodychunk, u.more, tags );
    END BodychunkObjectA;

  PROCEDURE NotifyObject*{"MuiSimple.NotifyObjectA"} ( tags{9}.. : u.Tag): m.Object;
  PROCEDURE NotifyObjectA*( tags{9} : u.TagListPtr ): m.Object;
    BEGIN (* SaveReg+ *)
      RETURN m.NewObject( m.cNotify, u.more, tags );
    END NotifyObjectA;

  PROCEDURE ApplicationObject*{"MuiSimple.ApplicationObjectA"} ( tags{9}.. : u.Tag): m.Object;
  PROCEDURE ApplicationObjectA*( tags{9} : u.TagListPtr ): m.Object;
    BEGIN (* SaveReg+ *)
      RETURN m.NewObject( m.cApplication, u.more, tags );
    END ApplicationObjectA;

  PROCEDURE TextObject*{"MuiSimple.TextObjectA"} ( tags{9}.. : u.Tag): m.Object;
  PROCEDURE TextObjectA*( tags{9} : u.TagListPtr ): m.Object;
    BEGIN (* SaveReg+ *)
      RETURN m.NewObject( m.cText, u.more, tags );
    END TextObjectA;

  PROCEDURE RectangleObject*{"MuiSimple.RectangleObjectA"} ( tags{9}.. : u.Tag): m.Object;
  PROCEDURE RectangleObjectA*( tags{9} : u.TagListPtr ): m.Object;
    BEGIN (* SaveReg+ *)
      RETURN m.NewObject( m.cRectangle, u.more, tags );
    END RectangleObjectA;

  PROCEDURE ListObject*{"MuiSimple.ListObjectA"} ( tags{9}.. : u.Tag): m.Object;
  PROCEDURE ListObjectA*( tags{9} : u.TagListPtr ): m.Object;
    BEGIN (* SaveReg+ *)
      RETURN m.NewObject( m.cList, u.more, tags );
    END ListObjectA;

  PROCEDURE PropObject*{"MuiSimple.PropObjectA"} ( tags{9}.. : u.Tag): m.Object;
  PROCEDURE PropObjectA*( tags{9} : u.TagListPtr ): m.Object;
    BEGIN (* SaveReg+ *)
      RETURN m.NewObject( m.cProp, u.more, tags );
    END PropObjectA;

  PROCEDURE StringObject*{"MuiSimple.StringObjectA"} ( tags{9}.. : u.Tag): m.Object;
  PROCEDURE StringObjectA*( tags{9} : u.TagListPtr ): m.Object;
    BEGIN (* SaveReg+ *)
      RETURN m.NewObject( m.cString, u.more, tags );
    END StringObjectA;

  PROCEDURE ScrollbarObject*{"MuiSimple.ScrollbarObjectA"} ( tags{9}.. : u.Tag): m.Object;
  PROCEDURE ScrollbarObjectA*( tags{9} : u.TagListPtr ): m.Object;
    BEGIN (* SaveReg+ *)
      RETURN m.NewObject( m.cScrollbar, u.more, tags );
    END ScrollbarObjectA;

  PROCEDURE ListviewObject*{"MuiSimple.ListviewObjectA"} ( tags{9}.. : u.Tag): m.Object;
  PROCEDURE ListviewObjectA*( tags{9} : u.TagListPtr ): m.Object;
    BEGIN (* SaveReg+ *)
      RETURN m.NewObject( m.cListview, u.more, tags );
    END ListviewObjectA;

  PROCEDURE RadioObject*{"MuiSimple.RadioObjectA"} ( tags{9}.. : u.Tag): m.Object;
  PROCEDURE RadioObjectA*( tags{9} : u.TagListPtr ): m.Object;
    BEGIN (* SaveReg+ *)
      RETURN m.NewObject( m.cRadio, u.more, tags );
    END RadioObjectA;

  PROCEDURE VolumelistObject*{"MuiSimple.VolumelistObjectA"} ( tags{9}.. : u.Tag): m.Object;
  PROCEDURE VolumelistObjectA*( tags{9} : u.TagListPtr ): m.Object;
    BEGIN (* SaveReg+ *)
      RETURN m.NewObject( m.cVolumelist, u.more, tags );
    END VolumelistObjectA;

  PROCEDURE FloattextObject*{"MuiSimple.FloattextObjectA"} ( tags{9}.. : u.Tag): m.Object;
  PROCEDURE FloattextObjectA*( tags{9} : u.TagListPtr ): m.Object;
    BEGIN (* SaveReg+ *)
      RETURN m.NewObject( m.cFloattext, u.more, tags );
    END FloattextObjectA;

  PROCEDURE DirlistObject*{"MuiSimple.DirlistObjectA"} ( tags{9}.. : u.Tag): m.Object;
  PROCEDURE DirlistObjectA*( tags{9} : u.TagListPtr ): m.Object;
    BEGIN (* SaveReg+ *)
      RETURN m.NewObject( m.cDirlist, u.more, tags );
    END DirlistObjectA;

  PROCEDURE CycleObject*{"MuiSimple.CycleObjectA"} ( tags{9}.. : u.Tag): m.Object;
  PROCEDURE CycleObjectA*( tags{9} : u.TagListPtr ): m.Object;
    BEGIN (* SaveReg+ *)
      RETURN m.NewObject( m.cCycle, u.more, tags );
    END CycleObjectA;

  PROCEDURE GaugeObject*{"MuiSimple.GaugeObjectA"} ( tags{9}.. : u.Tag): m.Object;
  PROCEDURE GaugeObjectA*( tags{9} : u.TagListPtr ): m.Object;
    BEGIN (* SaveReg+ *)
      RETURN m.NewObject( m.cGauge, u.more, tags );
    END GaugeObjectA;

  PROCEDURE NumericObject*{"MuiSimple.NumericObjectA"} ( tags{9}.. : u.Tag):m.Object;
  PROCEDURE NumericObjectA*( tags{9} : u.TagListPtr ):m.Object;
    BEGIN (* SaveReg+ *)
      RETURN m.NewObject( m.cNumeric, u.more, tags );
    END NumericObjectA;

  PROCEDURE SliderObject*{"MuiSimple.SliderObjectA"} ( tags{9}.. : u.Tag): m.Object;
  PROCEDURE SliderObjectA*( tags{9} : u.TagListPtr ): m.Object;
    BEGIN (* SaveReg+ *)
      RETURN m.NewObject( m.cSlider, u.more, tags );
    END SliderObjectA;

  PROCEDURE NumericbutonObject*{"MuiSimple.NumericbuttonObjectA"} ( tags{9}.. : u.Tag):m.Object;
  PROCEDURE NumericbuttonObjectA*( tags{9} : u.TagListPtr ):m.Object;
    BEGIN (* SaveReg+ *)
      RETURN m.NewObject( m.cNumericbutton, u.more, tags );
    END NumericbuttonObjectA;

  PROCEDURE KnobObject*{"MuiSimple.KnobObjectA"} ( tags{9}.. : u.Tag):m.Object;
  PROCEDURE KnobObjectA*( tags{9} : u.TagListPtr ):m.Object;
    BEGIN (* SaveReg+ *)
      RETURN m.NewObject( m.cKnob, u.more, tags );
    END KnobObjectA;

  PROCEDURE LevelmeterObject*{"MuiSimple.LevelmeterObjectA"} ( tags{9}.. : u.Tag):m.Object;
  PROCEDURE LevelmeterObjectA*( tags{9} : u.TagListPtr ):m.Object;
    BEGIN (* SaveReg+ *)
      RETURN m.NewObject( m.cLevelmeter, u.more, tags );
    END LevelmeterObjectA;

  PROCEDURE ScaleObject*{"MuiSimple.ScaleObjectA"} ( tags{9}.. : u.Tag): m.Object;
  PROCEDURE ScaleObjectA*( tags{9} : u.TagListPtr ): m.Object;
    BEGIN (* SaveReg+ *)
      RETURN m.NewObject( m.cScale, u.more, tags );
    END ScaleObjectA;

  PROCEDURE BoopsiObject*{"MuiSimple.BoopsiObjectA"} ( tags{9}.. : u.Tag): m.Object;
  PROCEDURE BoopsiObjectA*( tags{9} : u.TagListPtr ): m.Object;
    BEGIN (* SaveReg+ *)
      RETURN m.NewObject( m.cBoopsi, u.more, tags );
    END BoopsiObjectA;

  PROCEDURE ColorfieldObject*{"MuiSimple.ColorfieldObjectA"} ( tags{9}.. : u.Tag): m.Object;
  PROCEDURE ColorfieldObjectA*( tags{9} : u.TagListPtr ): m.Object;
    BEGIN (* SaveReg+ *)
      RETURN m.NewObject( m.cColorfield, u.more, tags );
    END ColorfieldObjectA;

  PROCEDURE ColoradjustObject*{"MuiSimple.ColoradjustObjectA"} ( tags{9}.. : u.Tag): m.Object;
  PROCEDURE ColoradjustObjectA*( tags{9} : u.TagListPtr ): m.Object;
    BEGIN (* SaveReg+ *)
      RETURN m.NewObject( m.cColoradjust, u.more, tags );
    END ColoradjustObjectA;

  PROCEDURE PenadjustObject*{"MuiSimple.PenadjustObjectA"} ( tags{9}.. : u.Tag):m.Object;
  PROCEDURE PenadjustObjectA*( tags{9} : u.TagListPtr ):m.Object;
    BEGIN (* SaveReg+ *)
      RETURN m.NewObject( m.cPenadjust, u.more, tags );
    END PenadjustObjectA;

 PROCEDURE PaletteObject*{"MuiSimple.PaletteObjectA"} ( tags{9}.. : u.Tag): m.Object;
  PROCEDURE PaletteObjectA*( tags{9} : u.TagListPtr ): m.Object;
    BEGIN (* SaveReg+ *)
      RETURN m.NewObject( m.cPalette, u.more, tags );
    END PaletteObjectA;

  PROCEDURE GroupObject*{"MuiSimple.GroupObjectA"} ( tags{9}.. : u.Tag): m.Object;
  PROCEDURE GroupObjectA*( tags{9} : u.TagListPtr ): m.Object;
    BEGIN (* SaveReg+ *)
      RETURN m.NewObject( m.cGroup, u.more, tags );
    END GroupObjectA;

  PROCEDURE RegisterObject*{"MuiSimple.RegisterObjectA"} ( tags{9}.. : u.Tag): m.Object;
  PROCEDURE RegisterObjectA*( tags{9} : u.TagListPtr ): m.Object;
    BEGIN (* SaveReg+ *)
      RETURN m.NewObject( m.cRegister, u.more, tags );
    END RegisterObjectA;

  PROCEDURE VirtgroupObject*{"MuiSimple.VirtgroupObjectA"} ( tags{9}.. : u.Tag): m.Object;
  PROCEDURE VirtgroupObjectA*( tags{9} : u.TagListPtr ): m.Object;
    BEGIN (* SaveReg+ *)
      RETURN m.NewObject( m.cVirtgroup, u.more, tags );
    END VirtgroupObjectA;

  PROCEDURE ScrollgroupObject*{"MuiSimple.ScrollgroupObjectA"} ( tags{9}.. : u.Tag ): m.Object;
  PROCEDURE ScrollgroupObjectA*( tags{9} : u.TagListPtr ): m.Object;
    BEGIN (* SaveReg+ *)
      RETURN m.NewObject( m.cScrollgroup, u.more, tags );
    END ScrollgroupObjectA;

  PROCEDURE PopstringObject*{"MuiSimple.PopstringObjectA"} ( tags{9}.. : u.Tag): m.Object;
  PROCEDURE PopstringObjectA*( tags{9} : u.TagListPtr ): m.Object;
    BEGIN (* SaveReg+ *)
      RETURN m.NewObject( m.cPopstring, u.more, tags );
    END PopstringObjectA;

  PROCEDURE PopobjectObject*{"MuiSimple.PopobjectObjectA"} ( tags{9}.. : u.Tag): m.Object;
  PROCEDURE PopobjectObjectA*( tags{9} : u.TagListPtr ): m.Object;
    BEGIN (* SaveReg+ *)
      RETURN m.NewObject( m.cPopobject, u.more, tags );
    END PopobjectObjectA;

  PROCEDURE PoplistObject*{"MuiSimple.PoplistObjectA"} ( tags{9}.. : u.Tag): m.Object;
  PROCEDURE PoplistObjectA*( tags{9} : u.TagListPtr ): m.Object;
    BEGIN (* SaveReg+ *)
      RETURN m.NewObject( m.cPoplist, u.more, tags );
    END PoplistObjectA;

  PROCEDURE PopaslObject*{"MuiSimple.PopaslObjectA"} ( tags{9}.. : u.Tag): m.Object;
  PROCEDURE PopaslObjectA*( tags{9} : u.TagListPtr ): m.Object;
    BEGIN (* SaveReg+ *)
      RETURN m.NewObject( m.cPopasl, u.more, tags );
    END PopaslObjectA;

  PROCEDURE PoppenObject*{"MuiSimple.PoppenObjectA"} ( tags{9}.. : u.Tag):m.Object;
  PROCEDURE PoppenObjectA*( tags{9} : u.TagListPtr ):m.Object;
    BEGIN (* SaveReg+ *)
      RETURN m.NewObject( m.cPoppen, u.more, tags );
    END PoppenObjectA;

  PROCEDURE AboutmuiObject*{"MuiSimple.AboutmuiObjectA"} ( tags{9}.. : u.Tag):m.Object;
  PROCEDURE AboutmuiObjectA*( tags{9} : u.TagListPtr ):m.Object;
    BEGIN (* SaveReg+ *)
      RETURN m.NewObject( m.cAboutmui, u.more, tags );
    END AboutmuiObjectA;

  PROCEDURE ScrmodelistObject*{"MuiSimple.ScrmodelistObjectA"} ( tags{9}.. : u.Tag): m.Object;
  PROCEDURE ScrmodelistObjectA*( tags{9} : u.TagListPtr ): m.Object;
    BEGIN (* SaveReg+ *)
      RETURN m.NewObject( m.cScrmodelist, u.more, tags );
    END ScrmodelistObjectA;

  PROCEDURE VGroup*{"MuiSimple.VGroupA"}( tags{9}.. : u.Tag ): m.Object;
  PROCEDURE VGroupA*( tags{9} : u.TagListPtr ): m.Object;
    BEGIN (* SaveReg+ *)
      RETURN m.NewObject( m.cGroup, u.more, tags );
    END VGroupA;

  PROCEDURE HGroup*{"MuiSimple.HGroupA"}( tags{9}.. : u.Tag ): m.Object;
  PROCEDURE HGroupA*( tags{9} : u.TagListPtr ): m.Object;
    BEGIN (* SaveReg+ *)
      RETURN m.NewObject( m.cGroup, m.aGroupHoriz, e.true, u.more, tags );
    END HGroupA;

  PROCEDURE ColGroup*{"MuiSimple.ColGroupA"} ( cols{3} : LONGINT; tags{9}.. : u.Tag );
  PROCEDURE ColGroupA*( cols{3} : LONGINT; tags{9} : u.TagListPtr  ): m.Object;
    BEGIN (* SaveReg+ *)
      RETURN m.NewObject( m.cGroup, m.aGroupColumns, cols, u.more, tags );
    END ColGroupA;

  PROCEDURE RowGroup*{"MuiSimple.RowGroupA"}( rows{3} : LONGINT; tags{9}.. : u.Tag  ): m.Object;
  PROCEDURE RowGroupA*( rows{3} : LONGINT; tags{9} : u.TagListPtr  ): m.Object;
    BEGIN (* SaveReg+ *)
      RETURN m.NewObject( m.cGroup, m.aGroupRows, rows, u.more, tags );
    END RowGroupA;

  PROCEDURE PageGroup*{"MuiSimple.PageGroupA"}( tags{9}.. : u.Tag ): m.Object;
  PROCEDURE PageGroupA*( tags{9} : u.TagListPtr ): m.Object;
    BEGIN (* SaveReg+ *)
      RETURN m.NewObject( m.cGroup, m.aGroupPageMode, e.true, u.more, tags );
    END PageGroupA;

  PROCEDURE VGroupV*{"MuiSimple.VGroupVA"}( tags{9}.. : u.Tag ): m.Object;
  PROCEDURE VGroupVA*( tags{9} : u.TagListPtr ): m.Object;
    BEGIN (* SaveReg+ *)
      RETURN m.NewObject( m.cVirtgroup, u.more, tags );
    END VGroupVA;

  PROCEDURE HGroupV*{"MuiSimple.HGroupVA"}( tags{9}.. : u.Tag ): m.Object;
  PROCEDURE HGroupVA*( tags{9} : u.TagListPtr ): m.Object;
    BEGIN (* SaveReg+ *)
      RETURN m.NewObject( m.cVirtgroup, m.aGroupHoriz, e.true, u.more, tags );
    END HGroupVA;

  PROCEDURE ColGroupV*{"MuiSimple.ColGroupVA"} ( cols{3} : LONGINT; tags{9}.. : u.Tag ): m.Object;
  PROCEDURE ColGroupVA*( cols{3} : LONGINT; tags{9} : u.TagListPtr  ): m.Object;
    BEGIN (* SaveReg+ *)
      RETURN m.NewObject( m.cVirtgroup, m.aGroupColumns, cols, u.more, tags );
    END ColGroupVA;

  PROCEDURE RowGroupV*{"MuiSimple.RowGroupVA"}( rows{3} : LONGINT; tags{9}.. : u.Tag  ): m.Object;
  PROCEDURE RowGroupVA*( rows{3} : LONGINT; tags{9} : u.TagListPtr  ): m.Object;
    BEGIN (* SaveReg+ *)
      RETURN m.NewObject( m.cVirtgroup, m.aGroupRows, rows, u.more, tags);
    END RowGroupVA;

  PROCEDURE PageGroupV*{"MuiSimple.PageGroupVA"}( tags{9}.. : u.Tag ): m.Object;
  PROCEDURE PageGroupVA*( tags{9} : u.TagListPtr ): m.Object;
    BEGIN (* SaveReg+ *)
      RETURN m.NewObject( m.cVirtgroup, m.aGroupPageMode, e.true, u.more, tags );
    END PageGroupVA;

  PROCEDURE RegisterGroup*{"MuiSimple.RegisterGroupA"}( t{8} : e.APTR; tags{9}.. : u.Tag ): m.Object;
  PROCEDURE RegisterGroupA*( t{8} : e.APTR; tags{9} : u.TagListPtr ): m.Object;
    BEGIN (* SaveReg+ *)
      RETURN m.NewObject( m.cRegister, m.aRegisterTitles, t, u.more, tags );
    END RegisterGroupA;


(***************************************************************************
**
** Baring Procedures
** ------------------
**
***************************************************************************)

  PROCEDURE HBar*(): m.Object;
    BEGIN (* SaveReg+ *)
      RETURN m.NewObject( m.cRectangle,
			  m.aRectangleHBar, e.true,
			  m.aFixHeight, 2,
			  u.done ) ;
    END HBar;

  PROCEDURE VBar*(): m.Object;
    BEGIN (* SaveReg+ *)
      RETURN m.NewObject( m.cRectangle,
			  m.aRectangleVBar, e.true,
			  m.aFixWidth, 2,
			  u.done );
    END VBar;

(***************************************************************************
**
** Spacing Procedures
** ------------------
**
***************************************************************************)

  PROCEDURE HVSpace*(): m.Object;
    BEGIN (* SaveReg+ *)
      RETURN m.NewObject( m.cRectangle, u.done );
    END HVSpace;

(*
 *  PROCEDURE GroupSpacing*( x: LONGINT );
 *  (*  *)
 *    BEGIN (* SaveReg+ *)
 *      TagItem( m.aGroupSpacing, x );
 *    END GroupSpacing;
 *)

  PROCEDURE HSpace*( x : LONGINT ): m.Object;
    BEGIN (* SaveReg+ *)
      RETURN m.MakeObject( m.oHSpace, x );
    END HSpace;

  PROCEDURE VSpace*( x : LONGINT ): m.Object;
    BEGIN (* SaveReg+ *)
      RETURN m.MakeObject( m.oVSpace, x );
    END VSpace;


  PROCEDURE HCenterObject*( obj : m.Object ): m.Object;
    VAR spL, spR : m.Object;
    BEGIN (* SaveReg+ *)
      spL := HSpace( 0 );
      spR := HSpace( 0 );
      RETURN HGroup( m.aGroupSpacing, 0,
		     m.aGroupChild, spL,
		     m.aGroupChild, obj,
		     m.aGroupChild, spR,
		     u.end );
    END HCenterObject;

  PROCEDURE VCenterObject*( obj : m.Object ): m.Object;
    VAR spO, spU : m.Object;
    BEGIN (* SaveReg+ *)
      spO := VSpace( 0 );
      spU := VSpace( 0 );
      RETURN VGroup( m.aGroupSpacing,0,
		     m.aGroupChild, spO,
		     m.aGroupChild, obj,
		     m.aGroupChild, spU,
		     u.end );
    END VCenterObject;


(*
 *  PROCEDURE InnerSpacing*( h, v : LONGINT );
 *  (*  *)
 *    BEGIN (* SaveReg+ *)
 *      Tags( m.aInnerLeft   , h,
 *            m.aInnerRight  , h,
 *            m.aInnerTop    , v,
 *            m.aInnerBottom , v,
 *            u.end );
 *    END InnerSpacing;
 *)


(***************************************************************************
**
** String-Object
** -------------
**
** The following procedure creates a simple string gadget.
**
***************************************************************************)

  PROCEDURE String * {"MuiSimple.StringA"} ( contents{8} : ARRAY OF CHAR; maxlen{3} : LONGINT; tags{9}.. : u.Tag ):m.Object;
  PROCEDURE StringA*( contents{8} : e.LSTRPTR; maxlen{3} : LONGINT; tags{9} : u.TagListPtr ):m.Object;
    BEGIN (* SaveReg+ *)
      RETURN StringObject( m.aFrame, m.vFrameString,
			   m.aStringMaxLen, maxlen,
			   m.aStringContents, contents,
			   u.more, tags );
    END StringA;

  PROCEDURE KeyString * {"MuiSimple.KeyStringA"} ( contents{8} : ARRAY OF CHAR; maxlen{3} : LONGINT; controlchar{4}: CHAR; tags{9}.. : u.Tag ):m.Object;
  PROCEDURE KeyStringA*( contents{8} : e.LSTRPTR; maxlen{3} : LONGINT; controlchar{4} : LONGINT; tags{9} : u.TagListPtr ):m.Object;
    BEGIN (* SaveReg+ *)
      RETURN String( contents^, maxlen, m.aControlChar, controlchar, u.more, tags );
    END KeyStringA;

(***************************************************************************
**
** Integer-Object
** --------------
**
** The following procedure creates a simple integer string gadget.
**
***************************************************************************)

  PROCEDURE Integer * {"MuiSimple.IntegerA"} ( contents{0} : LONGINT; maxlen{1} : LONGINT; tags{9}.. : u.Tag ):m.Object;
  PROCEDURE IntegerA*( contents{0} : LONGINT; maxlen{1} : LONGINT; tags{9} : u.TagListPtr ):m.Object;
    BEGIN (* SaveReg+ *)
      RETURN StringObject( m.aFrame, m.vFrameString,
			   m.aStringMaxLen, maxlen,
			   m.aStringInteger, contents,
			   m.aStringAccept, y.ADR( "0123456789" ),
			   u.more, tags );
    END IntegerA;

  PROCEDURE KeyInteger * {"MuiSimple.KeyIntegerA"} ( contents{0} : LONGINT; maxlen{1} : LONGINT; controlchar{2}: CHAR; tags{9}.. : u.Tag ):m.Object;
  PROCEDURE KeyIntegerA*( contents{0} : LONGINT; maxlen{1} : LONGINT; controlchar{2} : LONGINT; tags{9} : u.TagListPtr ):m.Object;
    BEGIN (* SaveReg+ *)
      RETURN Integer( contents, maxlen, m.aControlChar, controlchar, u.more, tags );
    END KeyIntegerA;

(***************************************************************************
**
** CheckMark-Object
** ----------------
**
** The following procedure creates a checkmark gadget.
**
***************************************************************************)

  PROCEDURE CheckMark * {"MuiSimple.CheckMarkA"}( checked{4} : BOOLEAN; tags{9}.. : u.Tag ):m.Object;
  PROCEDURE CheckMarkA*( checked{4} : e.LONGBOOL; tags{9} : u.TagListPtr ):m.Object;
   BEGIN (* SaveReg+ *)
    RETURN ImageObject( m.aFrame, m.vFrameImageButton,
			m.aInputMode, m.vInputModeToggle,
			m.aImageSpec, m.iCheckMark,
			m.aImageFreeVert, e.true,
			m.aSelected, checked,
			m.aBackground, m.iButtonBack,
			m.aShowSelState, e.false,
			u.more, tags );
    END CheckMarkA;

  PROCEDURE KeyCheckMark *{"MuiSimple.KeyCheckMarkA"}( checked{4} : BOOLEAN; key{3} : CHAR; tags{9}.. : u.Tag ):m.Object;
  PROCEDURE KeyCheckMarkA*( checked{4} : e.LONGBOOL; key{3} : LONGINT; tags{9} : u.TagListPtr ):m.Object;
   BEGIN (* SaveReg+ *)
    RETURN CheckMark( y.VAL(BOOLEAN,SHORT(SHORT(checked))), m.aControlChar, key, u.more, tags );
    END KeyCheckMarkA;


(***************************************************************************
**
** Button-Objects
** --------------
**
** Note: Use small letters for KeyButtons, e.g.
**       KeyButton("Cancel",'c')  and not  KeyButton("Cancel",'C') !!
**
***************************************************************************)

  PROCEDURE Button* {"MuiSimple.ButtonA"} ( label{8} : ARRAY OF CHAR ): m.Object;
  PROCEDURE ButtonA* (label{8} : y.ADDRESS ):m.Object;
    BEGIN
      RETURN m.MakeObject( m.oButton, label );
    END ButtonA;
	    
  PROCEDURE SimpleButton * {"MuiSimple.SimpleButtonA"} ( name{8} : ARRAY OF CHAR ):m.Object;
  PROCEDURE SimpleButtonA * ( name{8} : e.LSTRPTR ):m.Object;
    BEGIN (* SaveReg+ *)
      RETURN m.MakeObject( m.oButton, name );
    END SimpleButtonA;


(***************************************************************************
**
** Cycle-Object
** ------------
**
***************************************************************************)

  PROCEDURE Cycle * {"MuiSimple.CycleA"} ( entries{10} : e.APTR; tags{9}.. : u.Tag ):m.Object;
  PROCEDURE CycleA * ( entries{10} : e.APTR; tags{9} : u.TagListPtr ):m.Object;
    BEGIN (* SaveReg+ *)
      RETURN CycleObject( m.aCycleEntries, entries, u.more, tags );
    END CycleA;

  PROCEDURE KeyCycle * {"MuiSimple.KeyCycleA"} ( entries{10} : e.APTR; key{4} : CHAR; tags{9}.. : u.Tag ):m.Object;
  PROCEDURE KeyCycleA * ( entries{10} : e.APTR; key{4} : LONGINT; tags{9} : u.TagListPtr ):m.Object;
    BEGIN (* SaveReg+ *)
      RETURN Cycle( entries, m.aControlChar, key, u.more, tags );
    END KeyCycleA;

(***************************************************************************
**
** Radio-Object
** ------------
**
***************************************************************************)

  PROCEDURE Radio * {"MuiSimple.RadioA"} ( name{8} : ARRAY OF CHAR; entries{10} : e.APTR; tags{9}.. : u.Tag ):m.Object;
  PROCEDURE RadioA * ( name{8}: e.LSTRPTR; entries{10} : e.APTR; tags{9} : u.TagListPtr ):m.Object;
    BEGIN (* SaveReg+ *)
      RETURN RadioObject( m.aFrame, m.vFrameGroup,
			  m.aFrameTitle, name,
			  m.aRadioEntries, entries,
			  u.more, tags );
    END RadioA;

  PROCEDURE KeyRadio * {"MuiSimple.KeyRadioA"} ( name{8} : ARRAY OF CHAR; entries{10} : e.APTR; key{4} : CHAR; tags{9}.. : u.Tag ):m.Object;
  PROCEDURE KeyRadioA * ( name{8}: e.LSTRPTR; entries{10} : e.APTR; key{4} : LONGINT; tags{9} : u.TagListPtr ):m.Object;
    BEGIN (* SaveReg+ *)
      RETURN Radio( name^, entries, m.aControlChar, key, u.more, tags );
    END KeyRadioA;

(***************************************************************************
**
** Slider-Object
** -------------
**
***************************************************************************)

  PROCEDURE Slider * {"MuiSimple.SliderA"} ( min{0}, max{1}, level{2} : LONGINT; tags{9}.. : u.Tag ):m.Object;
  PROCEDURE SliderA * ( min{0}, max{1}, level{2} : LONGINT; tags{9} : u.TagListPtr ):m.Object;
    BEGIN (* SaveReg+ *)
      RETURN SliderObject( m.aSliderMin, min,
			   m.aSliderMax, max,
			   m.aSliderLevel, level,
			   u.more, tags );
    END SliderA;

  PROCEDURE KeySlider * {"MuiSimple.KeySliderA"} ( min{0}, max{1}, level{2} : LONGINT; key{3} : CHAR; tags{9}.. : u.Tag ):m.Object;
  PROCEDURE KeySliderA * ( min{0}, max{1}, level{2}, key{3} : LONGINT; tags{9} : u.TagListPtr ):m.Object;
    BEGIN (* SaveReg+ *)
      RETURN Slider( min, max, level, m.aControlChar, key, u.more, tags );
    END KeySliderA;

  PROCEDURE VSlider * {"MuiSimple.VSliderA"} ( min{0}, max{1}, level{2} : LONGINT; tags{9}.. : u.Tag ):m.Object;
  PROCEDURE VSliderA * ( min{0}, max{1}, level{2} : LONGINT; tags{9} : u.TagListPtr ):m.Object;
    BEGIN (* SaveReg+ *)
      RETURN Slider( min, max, level, m.aGroupHoriz, e.false, u.more, tags );
    END VSliderA;

  PROCEDURE KeyVSlider * {"MuiSimple.KeyVSliderA"} ( min{0}, max{1}, level{2} : LONGINT; key{3} : CHAR; tags{9}.. : u.Tag ):m.Object;
  PROCEDURE KeyVSliderA * ( min{0}, max{1}, level{2}, key{3} : LONGINT; tags{9} : u.TagListPtr ):m.Object;
    BEGIN (* SaveReg+ *)
      RETURN VSlider( min,  max, level, m.aControlChar, key, u.more, tags );
    END KeyVSliderA;

(***************************************************************************
**
** Scrollbar-Object
** -------------
**
***************************************************************************)

  PROCEDURE Scrollbar * {"MuiSimple.ScrollbarA"} ( min{0}, max{1}, level{2} : LONGINT; tags{9}.. : u.Tag ):m.Object;
  PROCEDURE ScrollbarA * ( min{0}, max{1}, level{2} : LONGINT; tags{9} : u.TagListPtr ):m.Object;
    BEGIN (* SaveReg+ *)
      RETURN ScrollbarObject( m.aSliderMin, min,
			      m.aSliderMax, max,
			      m.aSliderLevel, level,
			      m.aGroupHoriz, e.true,
			      u.more, tags );
    END ScrollbarA;

  PROCEDURE KeyScrollbar * {"MuiSimple.KeyScrollbarA"} ( min{0}, max{1}, level{2} : LONGINT; key{3} : CHAR; tags{9}.. : u.Tag ):m.Object;
  PROCEDURE KeyScrollbarA * ( min{0}, max{1}, level{2}, key{3} : LONGINT; tags{9} : u.TagListPtr ):m.Object;
    BEGIN (* SaveReg+ *)
      RETURN Scrollbar( min, max, level, m.aControlChar, key, u.more, tags );
    END KeyScrollbarA;

  PROCEDURE VScrollbar * {"MuiSimple.VScrollbarA"} ( min{0}, max{1}, level{2} : LONGINT; tags{9}.. : u.Tag ):m.Object;
  PROCEDURE VScrollbarA * ( min{0}, max{1}, level{2} : LONGINT; tags{9} : u.TagListPtr ):m.Object;
    BEGIN (* SaveReg+ *)
      RETURN ScrollbarObject( m.aSliderMin, min,
			      m.aSliderMax, max,
			      m.aSliderLevel, level,
			      u.more, tags );
    END VScrollbarA;

  PROCEDURE KeyVScrollbar * {"MuiSimple.KeyVScrollbarA"} ( min{0}, max{1}, level{2} : LONGINT; key{3} : CHAR; tags{9}.. : u.Tag ):m.Object;
  PROCEDURE KeyVScrollbarA * ( min{0}, max{1}, level{2}, key{3} : LONGINT; tags{9} : u.TagListPtr ):m.Object;
    BEGIN (* SaveReg+ *)
      RETURN VScrollbar( min, max, level, m.aControlChar, key, u.more, tags );
    END KeyVScrollbarA;

(***************************************************************************
**
** Button to be used for popup objects
**
***************************************************************************)

  PROCEDURE PopButton* {"MuiSimple.PopButtonA"} ( img{3} : LONGINT ):m.Object;
  PROCEDURE PopButtonA*( img{3} : LONGINT ):m.Object;
    BEGIN (* SaveReg+ *)
      RETURN m.MakeObject( m.oPopButton, img );
    END PopButtonA;

(***************************************************************************
**
** Labeling Objects
** ----------------
**
** Labeling objects, e.g. a group of string gadgets,
**
**   Small: |foo   |
**  Normal: |bar   |
**     Big: |foobar|
**    Huge: |barfoo|
**
** is done using a 2 column group:
**
** ColGroup(2);
**      Child; Label2( "Small:"  );
**    Child; StringObject; end;
**      Child; Label2( "Normal:" );
**    Child; StringObject; end;
**      Child; Label2( "Big:"    );
**    Child; StringObject; end;
**      Child; Label2( "Huge:"   );
**    Child; StringObject; end;
**    end;
**
** Note that we have three versions of the label procedure, depending on
** the frame type of the right hand object:
**
** Label1(): For use with standard frames (e.g. checkmarks).
** Label2(): For use with double high frames (e.g. string gadgets).
** Label() : For use with objects without a frame.
**
** These procedures ensure that your label will look fine even if the
** user of your application configured some strange spacing values.
** If you want to use your own labeling, you'll have to pay attention
** on this topic yourself.
**
***************************************************************************)

  PROCEDURE Label* {"MuiSimple.LabelA"} ( label {8} : ARRAY OF CHAR ):m.Object;
  PROCEDURE LabelA * ( label{8} : e.LSTRPTR ):m.Object;
    BEGIN (* SaveReg+ *)
      RETURN m.MakeObject( m.oLabel, label, 0 );
    END LabelA;

  PROCEDURE Label1* {"MuiSimple.Label1A"} ( label {8} : ARRAY OF CHAR ):m.Object;
  PROCEDURE Label1A * ( label{8} : e.LSTRPTR ):m.Object;
    BEGIN (* SaveReg+ *)
      RETURN m.MakeObject( m.oLabel, label, m.oLabelSingleFrame );
    END Label1A;

  PROCEDURE Label2* {"MuiSimple.Label2A"} ( label {8} : ARRAY OF CHAR):m.Object;
  PROCEDURE Label2A * ( label{8} : e.LSTRPTR ):m.Object;
    BEGIN (* SaveReg+ *)
      RETURN m.MakeObject( m.oLabel, label, m.oLabelDoubleFrame );
    END Label2A;

  PROCEDURE LLabel* {"MuiSimple.LLabelA"} ( label {8} : ARRAY OF CHAR ):m.Object;
  PROCEDURE LLabelA * ( label{8} : e.LSTRPTR ):m.Object;
    BEGIN (* SaveReg+ *)
      RETURN m.MakeObject( m.oLabel, label, m.oLabelLeftAligned );
    END LLabelA;

  PROCEDURE LLabel1* {"MuiSimple.LLabel1A"} ( label {8} : ARRAY OF CHAR ):m.Object;
  PROCEDURE LLabel1A * ( label{8} : e.LSTRPTR ):m.Object;
    BEGIN (* SaveReg+ *)
      RETURN m.MakeObject( m.oLabel, label, m.oLabelSingleFrame+m.oLabelLeftAligned );
    END LLabel1A;

  PROCEDURE LLabel2* {"MuiSimple.LLabel2A"} ( label {8} : ARRAY OF CHAR ):m.Object;
  PROCEDURE LLabel2A * ( label{8} : e.LSTRPTR ):m.Object;
    BEGIN (* SaveReg+ *)
      RETURN m.MakeObject( m.oLabel, label, m.oLabelDoubleFrame+m.oLabelLeftAligned );
    END LLabel2A;

  PROCEDURE CLabel* {"MuiSimple.CLabelA"} ( label {8} : ARRAY OF CHAR ):m.Object;
  PROCEDURE CLabelA * ( label{8} : e.LSTRPTR ):m.Object;
    BEGIN (* SaveReg+ *)
      RETURN m.MakeObject( m.oLabel, label, m.oLabelCentered );
    END CLabelA;

  PROCEDURE CLabel1* {"MuiSimple.CLabel1A"} ( label {8} : ARRAY OF CHAR ):m.Object;
  PROCEDURE CLabel1A * ( label{8} : e.LSTRPTR ):m.Object;
    BEGIN (* SaveReg+ *)
      RETURN m.MakeObject( m.oLabel, label, m.oLabelCentered+m.oLabelSingleFrame );
    END CLabel1A;

  PROCEDURE CLabel2* {"MuiSimple.CLabel2A"} ( label {8} : ARRAY OF CHAR):m.Object;
  PROCEDURE CLabel2A * ( label{8} : e.LSTRPTR ):m.Object;
    BEGIN (* SaveReg+ *)
      RETURN m.MakeObject( m.oLabel, label, m.oLabelCentered+m.oLabelDoubleFrame );
    END CLabel2A;

  PROCEDURE KeyLabel*{"MuiSimple.KeyLabelA"} ( label{8} : ARRAY OF CHAR; hichar{3} : CHAR ):m.Object;
  PROCEDURE KeyLabelA * ( label{8} : e.LSTRPTR; hichar{3} : LONGINT  ):m.Object;
    BEGIN (* SaveReg+ *)
      RETURN m.MakeObject( m.oLabel, label, 0+hichar );
    END KeyLabelA;

  PROCEDURE KeyLabel1*{"MuiSimple.KeyLabel1A"} ( label{8} : ARRAY OF CHAR; hichar{3} : CHAR ):m.Object;
  PROCEDURE KeyLabel1A * ( label{8} : e.LSTRPTR; hichar{3} : LONGINT ):m.Object;
    BEGIN (* SaveReg+ *)
      RETURN m.MakeObject( m.oLabel, label, m.oLabelSingleFrame+hichar );
    END KeyLabel1A;

  PROCEDURE KeyLabel2*{"MuiSimple.KeyLabel2A"} ( label{8} : ARRAY OF CHAR; hichar{3} : CHAR ):m.Object;
  PROCEDURE KeyLabel2A * ( label{8} : e.LSTRPTR; hichar{3} : LONGINT ):m.Object;
    BEGIN (* SaveReg+ *)
      RETURN m.MakeObject( m.oLabel, label, m.oLabelDoubleFrame+m.oLabelLeftAligned+hichar );
    END KeyLabel2A;

  PROCEDURE KeyLLabel*{"MuiSimple.KeyLLabelA"} ( label{8} : ARRAY OF CHAR; hichar{3} : CHAR):m.Object;
  PROCEDURE KeyLLabelA * ( label{8} : e.LSTRPTR; hichar{3} : LONGINT ):m.Object;
    BEGIN (* SaveReg+ *)
      RETURN m.MakeObject( m.oLabel, label, 0+hichar );
    END KeyLLabelA;

  PROCEDURE KeyLLabel1*{"MuiSimple.KeyLLabel1A"} ( label{8} : ARRAY OF CHAR; hichar{3} : CHAR ):m.Object;
  PROCEDURE KeyLLabel1A * ( label{8} : e.LSTRPTR; hichar{3} : LONGINT ):m.Object;
    BEGIN (* SaveReg+ *)
      RETURN m.MakeObject( m.oLabel, label, m.oLabelSingleFrame+m.oLabelLeftAligned+hichar );
    END KeyLLabel1A;

  PROCEDURE KeyLLabel2*{"MuiSimple.KeyLLabel2A"} ( label{8} : ARRAY OF CHAR; hichar{3} : CHAR ):m.Object;
  PROCEDURE KeyLLabel2A * ( label{8} : e.LSTRPTR; hichar{3} : LONGINT ):m.Object;
    BEGIN (* SaveReg+ *)
      RETURN m.MakeObject( m.oLabel, label, m.oLabelDoubleFrame+m.oLabelLeftAligned+hichar );
    END KeyLLabel2A;

  PROCEDURE KeyCLabel*{"MuiSimple.KeyCLabelA"} ( label{8} : ARRAY OF CHAR; hichar{3} : CHAR ):m.Object;
  PROCEDURE KeyCLabelA * ( label{8} : e.LSTRPTR; hichar{3} : LONGINT  ):m.Object;
    BEGIN (* SaveReg+ *)
      RETURN m.MakeObject( m.oLabel, label, m.oLabelCentered+hichar );
    END KeyCLabelA;

  PROCEDURE KeyCLabel1*{"MuiSimple.KeyCLabel1A"} ( label{8} : ARRAY OF CHAR; hichar{3} : CHAR ):m.Object;
  PROCEDURE KeyCLabel1A * ( label{8} : e.LSTRPTR; hichar{3} : LONGINT ):m.Object;
    BEGIN (* SaveReg+ *)
      RETURN m.MakeObject( m.oLabel, label, m.oLabelCentered+m.oLabelSingleFrame+hichar );
    END KeyCLabel1A;

  PROCEDURE KeyCLabel2*{"MuiSimple.KeyCLabel2A"} ( label{8} : ARRAY OF CHAR; hichar{3} : CHAR ):m.Object;
  PROCEDURE KeyCLabel2A * ( label{8} : e.LSTRPTR; hichar{3} : LONGINT ):m.Object;
    BEGIN (* SaveReg+ *)
      RETURN m.MakeObject( m.oLabel, label, m.oLabelCentered+m.oLabelDoubleFrame+m.oLabelLeftAligned+hichar );
    END KeyCLabel2A;


  PROCEDURE FreeLabel* {"MuiSimple.FreeLabelA"} ( label {8} : ARRAY OF CHAR ):m.Object;
  PROCEDURE FreeLabelA * ( label{8} : e.LSTRPTR ):m.Object;
    BEGIN (* SaveReg+ *)
      RETURN m.MakeObject( m.oLabel, label, m.oLabelFreeVert+0 );
    END FreeLabelA;

  PROCEDURE FreeLabel1* {"MuiSimple.FreeLabel1A"} ( label {8} : ARRAY OF CHAR ):m.Object;
  PROCEDURE FreeLabel1A * ( label{8} : e.LSTRPTR ):m.Object;
    BEGIN (* SaveReg+ *)
      RETURN m.MakeObject( m.oLabel, label, m.oLabelFreeVert+m.oLabelSingleFrame );
    END FreeLabel1A;

  PROCEDURE FreeLabel2* {"MuiSimple.FreeLabel2A"} ( label {8} : ARRAY OF CHAR):m.Object;
  PROCEDURE FreeLabel2A * ( label{8} : e.LSTRPTR ):m.Object;
    BEGIN (* SaveReg+ *)
      RETURN m.MakeObject( m.oLabel, label, m.oLabelFreeVert+m.oLabelDoubleFrame );
    END FreeLabel2A;

  PROCEDURE FreeLLabel* {"MuiSimple.FreeLLabelA"} ( label {8} : ARRAY OF CHAR ):m.Object;
  PROCEDURE FreeLLabelA * ( label{8} : e.LSTRPTR ):m.Object;
    BEGIN (* SaveReg+ *)
      RETURN m.MakeObject( m.oLabel, label, m.oLabelFreeVert+m.oLabelLeftAligned );
    END FreeLLabelA;

  PROCEDURE FreeLLabel1* {"MuiSimple.FreeLLabel1A"} ( label {8} : ARRAY OF CHAR ):m.Object;
  PROCEDURE FreeLLabel1A * ( label{8} : e.LSTRPTR ):m.Object;
    BEGIN (* SaveReg+ *)
      RETURN m.MakeObject( m.oLabel, label, m.oLabelFreeVert+m.oLabelSingleFrame+m.oLabelLeftAligned );
    END FreeLLabel1A;

  PROCEDURE FreeLLabel2* {"MuiSimple.FreeLLabel2A"} ( label {8} : ARRAY OF CHAR ):m.Object;
  PROCEDURE FreeLLabel2A * ( label{8} : e.LSTRPTR ):m.Object;
    BEGIN (* SaveReg+ *)
      RETURN m.MakeObject( m.oLabel, label, m.oLabelFreeVert+m.oLabelDoubleFrame+m.oLabelLeftAligned );
    END FreeLLabel2A;

  PROCEDURE FreeCLabel* {"MuiSimple.FreeCLabelA"} ( label {8} : ARRAY OF CHAR ):m.Object;
  PROCEDURE FreeCLabelA * ( label{8} : e.LSTRPTR ):m.Object;
    BEGIN (* SaveReg+ *)
      RETURN m.MakeObject( m.oLabel, label, m.oLabelFreeVert+m.oLabelCentered );
    END FreeCLabelA;

  PROCEDURE FreeCLabel1* {"MuiSimple.FreeCLabel1A"} ( label {8} : ARRAY OF CHAR ):m.Object;
  PROCEDURE FreeCLabel1A * ( label{8} : e.LSTRPTR ):m.Object;
    BEGIN (* SaveReg+ *)
      RETURN m.MakeObject( m.oLabel, label, m.oLabelFreeVert+m.oLabelCentered+m.oLabelSingleFrame );
    END FreeCLabel1A;

  PROCEDURE FreeCLabel2* {"MuiSimple.FreeCLabel2A"} ( label {8} : ARRAY OF CHAR):m.Object;
  PROCEDURE FreeCLabel2A * ( label{8} : e.LSTRPTR ):m.Object;
    BEGIN (* SaveReg+ *)
      RETURN m.MakeObject( m.oLabel, label, m.oLabelFreeVert+m.oLabelCentered+m.oLabelDoubleFrame );
    END FreeCLabel2A;

  PROCEDURE FreeKeyLabel*{"MuiSimple.FreeKeyLabelA"} ( label{8} : ARRAY OF CHAR; hichar{3} : CHAR ):m.Object;
  PROCEDURE FreeKeyLabelA * ( label{8} : e.LSTRPTR; hichar{3} : LONGINT  ):m.Object;
    BEGIN (* SaveReg+ *)
      RETURN m.MakeObject( m.oLabel, label, m.oLabelFreeVert+0+hichar );
    END FreeKeyLabelA;

  PROCEDURE FreeKeyLabel1*{"MuiSimple.FreeKeyLabel1A"} ( label{8} : ARRAY OF CHAR; hichar{3} : CHAR ):m.Object;
  PROCEDURE FreeKeyLabel1A * ( label{8} : e.LSTRPTR; hichar{3} : LONGINT ):m.Object;
    BEGIN (* SaveReg+ *)
      RETURN m.MakeObject( m.oLabel, label, m.oLabelFreeVert+m.oLabelSingleFrame+hichar );
    END FreeKeyLabel1A;

  PROCEDURE FreeKeyLabel2*{"MuiSimple.FreeKeyLabel2A"} ( label{8} : ARRAY OF CHAR; hichar{3} : CHAR ):m.Object;
  PROCEDURE FreeKeyLabel2A * ( label{8} : e.LSTRPTR; hichar{3} : LONGINT ):m.Object;
    BEGIN (* SaveReg+ *)
      RETURN m.MakeObject( m.oLabel, label, m.oLabelFreeVert+m.oLabelDoubleFrame+m.oLabelLeftAligned+hichar );
    END FreeKeyLabel2A;

  PROCEDURE FreeKeyLLabel*{"MuiSimple.FreeKeyLLabelA"} ( label{8} : ARRAY OF CHAR; hichar{3} : CHAR):m.Object;
  PROCEDURE FreeKeyLLabelA * ( label{8} : e.LSTRPTR; hichar{3} : LONGINT ):m.Object;
    BEGIN (* SaveReg+ *)
      RETURN m.MakeObject( m.oLabel, label, m.oLabelFreeVert+0+hichar );
    END FreeKeyLLabelA;

  PROCEDURE FreeKeyLLabel1*{"MuiSimple.FreeKeyLLabel1A"} ( label{8} : ARRAY OF CHAR; hichar{3} : CHAR ):m.Object;
  PROCEDURE FreeKeyLLabel1A * ( label{8} : e.LSTRPTR; hichar{3} : LONGINT ):m.Object;
    BEGIN (* SaveReg+ *)
      RETURN m.MakeObject( m.oLabel, label, m.oLabelFreeVert+m.oLabelSingleFrame+m.oLabelLeftAligned+hichar );
    END FreeKeyLLabel1A;

  PROCEDURE FreeKeyLLabel2*{"MuiSimple.FreeKeyLLabel2A"} ( label{8} : ARRAY OF CHAR; hichar{3} : CHAR ):m.Object;
  PROCEDURE FreeKeyLLabel2A * ( label{8} : e.LSTRPTR; hichar{3} : LONGINT ):m.Object;
    BEGIN (* SaveReg+ *)
      RETURN m.MakeObject( m.oLabel, label, m.oLabelFreeVert+m.oLabelDoubleFrame+m.oLabelLeftAligned+hichar );
    END FreeKeyLLabel2A;

  PROCEDURE FreeKeyCLabel*{"MuiSimple.FreeKeyCLabelA"} ( label{8} : ARRAY OF CHAR; hichar{3} : CHAR ):m.Object;
  PROCEDURE FreeKeyCLabelA * ( label{8} : e.LSTRPTR; hichar{3} : LONGINT  ):m.Object;
    BEGIN (* SaveReg+ *)
      RETURN m.MakeObject( m.oLabel, label, m.oLabelFreeVert+m.oLabelCentered+hichar );
    END FreeKeyCLabelA;

  PROCEDURE FreeKeyCLabel1*{"MuiSimple.FreeKeyCLabel1A"} ( label{8} : ARRAY OF CHAR; hichar{3} : CHAR ):m.Object;
  PROCEDURE FreeKeyCLabel1A * ( label{8} : e.LSTRPTR; hichar{3} : LONGINT ):m.Object;
    BEGIN (* SaveReg+ *)
      RETURN m.MakeObject( m.oLabel, label, m.oLabelFreeVert+m.oLabelCentered+m.oLabelSingleFrame+hichar );
    END FreeKeyCLabel1A;

  PROCEDURE FreeKeyCLabel2*{"MuiSimple.FreeKeyCLabel2A"} ( label{8} : ARRAY OF CHAR; hichar{3} : CHAR ):m.Object;
  PROCEDURE FreeKeyCLabel2A * ( label{8} : e.LSTRPTR; hichar{3} : LONGINT ):m.Object;
    BEGIN (* SaveReg+ *)
      RETURN m.MakeObject( m.oLabel, label, m.oLabelFreeVert+m.oLabelCentered+m.oLabelDoubleFrame+m.oLabelLeftAligned+hichar );
    END FreeKeyCLabel2A;


(***************************************************************************
**
** Controlling Objects
** -------------------
**
** Set() and Get() are two short stubs for BOOPSI GetAttr() and SetAttrs()
** calls:
**
**
**    VAR x : e.LSTRPTR;
**
**    Set(obj,MUIA_String_Contents, y.ADR("foobar") );
**    Get(obj,MUIA_String_Contents, x);
**
**    Dos.PrintF( "gadget contains '%s'\n" , x );
**
** NNset() sets an attribute without triggering a possible notification.
**
**
***************************************************************************)

  PROCEDURE Set*( obj : m.Object; attr, value : e.APTR );
    BEGIN (* SaveReg+ *)
      IF I.SetAttrs( obj, attr, value, u.end ) = 0 THEN END
    END Set;

  PROCEDURE Get*( obj : m.Object; attr : LONGINT ; VAR store : ARRAY OF e.BYTE );
    BEGIN (* SaveReg+ *)
      IF I.GetAttr( attr, obj, store) = 0 THEN END
    END Get;

  PROCEDURE NNSet( obj : m.Object; attr, value : e.APTR );
    BEGIN (* SaveReg+ *)
      IF I.SetAttrs( obj, m.aNoNotify, e.LTRUE, attr, value, u.end ) = 0 THEN END
    END NNSet;

  PROCEDURE SetMutex * ( obj : m.Object; n : LONGINT );
    BEGIN (* SaveReg+ *)
      Set( obj, m.aRadioActive, n );
    END SetMutex;

  PROCEDURE SetCycle * ( obj : m.Object; n : LONGINT );
    BEGIN (* SaveReg+ *)
      Set( obj, m.aCycleActive, n );
    END SetCycle;

  PROCEDURE SetString * ( obj : m.Object; s : ARRAY OF CHAR );
    BEGIN (* SaveReg+ *)
      Set( obj, m.aStringContents, y.ADR( s ) );
    END SetString;

  PROCEDURE SetCheckmark * ( obj : m.Object; b : BOOLEAN );
    BEGIN (* SaveReg+ *)
      Set( obj, m.aSelected, y.VAL(SHORTINT,b) );
    END SetCheckmark;

  PROCEDURE SetSlider * ( obj : m.Object; l : LONGINT );
    BEGIN (* SaveReg+ *)
      Set( obj, m.aSliderLevel, l );
    END SetSlider;

  PROCEDURE MAKEID*( c1, c2, c3, c4 : CHAR):LONGINT;
    BEGIN (* SaveReg+ *)
      RETURN( y.LSH( ORD(c1), 24 )+
	      y.LSH( ORD(c2), 16 )+
	      y.LSH( ORD(c3),  8 )+
	      ORD(c4) )
    END MAKEID;

BEGIN
  IF m.base.version < 8 THEN HALT( 100 ) END;
END MuiSimple.