home *** CD-ROM | disk | FTP | other *** search
/ Megahits 4 / MegaHits_Vol.4.iso / mui / dev / gui / m2mui2_0.lha / txt / MuiMacros.def < prev    next >
Text File  |  1994-02-19  |  14KB  |  467 lines
  1. DEFINITION MODULE MuiMacros;
  2.  
  3. (*$ DEFINE Locale:=FALSE *)
  4.  
  5. (****************************************************************************
  6. **
  7. **      MUI Macros 2.0
  8. **
  9. **      Converted to Modula by Christian "Kochtopf" Scholz
  10. **
  11. **      refer also to MuiMacros.mod if you want to know, how they are made.
  12. **
  13. **      $Id: MuiMacros.def,v 1.5 1994/02/15 21:14:05 Kochtopf Exp $
  14. **
  15. **      $Log: MuiMacros.def,v $
  16. # Revision 1.5  1994/02/15  21:14:05  Kochtopf
  17. # neue Macros fuer Pop* und Register definiert,
  18. # HCenter und VCenter neu
  19. # PopUp entfernt und durch PopButton ersetzt.
  20. # neue Label-Macros LLabel eingefuehrt (aus mui.h)
  21. #
  22. # Revision 1.4  1994/02/09  14:50:03  Kochtopf
  23. # Versionsnummer in 2.0 geaendert.
  24. #
  25. **
  26. ****************************************************************************
  27. ** Class Tree
  28. ****************************************************************************
  29. **
  30. ** rootclass               (BOOPSI's base class)
  31. ** +--Notify               (implements notification mechanism)
  32. **    +--Application       (main class for all applications)
  33. **    +--Window            (handles intuition window related topics)
  34. **    +--Area              (base class for all GUI elements)
  35. **       +--Rectangle      (creates empty rectangles)
  36. **       +--Image          (creates images)
  37. **       +--Text           (creates some text)
  38. **       +--String         (creates a string gadget)
  39. **       +--Prop           (creates a proportional gadget)
  40. **       +--Gauge          (creates a fule gauge)
  41. **       +--Scale          (creates a percentage scale)
  42. **       +--Boopsi         (interface to BOOPSI gadgets)
  43. **       +--Colorfield     (creates a field with changeable color)
  44. **       +--List           (creates a line-oriented list)
  45. **       !  +--Floattext   (special list with floating text)
  46. **       !  +--Volumelist  (special list with volumes)
  47. **       !  +--Scrmodelist (special list with screen modes)
  48. **       !  \--Dirlist     (special list with files)
  49. **       +--Group          (groups other GUI elements)
  50. **          +--Virtgroup   (handles virtual groups)
  51. **          +--Scrollgroup (handles virtual groups with scrollers)
  52. **          +--Scrollbar   (creates a scrollbar)
  53. **          +--Listview    (creates a listview)
  54. **          +--Radio       (creates radio buttons)
  55. **          +--Cycle       (creates cycle gadgets)
  56. **          +--Slider      (creates slider gadgets)
  57. **          +--Coloradjust (creates some RGB sliders)
  58. **          \--Palette     (creates a complete palette gadget)
  59. **
  60. ****************************************************************************)
  61.  
  62. IMPORT  MD:MuiD;
  63. IMPORT  ML:MuiL;
  64. IMPORT  UD:UtilityD;
  65. FROM    UtilityD IMPORT HookPtr;
  66. FROM    SYSTEM IMPORT ADDRESS, ADR, TAG;
  67.  
  68. TYPE    APTR    = ADDRESS;      (* just for readability *)
  69.         StrPtr  = ADDRESS;
  70.  
  71.         ShortString = ARRAY[0..3] OF CHAR;  (* for MakeID *)
  72.  
  73.         (* Here some Types you have to use, IF you want to fill the
  74.            array, the ListDisplayHook gets as parameter and which the hook
  75.            has to fill *)
  76.  
  77.         STRING      = ARRAY[0..128] OF CHAR;
  78.         STRPTR      = POINTER TO STRING;
  79.         STRARR      = ARRAY[0..10] OF STRPTR; (* set 10 to the number of columns you have in your list *)
  80.         STRARRPTR   = POINTER TO STRARR;
  81.  
  82.         (* Use it the following way :
  83.  
  84.         Your Hookfunction :
  85.  
  86.         PROCEDURE dspfunc(hook : HookPtr; array : APTR; entry : APTR) : APTR;
  87.  
  88.             BEGIN
  89.                 CAST(STRARRPTR,array)^[0]:=ADR(first string);
  90.                 CAST(STRARRPTR,array)^[1]:=ADR(second string);
  91.                 ...
  92.                 RETURN 0;
  93.             END dspfunc;
  94.  
  95.         As you see, it is the same as string-arrays in C  *)
  96.  
  97.  
  98.         (* Here your PROCEDURE-Prototype for your hookfunction : *)
  99.  
  100.         HookDef     = PROCEDURE(HookPtr, APTR, APTR):APTR;
  101.  
  102. (*
  103. **  MUI - Object Generation
  104. **
  105. **  These Macros are equal to the C-Macros which can be found in mui.h
  106. **  But notice, that you have a different usage of these :
  107. **
  108. **  Instead of
  109. **
  110. **      app = ApplicationObject,
  111. **
  112. **              ...
  113. **
  114. **            End;
  115. **
  116. **  you now write :
  117. **
  118. **      app := ApplicationObject(TAG(buffer,    (* TAG from SYSTEM *)
  119. **
  120. **              ...
  121. **
  122. **             tagEnd));    (* tagEnd imported from UtilityD *)
  123. **
  124. **  Also you can't use :
  125. **
  126. **      app := ApplicationObject(TAG(buffer,
  127. **
  128. **              ...
  129. **  ====>            window:=WindowObject(TAG(buffer, ... , tagEnd)),
  130. **              ...
  131. **
  132. **             tagEnd));
  133. **
  134. **  instead of this, you have to define your Window-Object before the
  135. **  Application-Object and then use the pointer in the App-Definition :
  136. **
  137. **      window := WindowObject(TAG(buffer, ... , tagEnd)),
  138. **
  139. **      app := ApplicationObject(TAG(buffer,
  140. **
  141. **              ...
  142. **                   window,
  143. **              ...
  144. **
  145. **             tagEnd));
  146. **
  147. **  So you can't define a whole application with one command if you need
  148. **  the pointer of some objects later on (for a Notify, etc.)
  149. **
  150. *)
  151.  
  152. CONST   Child           = MD.maGroupChild;
  153.         SubWindow       = MD.maApplicationWindow;
  154.         WindowContents  = MD.maWindowRootObject;
  155.  
  156. PROCEDURE WindowObject(tags : UD.TagItemPtr) : APTR;
  157. PROCEDURE ImageObject(tags : UD.TagItemPtr) : APTR;
  158. PROCEDURE NotifyObject(tags : UD.TagItemPtr) : APTR;
  159. PROCEDURE ApplicationObject(tags : UD.TagItemPtr) : APTR;
  160. PROCEDURE TextObject(tags : UD.TagItemPtr) : APTR;
  161. PROCEDURE RectangleObject(tags : UD.TagItemPtr) : APTR;
  162. PROCEDURE ListObject(tags : UD.TagItemPtr) : APTR;
  163. PROCEDURE PropObject(tags : UD.TagItemPtr) : APTR;
  164. PROCEDURE StringObject(tags : UD.TagItemPtr) : APTR;
  165. PROCEDURE ScrollbarObject(tags : UD.TagItemPtr) : APTR;
  166. PROCEDURE ListviewObject(tags : UD.TagItemPtr) : APTR;
  167. PROCEDURE RadioObject(tags : UD.TagItemPtr) : APTR;
  168. PROCEDURE VolumelistObject(tags : UD.TagItemPtr) : APTR;
  169. PROCEDURE FloattextObject(tags : UD.TagItemPtr) : APTR;
  170. PROCEDURE DirlistObject(tags : UD.TagItemPtr) : APTR;
  171. PROCEDURE SliderObject(tags : UD.TagItemPtr) : APTR;
  172. PROCEDURE CycleObject(tags : UD.TagItemPtr) : APTR;
  173. PROCEDURE GaugeObject(tags : UD.TagItemPtr) : APTR;
  174. PROCEDURE ScaleObject(tags : UD.TagItemPtr) : APTR;
  175. PROCEDURE BoopsiObject(tags : UD.TagItemPtr) : APTR;
  176. PROCEDURE ColorfieldObject(tags : UD.TagItemPtr) : APTR;
  177. PROCEDURE ColoradjustObject(tags : UD.TagItemPtr) : APTR;
  178. PROCEDURE PaletteObject(tags : UD.TagItemPtr) : APTR;
  179. PROCEDURE GroupObject(tags : UD.TagItemPtr) : APTR;
  180. PROCEDURE VirtgroupObject(tags : UD.TagItemPtr) : APTR;
  181. PROCEDURE ScrollgroupObject(tags : UD.TagItemPtr) : APTR;
  182. PROCEDURE ScrmodelistObject(tags : UD.TagItemPtr) : APTR;
  183. PROCEDURE VGroup(tags : UD.TagItemPtr) : APTR;
  184. PROCEDURE HGroup(tags : UD.TagItemPtr) : APTR;
  185. PROCEDURE ColGroup(cols : LONGCARD; tags : UD.TagItemPtr) : APTR;
  186. PROCEDURE RowGroup(rows : LONGCARD; tags : UD.TagItemPtr) : APTR;
  187. PROCEDURE PageGroup(tags : UD.TagItemPtr) : APTR;
  188. PROCEDURE VGroupV(tags : UD.TagItemPtr) : APTR;
  189. PROCEDURE HGroupV(tags : UD.TagItemPtr) : APTR;
  190. PROCEDURE ColGroupV(cols : LONGCARD; tags : UD.TagItemPtr) : APTR;
  191. PROCEDURE RowGroupV(rows : LONGCARD; tags : UD.TagItemPtr) : APTR;
  192. PROCEDURE PageGroupV(tags : UD.TagItemPtr) : APTR;
  193. PROCEDURE PopString(tags : UD.TagItemPtr) : APTR;
  194. PROCEDURE PopObject(tags : UD.TagItemPtr) : APTR;
  195. PROCEDURE PopAsl(tags : UD.TagItemPtr) : APTR;
  196. PROCEDURE Register(tags : UD.TagItemPtr) : APTR;
  197.  
  198.  
  199. (*
  200. **  MakeID
  201. **  Generate an ID out of a 4-char-string.
  202. **  Use it the as WindowID ! (look in MuiTest for an example!)
  203. *)
  204.  
  205. PROCEDURE MakeID (name : ShortString): LONGINT;
  206.  
  207. (*
  208. **
  209. **  Hook Macros
  210. **
  211. **  Use it the following way :
  212. **      1. Write your Hook-Function :
  213. **          PROCEDURE hookfunc(hook:HookPtr; obj : APTR; args : APTR) : APTR
  214. **              BEGIN
  215. **              ...
  216. **              END hookfunc;
  217. **          Note, that your function needs not to specify registers, but
  218. **          your PROCEDURE must be looking like name(HookPtr, APTR, APTR)!!
  219. **
  220. **      2. Define in your VAR-section a pointer to a Hookrecord :
  221. **          VAR hook    : UtilitiesD.HookPtr;
  222. **
  223. **      3. fill it with MakeHook :
  224. **          MakeHook(hookfunc,hook);
  225. **
  226. **      4. Use it with MUI, as you like, e.g. :
  227. **          DoMethod(button,TAG(buffer,MD.mmCallHook,hook,arg1,arg2));
  228. **
  229. *)
  230.  
  231. PROCEDURE MakeHook(entry:HookDef; VAR hook : HookPtr);
  232.  
  233. (*
  234. **
  235. **  Spacing Macros
  236. **
  237. **  (not all from mui.h)
  238. **
  239. *)
  240.  
  241. PROCEDURE HVSpace() : APTR;
  242. PROCEDURE HSpace(x : LONGCARD) : APTR;
  243. PROCEDURE VSpace(x : LONGCARD) : APTR;
  244. PROCEDURE HCenter(obj : APTR) : APTR;
  245. PROCEDURE VCenter(obj : APTR) : APTR;
  246.  
  247. (*
  248. **
  249. **  Popup-Object
  250. **
  251. **
  252. *)
  253.  
  254. PROCEDURE PopButton(img : ARRAY OF CHAR) : APTR;
  255.  
  256.  
  257. (*
  258. **
  259. ** String-Object
  260. **
  261. ** Creates a simple String-Gadget
  262. **
  263. *)
  264.  
  265. (*$ IF Locale *)
  266. PROCEDURE String(contents : StrPtr; maxlen : LONGINT) : APTR;
  267. PROCEDURE KeyString(contents : StrPtr; maxlen : LONGINT; key : CHAR) : APTR;
  268. (*$ ELSE *)
  269. PROCEDURE String(contents : ARRAY OF CHAR; maxlen : LONGINT) : APTR;
  270. PROCEDURE KeyString(contents : ARRAY OF CHAR; maxlen : LONGINT; key : CHAR) : APTR;
  271. (*$ ENDIF *)
  272.  
  273. (*
  274. **
  275. ** Checkmark
  276. **
  277. ** creates a Checkmark Gadget
  278. **
  279. *)
  280.  
  281. PROCEDURE Checkmark(selected : BOOLEAN) : APTR;
  282. PROCEDURE KeyCheckmark(selected : BOOLEAN; key : CHAR) : APTR;
  283.  
  284. (*
  285. **
  286. ** Buttons
  287. **
  288. ** Here the same note : Use small letters for Keybuttons!
  289. **
  290. *)
  291.  
  292. (*$ IF Locale *)
  293. PROCEDURE Simplebutton(name : StrPtr) : APTR;
  294. PROCEDURE Keybutton(name : StrPtr; key : CHAR) : APTR;
  295. (*$ ELSE *)
  296. PROCEDURE Simplebutton(name : ARRAY OF CHAR) : APTR;
  297. PROCEDURE Keybutton(name : ARRAY OF CHAR; key : CHAR) : APTR;
  298. (*$ ENDIF *)
  299.  
  300. (*
  301. **
  302. **  Radio Object
  303. **
  304. *)
  305.  
  306. (*$ IF Locale *)
  307. PROCEDURE Radio(name : StrPtr; array : APTR) : APTR;
  308. (*$ ELSE *)
  309. PROCEDURE Radio(name : ARRAY OF CHAR; array : APTR) : APTR;
  310. (*$ ENDIF *)
  311.  
  312. (*$ IF Locale *)
  313. PROCEDURE KeyRadio(name : StrPtr; array : APTR; key : CHAR) : APTR;
  314. (*$ ELSE *)
  315. PROCEDURE KeyRadio(name : ARRAY OF CHAR; array : APTR; key : CHAR) : APTR;
  316. (*$ ENDIF *)
  317.  
  318. (*
  319. **
  320. ** Label Objects
  321. **
  322. ** The same as in mui.h
  323. **
  324. ** Label()  : create a Label for Objects without a frame
  325. ** Label1() : create a label for Objects with a standard frame (Checkmarks...)
  326. ** Label2() : create a label for Objects with double high frame (String Gadgets...)
  327. **
  328. *)
  329.  
  330. (*$ IF Locale *)
  331. PROCEDURE Label(label : StrPtr) : APTR;
  332. PROCEDURE Label1(label : StrPtr) : APTR;
  333. PROCEDURE Label2(label : StrPtr) : APTR;
  334. PROCEDURE LLabel(label : StrPtr) : APTR;
  335. PROCEDURE LLabel1(label : StrPtr) : APTR;
  336. PROCEDURE LLabel2(label : StrPtr) : APTR;
  337. PROCEDURE KeyLabel(label : StrPtr; HiChar : CHAR) : APTR;
  338. PROCEDURE KeyLabel1(label : StrPtr; HiChar : CHAR) : APTR;
  339. PROCEDURE KeyLabel2(label : StrPtr; HiChar : CHAR) : APTR;
  340. PROCEDURE KeyLLabel(label : StrPtr; HiChar : CHAR) : APTR;
  341. PROCEDURE KeyLLabel1(label : StrPtr; HiChar : CHAR) : APTR;
  342. PROCEDURE KeyLLabel2(label : StrPtr; HiChar : CHAR) : APTR;
  343. (*$ ELSE *)
  344. PROCEDURE Label(label : ARRAY OF CHAR) : APTR;
  345. PROCEDURE Label1(label : ARRAY OF CHAR) : APTR;
  346. PROCEDURE Label2(label : ARRAY OF CHAR) : APTR;
  347. PROCEDURE LLabel(label : ARRAY OF CHAR) : APTR;
  348. PROCEDURE LLabel1(label : ARRAY OF CHAR) : APTR;
  349. PROCEDURE LLabel2(label : ARRAY OF CHAR) : APTR;
  350. PROCEDURE KeyLabel(label : ARRAY OF CHAR; HiChar : CHAR) : APTR;
  351. PROCEDURE KeyLabel1(label : ARRAY OF CHAR; HiChar : CHAR) : APTR;
  352. PROCEDURE KeyLabel2(label : ARRAY OF CHAR; HiChar : CHAR) : APTR;
  353. PROCEDURE KeyLLabel(label : ARRAY OF CHAR; HiChar : CHAR) : APTR;
  354. PROCEDURE KeyLLabel1(label : ARRAY OF CHAR; HiChar : CHAR) : APTR;
  355. PROCEDURE KeyLLabel2(label : ARRAY OF CHAR; HiChar : CHAR) : APTR;
  356. (*$ ENDIF *)
  357.  
  358. (*
  359. **
  360. **  Cycle-Objects
  361. **
  362. *)
  363.  
  364. PROCEDURE Cycle(array : APTR) : APTR;
  365. PROCEDURE KeyCycle(array : APTR; key : CHAR) : APTR;
  366.  
  367. (*
  368. **
  369. **  Slider-Objects
  370. **
  371. *)
  372.  
  373. PROCEDURE Slider(min, max, level : LONGINT; horiz : BOOLEAN) : APTR;
  374. PROCEDURE KeySlider(min, max, level : LONGINT; horiz : BOOLEAN; key : CHAR) : APTR;
  375.  
  376.  
  377. (*
  378. **
  379. ** Controlling Objects
  380. **
  381. ** Again the same as in mui.h :
  382. **
  383. ** set : set an attribute of an object
  384. ** get : get an attribute of an object
  385. **       didn't work in previous releases :-( (but now!! :-)
  386. **
  387. *)
  388.  
  389. PROCEDURE get(obj : APTR; attr : LONGCARD; store : ADDRESS);
  390. PROCEDURE set(obj : APTR; attr : LONGCARD; value : LONGINT);
  391. PROCEDURE setmutex(obj : APTR; n : LONGINT);
  392. PROCEDURE setcycle(obj : APTR; n : LONGINT);
  393. (*$ IF Locale *)
  394. PROCEDURE setstring(obj : APTR; s : StrPtr);
  395. (*$ ELSE *)
  396. PROCEDURE setstring(obj : APTR; s : ARRAY OF CHAR);
  397. (*$ ENDIF *)
  398. PROCEDURE setcheckmark(obj : APTR; b : BOOLEAN);
  399. PROCEDURE setslider(obj : APTR; l : LONGINT);
  400.  
  401. (*
  402. ** Now some macros which are not part of mui.h (in other words : my own ;-)
  403. **
  404. ** First : NoteClose (app,obj,ID)
  405. **         ----------------------
  406. **         This macro sets up a notification on the close-gadget of a window.
  407. **         if it gets pressed, the app-obj gets back an ID
  408. **         app : the application-object, which will receive the ID
  409. **         obj : the window-object
  410. **         ID  : the ID, which will be send to the app-obj, when the user
  411. **               presses the close-gadget of the window-object specified in
  412. **               obj.
  413. *)
  414.  
  415. PROCEDURE NoteClose(app : APTR;
  416.                     obj : APTR;
  417.                     ID  : LONGINT);
  418.  
  419. (*
  420. **  Notebutton (app,obj,ID)
  421. **  -----------------------
  422. **  Sets up a notification on a button. If it gets pressed, the app-obj
  423. **  receives an ID.
  424. **  app : the app-obj, which will receive the ID.
  425. **  obj : the pointer to the Button-Object (created by Keybutton, etc.)
  426. **  ID  : The ID, which will be send to the app-obj.
  427. **
  428. *)
  429.  
  430. PROCEDURE NoteButton(app : APTR;
  431.                      obj : APTR;
  432.                      ID  : LONGINT);
  433.  
  434. (*
  435. ** RemMember (obj,member)
  436. ** ----------------------
  437. ** The following macro deletes a member from an object
  438. **
  439. ** obj      : The object which holds the child to remove
  440. ** member   : The child which shall be removed
  441. ** ATTENTION: You have to dispose the removed child-objects yourself!
  442. **
  443. *)
  444.  
  445. PROCEDURE RemMember(obj : APTR; member : APTR);
  446.  
  447. (*
  448. ** AddMember (obj,member)
  449. ** ----------------------
  450. ** This macro will add a new child to an group-  or application-object
  451. **
  452. ** obj      : The group or application to which the new object will be added
  453. ** member   : The new child-object which shall be added to obj.
  454. **
  455. *)
  456.  
  457. PROCEDURE AddMember(obj : APTR; member : APTR);
  458.  
  459. END MuiMacros.
  460.  
  461.  
  462.  
  463.  
  464.  
  465.  
  466.  
  467.