home *** CD-ROM | disk | FTP | other *** search
/ Megahits 4 / MegaHits_Vol.4.iso / mui / dev / gui / m2mui2_0.lha / txt / MuiMacros.mod < prev    next >
Text File  |  1994-02-19  |  32KB  |  978 lines
  1. IMPLEMENTATION MODULE MuiMacros;
  2.  
  3. (*$ NilChk      := FALSE *)
  4. (*$ EntryClear  := FALSE *)
  5. (*$ LargeVars   := FALSE *)
  6. (*$ StackParms  := FALSE *)
  7. (*$ DEFINE Locale :=FALSE *)
  8.  
  9.  
  10. (****************************************************************************
  11. **
  12. **      MUI Macros 2.0
  13. **
  14. **      Converted to Modula by Christian "Kochtopf" Scholz
  15. **
  16. **      $Id: MuiMacros.mod,v 1.5 1994/02/15 21:14:05 Kochtopf Exp $
  17. **
  18. **      $Log: MuiMacros.mod,v $
  19. # Revision 1.5  1994/02/15  21:14:05  Kochtopf
  20. # neue Macros fuer Pop* und Register definiert,
  21. # HCenter und VCenter neu
  22. # PopUp entfernt und durch PopButton ersetzt.
  23. # neue Label-Macros LLabel eingefuehrt (aus mui.h)
  24. #
  25. # Revision 1.4  1994/02/09  14:50:03  Kochtopf
  26. # Versionsnummer in 2.0 geaendert.
  27. #
  28. **
  29. ****************************************************************************)
  30.  
  31. IMPORT  MD:MuiD;
  32. IMPORT  ML:MuiL;
  33. IMPORT  UD:UtilityD;
  34. IMPORT  R;
  35. FROM    MuiSupport IMPORT DoMethod;
  36. FROM    UtilityD IMPORT tagEnd, tagMore, HookPtr, Hook;
  37. FROM    SYSTEM IMPORT ADDRESS, ADR, TAG, CAST, SETREG, REG;
  38. FROM    IntuitionL IMPORT SetAttrsA, GetAttr;
  39. FROM    IntuitionD IMPORT omGET, omADDMEMBER, omREMMEMBER;
  40. FROM    Storage IMPORT ALLOCATE;
  41.  
  42. VAR buffer  : ARRAY [0..50] OF LONGINT;      (* for the tags *)
  43.  
  44. (*{{{  "MUI-Object-Generation" *)
  45. (*
  46. **
  47. **  MUI - Object Generation
  48. **
  49. *)
  50.  
  51. PROCEDURE WindowObject(tags : UD.TagItemPtr) : APTR;
  52.     BEGIN
  53.         RETURN ML.mNewObject(ADR(MD.mcWindow), tags);
  54.     END WindowObject;
  55.  
  56. PROCEDURE ImageObject(tags : UD.TagItemPtr) : APTR;
  57.     BEGIN
  58.         RETURN ML.mNewObject(ADR(MD.mcImage), tags);
  59.     END ImageObject;
  60.  
  61. PROCEDURE ApplicationObject(tags : UD.TagItemPtr) : APTR;
  62.     BEGIN
  63.         RETURN ML.mNewObject(ADR(MD.mcApplication), tags);
  64.     END ApplicationObject;
  65.  
  66. PROCEDURE NotifyObject(tags : UD.TagItemPtr) : APTR;
  67.     BEGIN
  68.         RETURN ML.mNewObject(ADR(MD.mcNotify), tags);
  69.     END NotifyObject;
  70.  
  71. PROCEDURE TextObject(tags : UD.TagItemPtr) : APTR;
  72.     BEGIN
  73.         RETURN ML.mNewObject(ADR(MD.mcText), tags);
  74.     END TextObject;
  75.  
  76. PROCEDURE RectangleObject(tags : UD.TagItemPtr) : APTR;
  77.     BEGIN
  78.         RETURN ML.mNewObject(ADR(MD.mcRectangle), tags);
  79.     END RectangleObject;
  80.  
  81. PROCEDURE ListObject(tags : UD.TagItemPtr) : APTR;
  82.     BEGIN
  83.         RETURN ML.mNewObject(ADR(MD.mcList), tags);
  84.     END ListObject;
  85.  
  86. PROCEDURE PropObject(tags : UD.TagItemPtr) : APTR;
  87.     BEGIN
  88.         RETURN ML.mNewObject(ADR(MD.mcProp), tags);
  89.     END PropObject;
  90.  
  91. PROCEDURE StringObject(tags : UD.TagItemPtr) : APTR;
  92.     BEGIN
  93.         RETURN ML.mNewObject(ADR(MD.mcString), tags);
  94.     END StringObject;
  95.  
  96. PROCEDURE ScrollbarObject(tags : UD.TagItemPtr) : APTR;
  97.     BEGIN
  98.         RETURN ML.mNewObject(ADR(MD.mcScrollbar), tags);
  99.     END ScrollbarObject;
  100.  
  101. PROCEDURE ListviewObject(tags : UD.TagItemPtr) : APTR;
  102.     BEGIN
  103.         RETURN ML.mNewObject(ADR(MD.mcListview), tags);
  104.     END ListviewObject;
  105.  
  106. PROCEDURE RadioObject(tags : UD.TagItemPtr) : APTR;
  107.     BEGIN
  108.         RETURN ML.mNewObject(ADR(MD.mcRadio), tags);
  109.     END RadioObject;
  110.  
  111. PROCEDURE VolumelistObject(tags : UD.TagItemPtr) : APTR;
  112.     BEGIN
  113.         RETURN ML.mNewObject(ADR(MD.mcVolumelist), tags);
  114.     END VolumelistObject;
  115.  
  116. PROCEDURE FloattextObject(tags : UD.TagItemPtr) : APTR;
  117.     BEGIN
  118.         RETURN ML.mNewObject(ADR(MD.mcFloattext), tags);
  119.     END FloattextObject;
  120.  
  121. PROCEDURE DirlistObject(tags : UD.TagItemPtr) : APTR;
  122.     BEGIN
  123.         RETURN ML.mNewObject(ADR(MD.mcDirlist), tags);
  124.     END DirlistObject;
  125.  
  126. PROCEDURE ScrmodelistObject(tags : UD.TagItemPtr) : APTR;
  127.     BEGIN
  128.         RETURN ML.mNewObject(ADR(MD.mcScrmodelist), tags);
  129.     END ScrmodelistObject;
  130.  
  131. PROCEDURE SliderObject(tags : UD.TagItemPtr) : APTR;
  132.     BEGIN
  133.         RETURN ML.mNewObject(ADR(MD.mcSlider), tags);
  134.     END SliderObject;
  135.  
  136. PROCEDURE CycleObject(tags : UD.TagItemPtr) : APTR;
  137.     BEGIN
  138.         RETURN ML.mNewObject(ADR(MD.mcCycle), tags);
  139.     END CycleObject;
  140.  
  141. PROCEDURE GaugeObject(tags : UD.TagItemPtr) : APTR;
  142.     BEGIN
  143.         RETURN ML.mNewObject(ADR(MD.mcGauge), tags);
  144.     END GaugeObject;
  145.  
  146. PROCEDURE BoopsiObject(tags : UD.TagItemPtr) : APTR;
  147.     BEGIN
  148.         RETURN ML.mNewObject(ADR(MD.mcBoopsi), tags);
  149.     END BoopsiObject;
  150.  
  151. PROCEDURE ScaleObject(tags : UD.TagItemPtr) : APTR;
  152.     BEGIN
  153.         RETURN ML.mNewObject(ADR(MD.mcScale), tags);
  154.     END ScaleObject;
  155.  
  156. PROCEDURE GroupObject(tags : UD.TagItemPtr) : APTR;
  157.     BEGIN
  158.         RETURN ML.mNewObject(ADR(MD.mcGroup), tags);
  159.     END GroupObject;
  160.  
  161. PROCEDURE VGroup(tags : UD.TagItemPtr) : APTR;
  162.     BEGIN
  163.         RETURN ML.mNewObject(ADR(MD.mcGroup), tags);
  164.     END VGroup;
  165.  
  166. PROCEDURE HGroup(tags : UD.TagItemPtr) : APTR;
  167.     BEGIN
  168.         RETURN ML.mNewObject(ADR(MD.mcGroup), TAG(buffer, MD.maGroupHoriz, TRUE, tagMore, tags, tagEnd));
  169.     END HGroup;
  170.  
  171. PROCEDURE ColGroup(cols : LONGCARD; tags : UD.TagItemPtr) : APTR;
  172.     BEGIN
  173.         RETURN ML.mNewObject(ADR(MD.mcGroup), TAG(buffer, MD.maGroupColumns, cols, tagMore, tags, tagEnd));
  174.     END ColGroup;
  175.  
  176. PROCEDURE RowGroup(rows : LONGCARD; tags : UD.TagItemPtr) : APTR;
  177.     BEGIN
  178.         RETURN ML.mNewObject(ADR(MD.mcGroup), TAG(buffer, MD.maGroupRows, rows, tagMore, tags, tagEnd));
  179.     END RowGroup;
  180.  
  181. PROCEDURE PageGroup(tags : UD.TagItemPtr) : APTR;
  182.     BEGIN
  183.          RETURN ML.mNewObject(ADR(MD.mcGroup),TAG(buffer, MD.maGroupPageMode, TRUE, tagMore, tags, tagEnd));
  184.     END PageGroup;
  185.  
  186. PROCEDURE ColorfieldObject(tags : UD.TagItemPtr) : APTR;
  187.     BEGIN
  188.          RETURN ML.mNewObject(ADR(MD.mcColorfield), tags);
  189.     END ColorfieldObject;
  190.  
  191. PROCEDURE ColoradjustObject(tags : UD.TagItemPtr) : APTR;
  192.     BEGIN
  193.          RETURN ML.mNewObject(ADR(MD.mcColoradjust), tags);
  194.     END ColoradjustObject;
  195.  
  196. PROCEDURE PaletteObject(tags : UD.TagItemPtr) : APTR;
  197.     BEGIN
  198.          RETURN ML.mNewObject(ADR(MD.mcPalette), tags);
  199.     END PaletteObject;
  200.  
  201. PROCEDURE VirtgroupObject(tags : UD.TagItemPtr) : APTR;
  202.     BEGIN
  203.          RETURN ML.mNewObject(ADR(MD.mcVirtgroup), tags);
  204.     END VirtgroupObject;
  205.  
  206. PROCEDURE ScrollgroupObject(tags : UD.TagItemPtr) : APTR;
  207.     BEGIN
  208.          RETURN ML.mNewObject(ADR(MD.mcScrollgroup), tags);
  209.     END ScrollgroupObject;
  210.  
  211. PROCEDURE VGroupV(tags : UD.TagItemPtr) : APTR;
  212.     BEGIN
  213.          RETURN ML.mNewObject(ADR(MD.mcVirtgroup), tags);
  214.     END VGroupV;
  215.  
  216. PROCEDURE HGroupV(tags : UD.TagItemPtr) : APTR;
  217.     BEGIN
  218.         RETURN ML.mNewObject(ADR(MD.mcVirtgroup), TAG(buffer, MD.maGroupHoriz, TRUE, tagMore, tags, tagEnd));
  219.     END HGroupV;
  220.  
  221. PROCEDURE ColGroupV(cols : LONGCARD; tags : UD.TagItemPtr) : APTR;
  222.     BEGIN
  223.         RETURN ML.mNewObject(ADR(MD.mcVirtgroup), TAG(buffer, MD.maGroupColumns, cols, tagMore, tags, tagEnd));
  224.     END ColGroupV;
  225.  
  226. PROCEDURE RowGroupV(rows : LONGCARD; tags : UD.TagItemPtr) : APTR;
  227.     BEGIN
  228.         RETURN ML.mNewObject(ADR(MD.mcVirtgroup), TAG(buffer, MD.maGroupRows, rows, tagMore, tags, tagEnd));
  229.     END RowGroupV;
  230.  
  231. PROCEDURE PageGroupV(tags : UD.TagItemPtr) : APTR;
  232.     BEGIN
  233.          RETURN ML.mNewObject(ADR(MD.mcVirtgroup),TAG(buffer, MD.maGroupPageMode, TRUE, tagMore, tags, tagEnd));
  234.     END PageGroupV;
  235.  
  236. PROCEDURE PopString(tags : UD.TagItemPtr) : APTR;
  237.     BEGIN
  238.          RETURN ML.mNewObject(ADR(MD.mcPopstring), tags);
  239.     END PopString;
  240.  
  241. PROCEDURE PopObject(tags : UD.TagItemPtr) : APTR;
  242.     BEGIN
  243.          RETURN ML.mNewObject(ADR(MD.mcPopobject), tags);
  244.     END PopObject;
  245.  
  246. PROCEDURE PopAsl(tags : UD.TagItemPtr) : APTR;
  247.     BEGIN
  248.          RETURN ML.mNewObject(ADR(MD.mcPopasl), tags);
  249.     END PopAsl;
  250.  
  251. PROCEDURE Register(tags : UD.TagItemPtr) : APTR;
  252.     BEGIN
  253.          RETURN ML.mNewObject(ADR(MD.mcRegister), tags);
  254.     END Register;
  255.  
  256. (*}}}*)
  257. (*{{{  "MakeID" *)
  258. (*
  259. **  MakeID
  260. **  Generate an ID out of a 4-char-string.
  261. **  Use it the as WindowID ! (look in MuiTest for an example!)
  262. *)
  263.  
  264. PROCEDURE MakeID (name : ShortString): LONGINT;
  265.  
  266.     BEGIN
  267.         RETURN ORD(name[0])+
  268.                ORD(name[1])*256+
  269.                ORD(name[2])*65536+
  270.                ORD(name[3])*16777216;
  271.     END MakeID;
  272. (*}}}*)
  273. (*{{{  "Hook-Support" *)
  274. (*
  275. **  Hook-Support functions
  276. **  1. the dispatcher
  277. **  2. the MakeHook-Function
  278. **
  279. *)
  280.  
  281. PROCEDURE HookEntry(hook{R.A0}  : HookPtr;
  282.                     object{R.A2}: ADDRESS;
  283.                     args{R.A1}  : ADDRESS)     : ADDRESS;
  284.     (*$SaveA4:=TRUE*)
  285.     BEGIN
  286.         SETREG (R.A4, hook^.data);
  287.         RETURN CAST(HookDef,hook^.subEntry)(hook, object, args);
  288.     END HookEntry;
  289.  
  290. PROCEDURE MakeHook(entry:HookDef; VAR hook : HookPtr);
  291.  
  292.     BEGIN
  293.             ALLOCATE(hook,SIZE(Hook));
  294.             hook^.node.succ  := NIL;
  295.             hook^.node.pred  := NIL;
  296.             hook^.entry      := HookEntry;
  297.             hook^.subEntry   := CAST(ADDRESS,entry);
  298.             hook^.data       := REG(R.A4);
  299.     END MakeHook;
  300. (*}}}*)
  301. (*{{{  "Spacing-Macros" *)
  302. (*
  303. **
  304. **  Spacing Macros
  305. **
  306. *)
  307. (*{{{  "HV-Space" *)
  308. PROCEDURE HVSpace() : APTR;
  309.     BEGIN
  310.         RETURN ML.mNewObject(ADR(MD.mcRectangle), NIL);
  311.     END HVSpace;
  312. (*}}}*)
  313. (*{{{  "Hspace" *)
  314. PROCEDURE HSpace(x : LONGCARD) : APTR;
  315.     BEGIN
  316.         IF x#0 THEN 
  317.                 RETURN ML.mNewObject(ADR(MD.mcRectangle),
  318.                                      TAG(buffer,
  319.                                         MD.maFixWidth,     x,
  320.                                         MD.maVertWeight,   0,
  321.                                         tagEnd));
  322.                 ELSE   
  323.                 RETURN ML.mNewObject(ADR(MD.mcRectangle),
  324.                                      TAG(buffer,
  325.                                         MD.maVertWeight,   0,
  326.                                         tagEnd));
  327.                 END;
  328.     END HSpace;
  329. (*}}}*)
  330. (*{{{  "VSpace" *)
  331. PROCEDURE VSpace(x : LONGCARD) : APTR;
  332.     BEGIN
  333.         IF x#0 THEN 
  334.                 RETURN ML.mNewObject(ADR(MD.mcRectangle),
  335.                                      TAG(buffer,
  336.                                         MD.maFixHeight,     x,
  337.                                         MD.maHorizWeight,   0,
  338.                                         tagEnd));
  339.                 ELSE
  340.                 RETURN ML.mNewObject(ADR(MD.mcRectangle),
  341.                                      TAG(buffer,
  342.                                         MD.maHorizWeight,   0,
  343.                                         tagEnd));
  344.                 END;
  345.     END VSpace;
  346. (*}}}*)
  347. (*{{{  "HCenter" *)
  348. PROCEDURE HCenter(obj : APTR) : APTR;
  349.     BEGIN
  350.         RETURN HGroup(TAG(buffer,
  351.                     MD.maGroupSpacing,      0,
  352.                     Child,                  HSpace(0),
  353.                     Child,                  obj,
  354.                     Child,                  HSpace(0),
  355.                     tagEnd));
  356.     END HCenter;
  357. (*}}}*)
  358. (*{{{  "VCenter" *)
  359. PROCEDURE VCenter(obj : APTR) : APTR;
  360.     BEGIN
  361.         RETURN VGroup(TAG(buffer,
  362.                     MD.maGroupSpacing,      0,
  363.                     Child,                  VSpace(0),
  364.                     Child,                  obj,
  365.                     Child,                  VSpace(0),
  366.                     tagEnd));
  367.     END VCenter;
  368. (*}}}*)
  369. (*}}}*)
  370. (*{{{  "PopButton" *)
  371. (*
  372. **
  373. **  PopUp-Button
  374. **
  375. **  to be used for Popup-Objects
  376. **
  377. *)
  378.  
  379. PROCEDURE PopButton(img : ARRAY OF CHAR) : APTR;
  380.     BEGIN
  381.         RETURN ImageObject(TAG(buffer,
  382.                     MD.maFrame,                 MD.mvFrameImageButton,
  383.                     MD.maImageSpec,             ADR(img),
  384.                     MD.maImageFontMatchWidth,   TRUE,
  385.                     MD.maImageFreeVert,         TRUE,
  386.                     MD.maInputMode,             MD.mvInputModeRelVerify,
  387.                     MD.maBackground,            MD.miBACKGROUND,
  388.                     tagEnd));
  389.     END PopButton;
  390. (*}}}*)
  391.  
  392. (*
  393. **
  394. ** String-Object
  395. **
  396. ** Makes a simple String-Gadget
  397. **
  398. *)
  399.  
  400. (*{{{  "StringObjects" *)
  401. (*$ IF Locale *)
  402. PROCEDURE String(contents : StrPtr; maxlen : LONGINT) : APTR;
  403. (*$ ELSE *)(*$ CopyDyn := FALSE *)
  404. PROCEDURE String(contents : ARRAY OF CHAR; maxlen : LONGINT) : APTR;
  405. (*$ ENDIF *)
  406.     BEGIN
  407.         RETURN StringObject(TAG(buffer,
  408.                             MD.maFrame,            MD.mvFrameString,
  409.                             MD.maStringMaxLen,     maxlen,
  410.                             (*$ IF Locale *)
  411.                                 MD.maStringContents,   contents,
  412.                             (*$ ELSE *)
  413.                                 MD.maStringContents,   ADR(contents),
  414.                             (*$ ENDIF *)
  415.                             tagEnd));
  416.     END String;
  417. (*$ IF Locale *)
  418. PROCEDURE KeyString(contents : StrPtr; maxlen : LONGINT; key : CHAR) : APTR;
  419. (*$ ELSE *)(*$ CopyDyn := FALSE *)
  420. PROCEDURE KeyString(contents : ARRAY OF CHAR; maxlen : LONGINT; key : CHAR) : APTR;
  421. (*$ ENDIF *)
  422.     BEGIN
  423.         RETURN StringObject(TAG(buffer,
  424.                             MD.maFrame,             MD.mvFrameString,
  425.                             MD.maStringMaxLen,      maxlen,
  426.                             (*$ IF Locale *)
  427.                                 MD.maStringContents,    contents,
  428.                             (*$ ELSE *)
  429.                                 MD.maStringContents,    ADR(contents),
  430.                             (*$ ENDIF *)
  431.                             MD.maControlChar,       key,
  432.                             tagEnd));
  433.     END KeyString;
  434. (*}}}*)
  435.  
  436. (*
  437. **
  438. ** Checkmark
  439. **
  440. *)
  441.  
  442. (*{{{  "Checkmarks" *)
  443. PROCEDURE Checkmark(selected : BOOLEAN) : APTR;
  444.     BEGIN
  445.         RETURN ImageObject( TAG(buffer,
  446.                             MD.maFrame,            MD.mvFrameImageButton,
  447.                             MD.maInputMode,        MD.mvInputModeToggle,
  448.                             MD.maImageSpec,        MD.miCheckMark,
  449.                             MD.maImageFreeVert,    TRUE,
  450.                             MD.maSelected,         selected,
  451.                             MD.maBackground,       MD.miButtonBack,
  452.                             MD.maShowSelState,     FALSE,
  453.                             tagEnd));
  454.     END Checkmark;
  455.  
  456. PROCEDURE KeyCheckmark(selected : BOOLEAN; key : CHAR) : APTR;
  457.     BEGIN
  458.         RETURN ImageObject( TAG(buffer,
  459.                             MD.maFrame,            MD.mvFrameImageButton,
  460.                             MD.maInputMode,        MD.mvInputModeToggle,
  461.                             MD.maImageSpec,        MD.miCheckMark,
  462.                             MD.maImageFreeVert,    TRUE,
  463.                             MD.maSelected,         selected,
  464.                             MD.maBackground,       MD.miButtonBack,
  465.                             MD.maShowSelState,     FALSE,
  466.                             MD.maControlChar,      key,
  467.                             tagEnd));
  468.     END KeyCheckmark;
  469.  
  470. (*}}}*)
  471.  
  472. (*
  473. **
  474. ** Buttons
  475. **
  476. *)
  477.  
  478. (*{{{  "Buttons" *)
  479. (*$ IF Locale *)
  480. PROCEDURE Simplebutton(name : StrPtr) : APTR;
  481. (*$ ELSE *)(*$ CopyDyn := FALSE *)
  482. PROCEDURE Simplebutton(name : ARRAY OF CHAR) : APTR;
  483. (*$ ENDIF *)
  484.     BEGIN
  485.         RETURN TextObject(  TAG(buffer,
  486.                             MD.maFrame,            MD.mvFrameButton,
  487.                             (*$ IF Locale *)
  488.                                 MD.maTextContents,     name,
  489.                             (*$ ELSE *)
  490.                                 MD.maTextContents,     ADR(name),
  491.                             (*$ ENDIF *)
  492.                             MD.maTextPreParse,     ADR("\033c"),
  493.                             MD.maTextSetMax,       FALSE,
  494.                             MD.maInputMode,        MD.mvInputModeRelVerify,
  495.                             MD.maBackground,       MD.miButtonBack,
  496.                             tagEnd));
  497.  
  498.     END Simplebutton;
  499.  
  500. (*$ IF Locale *)
  501. PROCEDURE Keybutton(name : StrPtr; key : CHAR) : APTR;
  502. (*$ ELSE *)(*$ CopyDyn := FALSE *)
  503. PROCEDURE Keybutton(name : ARRAY OF CHAR; key : CHAR) : APTR;
  504. (*$ ENDIF *)
  505.     BEGIN
  506.         RETURN TextObject(  TAG(buffer,
  507.                             MD.maFrame,            MD.mvFrameButton,
  508.                             (*$ IF Locale *)
  509.                                 MD.maTextContents,     name,
  510.                             (*$ ELSE *)
  511.                                 MD.maTextContents,     ADR(name),
  512.                             (*$ ENDIF *)
  513.                             MD.maTextPreParse,     ADR("\033c"),
  514.                             MD.maTextSetMax,       FALSE,
  515.                             MD.maTextHiChar,       key,
  516.                             MD.maControlChar,      key,
  517.                             MD.maInputMode,        MD.mvInputModeRelVerify,
  518.                             MD.maBackground,       MD.miButtonBack,
  519.                             tagEnd));
  520.  
  521.     END Keybutton;
  522.  
  523. (*}}}*)
  524.  
  525. (*
  526. **
  527. **  Radio Object
  528. **
  529. *)
  530.  
  531. (*{{{  "RadioObjects" *)
  532. (*$ IF Locale *)
  533. PROCEDURE Radio(name : StrPtr; array : APTR) : APTR;
  534. (*$ ELSE *)(*$ CopyDyn := FALSE *)
  535. PROCEDURE Radio(name : ARRAY OF CHAR; array : APTR) : APTR;
  536. (*$ ENDIF *)
  537.     BEGIN
  538.         RETURN RadioObject( TAG(buffer,
  539.                             MD.maFrame,             MD.mvFrameGroup,
  540.                             (*$ IF Locale *)
  541.                                 MD.maFrameTitle,        name,
  542.                             (*$ ELSE *)
  543.                                 MD.maFrameTitle,        ADR(name),
  544.                             (*$ ENDIF *)
  545.                             MD.maRadioEntries,      array,
  546.                             tagEnd));
  547.     END Radio;
  548.  
  549. (*$ IF Locale *)
  550. PROCEDURE KeyRadio(name : StrPtr; array : APTR; key : CHAR) : APTR;
  551. (*$ ELSE *)(*$ CopyDyn := FALSE *)
  552. PROCEDURE KeyRadio(name : ARRAY OF CHAR; array : APTR; key : CHAR) : APTR;
  553. (*$ ENDIF *)
  554.     BEGIN
  555.         RETURN RadioObject( TAG(buffer,
  556.                             MD.maFrame,             MD.mvFrameGroup,
  557.                             (*$ IF Locale *)
  558.                                 MD.maFrameTitle,        name,
  559.                             (*$ ELSE *)
  560.                                 MD.maFrameTitle,        ADR(name),
  561.                             (*$ ENDIF *)
  562.                             MD.maTextHiChar,        key,
  563.                             MD.maControlChar,       key,
  564.                             MD.maRadioEntries,      array,
  565.                             tagEnd));
  566.     END KeyRadio;
  567.  
  568. (*}}}*)
  569.  
  570. (*
  571. **
  572. ** Label Objects
  573. **
  574. *)
  575.  
  576. (*{{{  "LabelX" *)
  577. (*$ IF Locale *)
  578. PROCEDURE Label(label : StrPtr) : APTR;
  579. (*$ ELSE *)(*$ CopyDyn := FALSE *)
  580. PROCEDURE Label(label : ARRAY OF CHAR) : APTR;
  581. (*$ ENDIF *)
  582.     BEGIN
  583.         RETURN TextObject(  TAG(buffer,
  584.                             MD.maTextPreParse,         ADR("\033r"),
  585.                             (*$ IF Locale *)
  586.                                 MD.maTextContents,         label,
  587.                             (*$ ELSE *)
  588.                                 MD.maTextContents,         ADR(label),
  589.                             (*$ ENDIF *)
  590.                             MD.maWeight,               0,
  591.                             MD.maInnerLeft,            0,
  592.                             MD.maInnerRight,           0,
  593.                             tagEnd));
  594.     END Label;
  595.  
  596. (*$ IF Locale *)
  597. PROCEDURE Label1(label : StrPtr) : APTR;
  598. (*$ ELSE *)(*$ CopyDyn := FALSE *)
  599. PROCEDURE Label1(label : ARRAY OF CHAR) : APTR;
  600. (*$ ENDIF *)
  601.     BEGIN
  602.         RETURN TextObject(  TAG(buffer,
  603.                             MD.maTextPreParse,         ADR("\033r"),
  604.                             (*$ IF Locale *)
  605.                                 MD.maTextContents,         label,
  606.                             (*$ ELSE *)
  607.                                 MD.maTextContents,         ADR(label),
  608.                             (*$ ENDIF *)
  609.                             MD.maWeight,               0,
  610.                             MD.maInnerLeft,            0,
  611.                             MD.maInnerRight,           0,
  612.                             MD.maFrame,                MD.mvFrameButton,
  613.                             MD.maFramePhantomHoriz,    TRUE,
  614.                             tagEnd));
  615.     END Label1;
  616.  
  617. (*$ IF Locale *)
  618. PROCEDURE Label2(label : StrPtr) : APTR;
  619. (*$ ELSE *)(*$ CopyDyn := FALSE *)
  620. PROCEDURE Label2(label : ARRAY OF CHAR) : APTR;
  621. (*$ ENDIF *)
  622.     BEGIN
  623.         RETURN TextObject(  TAG(buffer,
  624.                             MD.maTextPreParse,         ADR("\033r"),
  625.                             (*$ IF Locale *)
  626.                                 MD.maTextContents,         label,
  627.                             (*$ ELSE *)
  628.                                 MD.maTextContents,         ADR(label),
  629.                             (*$ ENDIF *)
  630.                             MD.maWeight,               0,
  631.                             MD.maInnerLeft,            0,
  632.                             MD.maInnerRight,           0,
  633.                             MD.maFrame,                MD.mvFrameString,
  634.                             MD.maFramePhantomHoriz,    TRUE,
  635.                             tagEnd));
  636.     END Label2;
  637. (*}}}*)
  638. (*{{{  "LLabelX" *)
  639. (*$ IF Locale *)
  640. PROCEDURE LLabel(label : StrPtr) : APTR;
  641. (*$ ELSE *)(*$ CopyDyn := FALSE *)
  642. PROCEDURE LLabel(label : ARRAY OF CHAR) : APTR;
  643. (*$ ENDIF *)
  644.     BEGIN
  645.         RETURN TextObject(  TAG(buffer,
  646.                             (*$ IF Locale *)
  647.                                 MD.maTextContents,         label,
  648.                             (*$ ELSE *)
  649.                                 MD.maTextContents,         ADR(label),
  650.                             (*$ ENDIF *)
  651.                             MD.maWeight,               0,
  652.                             MD.maInnerLeft,            0,
  653.                             MD.maInnerRight,           0,
  654.                             tagEnd));
  655.     END LLabel;
  656.  
  657.  
  658. (*$ IF Locale *)
  659. PROCEDURE LLabel1(label : StrPtr) : APTR;
  660. (*$ ELSE *)(*$ CopyDyn := FALSE *)
  661. PROCEDURE LLabel1(label : ARRAY OF CHAR) : APTR;
  662. (*$ ENDIF *)
  663.     BEGIN
  664.         RETURN TextObject(  TAG(buffer,
  665.                             (*$ IF Locale *)
  666.                                 MD.maTextContents,         label,
  667.                             (*$ ELSE *)
  668.                                 MD.maTextContents,         ADR(label),
  669.                             (*$ ENDIF *)
  670.                             MD.maWeight,               0,
  671.                             MD.maInnerLeft,            0,
  672.                             MD.maInnerRight,           0,
  673.                             MD.maFrame,                MD.mvFrameButton,
  674.                             MD.maFramePhantomHoriz,    TRUE,
  675.                             tagEnd));
  676.     END LLabel1;
  677.  
  678.  
  679. (*$ IF Locale *)
  680. PROCEDURE LLabel2(label : StrPtr) : APTR;
  681. (*$ ELSE *)(*$ CopyDyn := FALSE *)
  682. PROCEDURE LLabel2(label : ARRAY OF CHAR) : APTR;
  683. (*$ ENDIF *)
  684.     BEGIN
  685.         RETURN TextObject(  TAG(buffer,
  686.                             (*$ IF Locale *)
  687.                                 MD.maTextContents,         label,
  688.                             (*$ ELSE *)
  689.                                 MD.maTextContents,         ADR(label),
  690.                             (*$ ENDIF *)
  691.                             MD.maWeight,               0,
  692.                             MD.maInnerLeft,            0,
  693.                             MD.maInnerRight,           0,
  694.                             MD.maFrame,                MD.mvFrameString,
  695.                             MD.maFramePhantomHoriz,    TRUE,
  696.                             tagEnd));
  697.     END LLabel2;
  698. (*}}}*)
  699. (*{{{  "KeyLabelX" *)
  700. (*$ IF Locale *)
  701. PROCEDURE KeyLabel(label : StrPtr; HiChar : CHAR) : APTR;
  702. (*$ ELSE *)(*$ CopyDyn := FALSE *)
  703. PROCEDURE KeyLabel(label : ARRAY OF CHAR; HiChar : CHAR) : APTR;
  704. (*$ ENDIF *)
  705.     BEGIN
  706.         RETURN TextObject(  TAG(buffer,
  707.                             MD.maTextPreParse,         ADR("\033r"),
  708.                             (*$ IF Locale *)
  709.                                 MD.maTextContents,         label,
  710.                             (*$ ELSE *)
  711.                                 MD.maTextContents,         ADR(label),
  712.                             (*$ ENDIF *)
  713.                             MD.maWeight,               0,
  714.                             MD.maInnerLeft,            0,
  715.                             MD.maInnerRight,           0,
  716.                             MD.maTextHiChar,           HiChar,
  717.                             tagEnd));
  718.     END KeyLabel;
  719.  
  720.  
  721. (*$ IF Locale *)
  722. PROCEDURE KeyLabel1(label : StrPtr; HiChar : CHAR) : APTR;
  723. (*$ ELSE *)(*$ CopyDyn := FALSE *)
  724. PROCEDURE KeyLabel1(label : ARRAY OF CHAR; HiChar : CHAR) : APTR;
  725. (*$ ENDIF *)
  726.     BEGIN
  727.         RETURN TextObject(  TAG(buffer,
  728.                             MD.maTextPreParse,         ADR("\033r"),
  729.                             (*$ IF Locale *)
  730.                                 MD.maTextContents,         label,
  731.                             (*$ ELSE *)
  732.                                 MD.maTextContents,         ADR(label),
  733.                             (*$ ENDIF *)
  734.                             MD.maWeight,               0,
  735.                             MD.maInnerLeft,            0,
  736.                             MD.maInnerRight,           0,
  737.                             MD.maTextHiChar,           HiChar,
  738.                             MD.maFrame,                MD.mvFrameButton,
  739.                             MD.maFramePhantomHoriz,    TRUE,
  740.                             tagEnd));
  741.     END KeyLabel1;
  742.  
  743.  
  744. (*$ IF Locale *)
  745. PROCEDURE KeyLabel2(label : StrPtr; HiChar : CHAR) : APTR;
  746. (*$ ELSE *)(*$ CopyDyn := FALSE *)
  747. PROCEDURE KeyLabel2(label : ARRAY OF CHAR; HiChar : CHAR) : APTR;
  748. (*$ ENDIF *)
  749.     BEGIN
  750.         RETURN TextObject(  TAG(buffer,
  751.                             MD.maTextPreParse,         ADR("\033r"),
  752.                             (*$ IF Locale *)
  753.                                 MD.maTextContents,         label,
  754.                             (*$ ELSE *)
  755.                                 MD.maTextContents,         ADR(label),
  756.                             (*$ ENDIF *)
  757.                             MD.maWeight,               0,
  758.                             MD.maInnerLeft,            0,
  759.                             MD.maInnerRight,           0,
  760.                             MD.maTextHiChar,           HiChar,
  761.                             MD.maFrame,                MD.mvFrameString,
  762.                             MD.maFramePhantomHoriz,    TRUE,
  763.                             tagEnd));
  764.     END KeyLabel2;
  765. (*}}}*)
  766. (*{{{  "KeyLLabelX" *)
  767. (*$ IF Locale *)
  768. PROCEDURE KeyLLabel(label : StrPtr; HiChar : CHAR) : APTR;
  769. (*$ ELSE *)(*$ CopyDyn := FALSE *)
  770. PROCEDURE KeyLLabel(label : ARRAY OF CHAR; HiChar : CHAR) : APTR;
  771. (*$ ENDIF *)
  772.     BEGIN
  773.         RETURN TextObject(  TAG(buffer,
  774.                             (*$ IF Locale *)
  775.                                 MD.maTextContents,         label,
  776.                             (*$ ELSE *)
  777.                                 MD.maTextContents,         ADR(label),
  778.                             (*$ ENDIF *)
  779.                             MD.maWeight,               0,
  780.                             MD.maInnerLeft,            0,
  781.                             MD.maInnerRight,           0,
  782.                             MD.maTextHiChar,           HiChar,
  783.                             tagEnd));
  784.     END KeyLLabel;
  785.  
  786.  
  787. (*$ IF Locale *)
  788. PROCEDURE KeyLLabel1(label : StrPtr; HiChar : CHAR) : APTR;
  789. (*$ ELSE *)(*$ CopyDyn := FALSE *)
  790. PROCEDURE KeyLLabel1(label : ARRAY OF CHAR; HiChar : CHAR) : APTR;
  791. (*$ ENDIF *)
  792.     BEGIN
  793.         RETURN TextObject(  TAG(buffer,
  794.                             (*$ IF Locale *)
  795.                                 MD.maTextContents,         label,
  796.                             (*$ ELSE *)
  797.                                 MD.maTextContents,         ADR(label),
  798.                             (*$ ENDIF *)
  799.                             MD.maWeight,               0,
  800.                             MD.maInnerLeft,            0,
  801.                             MD.maInnerRight,           0,
  802.                             MD.maTextHiChar,           HiChar,
  803.                             MD.maFrame,                MD.mvFrameButton,
  804.                             MD.maFramePhantomHoriz,    TRUE,
  805.                             tagEnd));
  806.     END KeyLLabel1;
  807.  
  808.  
  809. (*$ IF Locale *)
  810. PROCEDURE KeyLLabel2(label : StrPtr; HiChar : CHAR) : APTR;
  811. (*$ ELSE *)(*$ CopyDyn := FALSE *)
  812. PROCEDURE KeyLLabel2(label : ARRAY OF CHAR; HiChar : CHAR) : APTR;
  813. (*$ ENDIF *)
  814.     BEGIN
  815.         RETURN TextObject(  TAG(buffer,
  816.                             (*$ IF Locale *)
  817.                                 MD.maTextContents,         label,
  818.                             (*$ ELSE *)
  819.                                 MD.maTextContents,         ADR(label),
  820.                             (*$ ENDIF *)
  821.                             MD.maWeight,               0,
  822.                             MD.maInnerLeft,            0,
  823.                             MD.maInnerRight,           0,
  824.                             MD.maTextHiChar,           HiChar,
  825.                             MD.maFrame,                MD.mvFrameString,
  826.                             MD.maFramePhantomHoriz,    TRUE,
  827.                             tagEnd));
  828.     END KeyLLabel2;
  829. (*}}}*)
  830.  
  831. (*
  832. **
  833. **  Cycle-Objects
  834. **
  835. *)
  836.  
  837. (*{{{  "Cycle" *)
  838. PROCEDURE Cycle(array : APTR) : APTR;
  839.     BEGIN
  840.         RETURN CycleObject(TAG(buffer,
  841.                             MD.maCycleEntries,      array,
  842.                             tagEnd));
  843.     END Cycle;
  844.  
  845.  
  846. PROCEDURE KeyCycle(array : APTR; key : CHAR) : APTR;
  847.     BEGIN
  848.         RETURN CycleObject(TAG(buffer,
  849.                             MD.maCycleEntries,      array,
  850.                             MD.maControlChar,       key,
  851.                             tagEnd));
  852.     END KeyCycle;
  853. (*}}}*)
  854.  
  855. (*
  856. **
  857. **  Slider-Objects
  858. **
  859. *)
  860.  
  861. (*{{{  "Slider" *)
  862. PROCEDURE Slider(min,max,level : LONGINT; horiz : BOOLEAN) : APTR;
  863.     BEGIN
  864.         RETURN SliderObject(TAG(buffer,
  865.                             MD.maGroupHoriz,        horiz,
  866.                             MD.maSliderLevel,       level,
  867.                             MD.maSliderMax,         max,
  868.                             MD.maSliderMin,         min,
  869.                             tagEnd));
  870.     END Slider;
  871.  
  872. PROCEDURE KeySlider(min,max,level : LONGINT; horiz : BOOLEAN;
  873.                         key : CHAR) : APTR;
  874.     BEGIN
  875.         RETURN SliderObject(TAG(buffer,
  876.                             MD.maGroupHoriz,        horiz,
  877.                             MD.maSliderLevel,       level,
  878.                             MD.maSliderMax,         max,
  879.                             MD.maSliderMin,         min,
  880.                             MD.maControlChar,       key,
  881.                             tagEnd));
  882.     END KeySlider;
  883. (*}}}*)
  884.  
  885. (*
  886. **
  887. ** Controlling Objects
  888. **
  889. ** Note : get didn't work in previous releases
  890. **
  891. *)
  892.  
  893. (*{{{  "set, get,...." *)
  894.  
  895. PROCEDURE get(obj : APTR; attr : LONGCARD; store : ADDRESS);
  896.     BEGIN DoMethod(obj,TAG(buffer, omGET, attr, store));
  897.     END get;
  898.  
  899. PROCEDURE set(obj : APTR; attr : LONGCARD; value : LONGINT);
  900.     VAR dummy : APTR;
  901.     BEGIN dummy:=SetAttrsA(obj, TAG(buffer,attr,value,tagEnd));
  902.     END set;
  903.  
  904. PROCEDURE setmutex(obj : APTR; n : LONGINT);
  905.     BEGIN set(obj,MD.maRadioActive,n);
  906.     END setmutex;
  907.  
  908. PROCEDURE setcycle(obj : APTR; n : LONGINT);
  909.     BEGIN set(obj,MD.maCycleActive,n);
  910.     END setcycle;
  911.  
  912. (*$ IF Locale *)
  913. PROCEDURE setstring(obj : APTR; s : StrPtr);
  914.     BEGIN set(obj,MD.maStringContents,s);
  915.     END setstring;
  916. (*$ ELSE *) (*$ CopyDyn := FALSE *)
  917. PROCEDURE setstring(obj : APTR; s : ARRAY OF CHAR);
  918.     BEGIN set(obj,MD.maStringContents,ADR(s));
  919.     END setstring;
  920. (*$ ENDIF *)
  921.  
  922. PROCEDURE setcheckmark(obj : APTR; b : BOOLEAN);
  923.     BEGIN
  924.         IF b THEN set(obj,MD.maSelected,1);
  925.              ELSE set(obj,MD.maSelected,0);
  926.              END;
  927.     END setcheckmark;
  928.  
  929. PROCEDURE setslider(obj : APTR; l : LONGINT);
  930.     BEGIN set(obj,MD.maSliderLevel,l);
  931.     END setslider;
  932.  
  933. (*}}}*)
  934.  
  935. (*{{{  "NoteClose" *)
  936. (*
  937. ** NoteClose (app,obj,ID)
  938. *)
  939. PROCEDURE NoteClose(app : APTR; obj : APTR; ID  : LONGINT);
  940.     BEGIN DoMethod(obj,TAG(buffer, MD.mmNotify,MD.maWindowCloseRequest,TRUE, app,2,MD.mmApplicationReturnID,ID));
  941.     END NoteClose;
  942. (*}}}*)
  943. (*{{{  "NoteButton" *)
  944. (*
  945. **  Notebutton (app,obj,ID)
  946. *)
  947. PROCEDURE NoteButton(app : APTR; obj : APTR; ID  : LONGINT);
  948.     BEGIN DoMethod(obj,TAG(buffer, MD.mmNotify,MD.maPressed, FALSE, app,2,MD.mmApplicationReturnID,ID));
  949.     END NoteButton;
  950. (*}}}*)
  951. (*{{{  "RemMember" *)
  952. (*
  953. ** RemMember (obj,member)
  954. *)
  955.  
  956. PROCEDURE RemMember(obj : APTR; member : APTR);
  957.     BEGIN DoMethod(obj,TAG(buffer, omREMMEMBER, member));
  958.     END RemMember;
  959. (*}}}*)
  960. (*{{{  "AddMember" *)
  961. (*
  962. ** AddMember (obj,member)
  963. *)
  964.  
  965. PROCEDURE AddMember(obj : APTR; member : APTR);
  966.     BEGIN DoMethod(obj,TAG(buffer, omADDMEMBER, member));
  967.     END AddMember;
  968. (*}}}*)
  969.  
  970. END MuiMacros.
  971.  
  972.  
  973.  
  974.  
  975.  
  976.  
  977.  
  978.