home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / ooxdb210.zip / ooxmemo.xh < prev    next >
Text File  |  1996-12-31  |  24KB  |  864 lines
  1.  
  2. /*
  3.  * This file was generated by the SOM Compiler.
  4.  * FileName: ooxmemo.xh.
  5.  * Generated using:
  6.  *     SOM Precompiler somipc: 2.29.1.17
  7.  *     SOM Emitter emitxh: 2.47
  8.  */
  9.  
  10. #ifndef SOM_ooxmemo_xh
  11. #define SOM_ooxmemo_xh
  12.  
  13. class ooxmemo;
  14.  
  15. #define ooxmemo_MajorVersion 0
  16. #define ooxmemo_MinorVersion 0
  17.  
  18. /* C++ SOM defs */
  19. #include <somcls.xh>
  20. #include <somcm.xh>
  21.  
  22. /* C++ parent defs */
  23. #ifndef SOM_ooxfield_xh
  24. #include <ooxfield.xh>
  25. #endif
  26.  
  27. #ifndef ooxmemo_API
  28. #define ooxmemo_API
  29. /*
  30.  * -- The Class API
  31.  */
  32.  
  33. /*
  34.  * Start of bindings for IDL types
  35.  */
  36.  
  37. class SOMClass;
  38. class SOMObject;
  39. class dbt;
  40. class dbt_iv;
  41. class ooxbase;
  42. #define ex_ooxmemo_ooxfield_error "::ooxmemo::ooxfield_error"
  43. typedef
  44. struct ooxmemo_ooxfield_error {
  45. long  ErrCode;
  46. string  Reason;
  47. } ooxmemo_ooxfield_error;
  48.  
  49. #ifndef SOM_DONT_USE_SHORT_NAMES
  50. #ifndef SOMTGD_ex_ooxfield_error
  51.     #ifdef ex_ooxfield_error
  52.         #undef ex_ooxfield_error
  53.         #define SOMTGD_ex_ooxfield_error 1
  54.     #else
  55.         #define ex_ooxfield_error ex_ooxmemo_ooxfield_error
  56.     #endif /* ex_ooxfield_error */
  57. #endif /* SOMTGD_ex_ooxfield_error */
  58. #ifndef SOMTGD_ooxfield_error
  59.     #ifdef ooxfield_error
  60.         #undef ooxfield_error
  61.         #define SOMTGD_ooxfield_error 1
  62.     #else
  63.         #define ooxfield_error ooxmemo_ooxfield_error
  64.     #endif /* ooxfield_error */
  65. #endif /* SOMTGD_ooxfield_error */
  66. #endif /* SOM_DONT_USE_SHORT_NAMES */
  67.  
  68. /*
  69.  * End of bindings for IDL types.
  70.  */
  71.  
  72. /* A procedure to create the ooxmemo Class */
  73. SOMEXTERN SOMClass * SOMLINK ooxmemoNewClass(
  74.         integer4 majorVersion,
  75.         integer4 minorVersion);
  76.  
  77. /* The API to the ooxmemo class object, and the methods it introduces. */
  78. SOMEXTERN struct ooxmemoClassDataStructure {
  79.     SOMClass *classObject;
  80.     somMToken define;
  81. } SOMDLINK ooxmemoClassData;
  82. #define _ooxmemo ooxmemoClassData.classObject
  83.  
  84. /* The API to parentMtabs for ooxmemo, and the instance data it introduces. */
  85. SOMEXTERN struct ooxmemoCClassDataStructure {
  86.     somMethodTabs parentMtab;
  87.     somDToken              instanceDataToken;
  88. } SOMDLINK ooxmemoCClassData;
  89.  
  90. /*
  91.  * -- Typedefs for ooxmemo Method Procedures
  92.  */
  93. SOMEXTERN {
  94. typedef void   SOMLINK somTP_ooxmemo_define(ooxmemo *somSelf, Environment *ev, 
  95.         somInitCtrl* ctrl, 
  96.         string name);
  97. typedef somTP_ooxmemo_define *somTD_ooxmemo_define;
  98.  
  99. /*
  100.  * -- Typedefs for Reintroduced Wrapper Methods
  101.  */
  102. typedef string   SOMLINK somTP_ooxmemo_get_name(ooxmemo *somSelf, Environment *ev);
  103. typedef somTP_ooxmemo_get_name *somTD_ooxmemo_get_name;
  104. typedef string   SOMLINK somTP_ooxmemo_get(ooxmemo *somSelf, Environment *ev);
  105. typedef somTP_ooxmemo_get *somTD_ooxmemo_get;
  106. typedef long   SOMLINK somTP_ooxmemo_put(ooxmemo *somSelf, Environment *ev, 
  107.         string datum);
  108. typedef somTP_ooxmemo_put *somTD_ooxmemo_put;
  109. typedef char   SOMLINK somTP_ooxmemo_get_type(ooxmemo *somSelf, Environment *ev);
  110. typedef somTP_ooxmemo_get_type *somTD_ooxmemo_get_type;
  111. typedef short   SOMLINK somTP_ooxmemo_get_length(ooxmemo *somSelf, Environment *ev);
  112. typedef somTP_ooxmemo_get_length *somTD_ooxmemo_get_length;
  113. typedef short   SOMLINK somTP_ooxmemo_get_dec_point(ooxmemo *somSelf, Environment *ev);
  114. typedef somTP_ooxmemo_get_dec_point *somTD_ooxmemo_get_dec_point;
  115. typedef void   SOMLINK somTP_ooxmemo_somDefaultInit(ooxmemo *somSelf, 
  116.         som3InitCtrl* ctrl);
  117. typedef somTP_ooxmemo_somDefaultInit *somTD_ooxmemo_somDefaultInit;
  118. typedef void   SOMLINK somTP_ooxmemo_somUninit(ooxmemo *somSelf);
  119. typedef somTP_ooxmemo_somUninit *somTD_ooxmemo_somUninit;
  120. typedef void   SOMLINK somTP_ooxmemo_somDestruct(ooxmemo *somSelf, 
  121.         octet doFree, 
  122.         som3DestructCtrl* ctrl);
  123. typedef somTP_ooxmemo_somDestruct *somTD_ooxmemo_somDestruct;
  124. typedef void   SOMLINK somTP_ooxmemo_somDefaultCopyInit(ooxmemo *somSelf, 
  125.         som3InitCtrl* ctrl, 
  126.         SOMObject* fromObj);
  127. typedef somTP_ooxmemo_somDefaultCopyInit *somTD_ooxmemo_somDefaultCopyInit;
  128. typedef ooxmemo*   SOMLINK somTP_ooxmemo_somDefaultAssign(ooxmemo *somSelf, 
  129.         som3AssignCtrl* ctrl, 
  130.         SOMObject* fromObj);
  131. typedef somTP_ooxmemo_somDefaultAssign *somTD_ooxmemo_somDefaultAssign;
  132. typedef void   SOMLINK somTP_ooxmemo_somDefaultConstCopyInit(ooxmemo *somSelf, 
  133.         som3InitCtrl* ctrl, 
  134.         SOMObject* fromObj);
  135. typedef somTP_ooxmemo_somDefaultConstCopyInit *somTD_ooxmemo_somDefaultConstCopyInit;
  136. typedef void   SOMLINK somTP_ooxmemo_somDefaultVCopyInit(ooxmemo *somSelf, 
  137.         som3InitCtrl* ctrl, 
  138.         SOMObject* fromObj);
  139. typedef somTP_ooxmemo_somDefaultVCopyInit *somTD_ooxmemo_somDefaultVCopyInit;
  140. typedef void   SOMLINK somTP_ooxmemo_somDefaultConstVCopyInit(ooxmemo *somSelf, 
  141.         som3InitCtrl* ctrl, 
  142.         SOMObject* fromObj);
  143. typedef somTP_ooxmemo_somDefaultConstVCopyInit *somTD_ooxmemo_somDefaultConstVCopyInit;
  144. typedef ooxmemo*   SOMLINK somTP_ooxmemo_somDefaultConstAssign(ooxmemo *somSelf, 
  145.         som3AssignCtrl* ctrl, 
  146.         SOMObject* fromObj);
  147. typedef somTP_ooxmemo_somDefaultConstAssign *somTD_ooxmemo_somDefaultConstAssign;
  148. typedef ooxmemo*   SOMLINK somTP_ooxmemo_somDefaultVAssign(ooxmemo *somSelf, 
  149.         som3AssignCtrl* ctrl, 
  150.         SOMObject* fromObj);
  151. typedef somTP_ooxmemo_somDefaultVAssign *somTD_ooxmemo_somDefaultVAssign;
  152. typedef ooxmemo*   SOMLINK somTP_ooxmemo_somDefaultConstVAssign(ooxmemo *somSelf, 
  153.         som3AssignCtrl* ctrl, 
  154.         SOMObject* fromObj);
  155. typedef somTP_ooxmemo_somDefaultConstVAssign *somTD_ooxmemo_somDefaultConstVAssign;
  156. typedef void   SOMLINK somTP_ooxmemo_somInit(ooxmemo *somSelf);
  157. typedef somTP_ooxmemo_somInit *somTD_ooxmemo_somInit;
  158. typedef void   SOMLINK somTP_ooxmemo_somFree(ooxmemo *somSelf);
  159. typedef somTP_ooxmemo_somFree *somTD_ooxmemo_somFree;
  160. typedef SOMClass*   SOMLINK somTP_ooxmemo_somGetClass(ooxmemo *somSelf);
  161. typedef somTP_ooxmemo_somGetClass *somTD_ooxmemo_somGetClass;
  162. typedef string   SOMLINK somTP_ooxmemo_somGetClassName(ooxmemo *somSelf);
  163. typedef somTP_ooxmemo_somGetClassName *somTD_ooxmemo_somGetClassName;
  164. typedef long   SOMLINK somTP_ooxmemo_somGetSize(ooxmemo *somSelf);
  165. typedef somTP_ooxmemo_somGetSize *somTD_ooxmemo_somGetSize;
  166. typedef boolean   SOMLINK somTP_ooxmemo_somIsA(ooxmemo *somSelf, 
  167.         SOMClass* aClassObj);
  168. typedef somTP_ooxmemo_somIsA *somTD_ooxmemo_somIsA;
  169. typedef boolean   SOMLINK somTP_ooxmemo_somIsInstanceOf(ooxmemo *somSelf, 
  170.         SOMClass* aClassObj);
  171. typedef somTP_ooxmemo_somIsInstanceOf *somTD_ooxmemo_somIsInstanceOf;
  172. typedef boolean   SOMLINK somTP_ooxmemo_somRespondsTo(ooxmemo *somSelf, 
  173.         somId mId);
  174. typedef somTP_ooxmemo_somRespondsTo *somTD_ooxmemo_somRespondsTo;
  175. typedef boolean   SOMLINK somTP_ooxmemo_somDispatch(ooxmemo *somSelf, 
  176.         somToken* retValue, 
  177.         somId methodId, 
  178.         va_list ap);
  179. typedef somTP_ooxmemo_somDispatch *somTD_ooxmemo_somDispatch;
  180. typedef boolean   SOMLINK somTP_ooxmemo_somClassDispatch(ooxmemo *somSelf, 
  181.         SOMClass* clsObj, 
  182.         somToken* retValue, 
  183.         somId methodId, 
  184.         va_list ap);
  185. typedef somTP_ooxmemo_somClassDispatch *somTD_ooxmemo_somClassDispatch;
  186. typedef boolean   SOMLINK somTP_ooxmemo_somCastObj(ooxmemo *somSelf, 
  187.         SOMClass* cls);
  188. typedef somTP_ooxmemo_somCastObj *somTD_ooxmemo_somCastObj;
  189. typedef boolean   SOMLINK somTP_ooxmemo_somResetObj(ooxmemo *somSelf);
  190. typedef somTP_ooxmemo_somResetObj *somTD_ooxmemo_somResetObj;
  191. typedef void   SOMLINK somTP_ooxmemo_somDispatchV(ooxmemo *somSelf, 
  192.         somId methodId, 
  193.         somId descriptor, 
  194.         va_list ap);
  195. typedef somTP_ooxmemo_somDispatchV *somTD_ooxmemo_somDispatchV;
  196. typedef long   SOMLINK somTP_ooxmemo_somDispatchL(ooxmemo *somSelf, 
  197.         somId methodId, 
  198.         somId descriptor, 
  199.         va_list ap);
  200. typedef somTP_ooxmemo_somDispatchL *somTD_ooxmemo_somDispatchL;
  201. typedef void*   SOMLINK somTP_ooxmemo_somDispatchA(ooxmemo *somSelf, 
  202.         somId methodId, 
  203.         somId descriptor, 
  204.         va_list ap);
  205. typedef somTP_ooxmemo_somDispatchA *somTD_ooxmemo_somDispatchA;
  206. typedef double   SOMLINK somTP_ooxmemo_somDispatchD(ooxmemo *somSelf, 
  207.         somId methodId, 
  208.         somId descriptor, 
  209.         va_list ap);
  210. typedef somTP_ooxmemo_somDispatchD *somTD_ooxmemo_somDispatchD;
  211. typedef SOMObject*   SOMLINK somTP_ooxmemo_somPrintSelf(ooxmemo *somSelf);
  212. typedef somTP_ooxmemo_somPrintSelf *somTD_ooxmemo_somPrintSelf;
  213. typedef void   SOMLINK somTP_ooxmemo_somDumpSelf(ooxmemo *somSelf, 
  214.         long level);
  215. typedef somTP_ooxmemo_somDumpSelf *somTD_ooxmemo_somDumpSelf;
  216. typedef void   SOMLINK somTP_ooxmemo_somDumpSelfInt(ooxmemo *somSelf, 
  217.         long level);
  218. typedef somTP_ooxmemo_somDumpSelfInt *somTD_ooxmemo_somDumpSelfInt;
  219. }
  220.  
  221. #endif /* ooxmemo_API */
  222.  
  223.  
  224. /*
  225.  * -- This emitter treats Method Tokens as Thunks by default.
  226.  * -- Use the sc modifier "nothunks" to change this default
  227.  */
  228. #undef somresolve_
  229. #define somresolve_(obj,mToken) ((somMethodProc*)((void)obj, mToken))
  230.  
  231. /*
  232.  * -- The C++ Wrapper Class for ooxmemo
  233.  */
  234. class ooxmemo : public ooxfield
  235. {
  236. public:
  237.  
  238. // ooxmemo::new creates the class object if necessary, and then uses somNewNoInit
  239. // to allocate memory and create the object. Initialization is in ctors.
  240. void *operator new(size_t)
  241. {
  242.    if (!_ooxmemo) ooxmemoNewClass(ooxmemo_MajorVersion,ooxmemo_MinorVersion);
  243.    return (void*)
  244.       SOM_Resolve(_ooxmemo,SOMClass,somNewNoInit)
  245.          ((SOMClass *)((void*)_ooxmemo));
  246. }
  247.  
  248. // ooxmemo::delete uses somDestruct.
  249. void operator delete(void * obj)
  250. {
  251.    if (obj && *(void**)obj) {
  252.       SOM_Resolve(obj,SOMObject,somFree)
  253.          ((SOMObject*)obj);
  254.    }
  255. }
  256.  
  257. ooxmemo& operator=(ooxmemo& fromObj)
  258. {
  259.    this->somDefaultAssign(0,(SOMObject*)((void*)&fromObj));
  260.    return *this;
  261. }
  262.  
  263. ooxmemo()
  264. {
  265.    if (*(void**)this != 
  266.        ((somParentMtabStructPtr)
  267.         (ooxmemoCClassData.parentMtab))->mtab)
  268.       return;
  269.    ((SOMObject*)((void*)this))->somDefaultInit(0);
  270. }
  271.  
  272. ooxmemo(ooxmemo* fromObj)
  273. {
  274.    if (*(void**)this != 
  275.        ((somParentMtabStructPtr)
  276.         (ooxmemoCClassData.parentMtab))->mtab)
  277.       return;
  278.    ((SOMObject*)((void*)this))->somDefaultCopyInit(0,((SOMObject*)((void*)fromObj)));
  279. }
  280.  
  281. #ifdef __IBMCPP__
  282. #pragma info(nocnv,nopar)
  283. #endif
  284. ooxmemo(const ooxmemo* fromObj)
  285. {
  286.    if (*(void**)this != 
  287.        ((somParentMtabStructPtr)
  288.         (ooxmemoCClassData.parentMtab))->mtab)
  289.       return;
  290.    ((SOMObject*)((void*)this))->somDefaultConstCopyInit(0,((SOMObject*)((void*)fromObj)));
  291. }
  292. #ifdef __IBMCPP__
  293. #pragma info(restore)
  294. #endif
  295.  
  296. ooxmemo(Environment *ev,string name) 
  297. {
  298.    define(ev,0,name);
  299. }
  300.  
  301.  
  302. /* initializer method: define */
  303. void   define(Environment *ev, 
  304.         somInitCtrl* ctrl, 
  305.         string name)
  306. {
  307.    SOM_ResolveD(this,ooxmemo,ooxmemo,define)
  308.     (this, ev,ctrl,name);
  309. }
  310.  
  311.  
  312. /*
  313.  * Reintroduce inherited methods
  314.  */
  315.  
  316. /* method: get_name */
  317. string   get_name(Environment *ev)
  318. {
  319.    return SOM_ResolveD(this,ooxmemo,ooxfield,get_name)
  320.     (this, ev);
  321. }
  322.  
  323.  
  324. /* method: get */
  325. string   get(Environment *ev)
  326. {
  327.    return SOM_ResolveD(this,ooxmemo,ooxfield,get)
  328.     (this, ev);
  329. }
  330.  
  331.  
  332. /* method: put */
  333. long   put(Environment *ev, 
  334.         string datum)
  335. {
  336.    return SOM_ResolveD(this,ooxmemo,ooxfield,put)
  337.     (this, ev,datum);
  338. }
  339.  
  340.  
  341. /* method: get_type */
  342. char   get_type(Environment *ev)
  343. {
  344.    return SOM_ResolveD(this,ooxmemo,ooxfield,get_type)
  345.     (this, ev);
  346. }
  347.  
  348.  
  349. /* method: get_length */
  350. short   get_length(Environment *ev)
  351. {
  352.    return SOM_ResolveD(this,ooxmemo,ooxfield,get_length)
  353.     (this, ev);
  354. }
  355.  
  356.  
  357. /* method: get_dec_point */
  358. short   get_dec_point(Environment *ev)
  359. {
  360.    return SOM_ResolveD(this,ooxmemo,ooxfield,get_dec_point)
  361.     (this, ev);
  362. }
  363.  
  364.  
  365. /* initializer method: somDefaultInit */
  366. void   somDefaultInit(som3InitCtrl* ctrl)
  367. {
  368.    SOM_ResolveD(this,ooxmemo,SOMObject,somDefaultInit)
  369.     (this,ctrl);
  370. }
  371.  
  372.  
  373. /* method: somUninit */
  374. void   somUninit()
  375. {
  376.    SOM_ResolveD(this,ooxmemo,SOMObject,somUninit)
  377.     (this);
  378. }
  379.  
  380.  
  381. /* method: somDestruct */
  382. void   somDestruct(octet doFree, 
  383.         som3DestructCtrl* ctrl)
  384. {
  385. /*
  386.  *  The default destructor for a SOM object. A nonzero <doFree>
  387.  *  indicates that the object storage should be freed by the
  388.  *  object's class (via somDeallocate) after uninitialization.
  389.  *  As with somDefaultInit, a null ctrl can be passed.
  390.  */
  391.    SOM_ResolveD(this,ooxmemo,SOMObject,somDestruct)
  392.     (this,doFree,ctrl);
  393. }
  394.  
  395.  
  396. /* initializer method: somDefaultCopyInit */
  397. void   somDefaultCopyInit(som3InitCtrl* ctrl, 
  398.         SOMObject* fromObj)
  399. {
  400. /*
  401.  *  A default copy constructor. Use this to make copies of objects for
  402.  *  calling methods with "by-value" argument semantics.
  403.  */
  404.    SOM_ResolveD(this,ooxmemo,SOMObject,somDefaultCopyInit)
  405.     (this,ctrl,fromObj);
  406. }
  407.  
  408.  
  409. /* method: somDefaultAssign */
  410. ooxmemo*  somDefaultAssign(som3AssignCtrl* ctrl, 
  411.         SOMObject* fromObj)
  412. {
  413. /*
  414.  *  A default assignment operator. Use this to "assign" the state of one
  415.  *  object to another.
  416.  */
  417.    return SOM_ResolveD(this,ooxmemo,SOMObject,somDefaultAssign)
  418.     (this,ctrl,fromObj);
  419. }
  420.  
  421.  
  422. /* initializer method: somDefaultConstCopyInit */
  423. void   somDefaultConstCopyInit(som3InitCtrl* ctrl, 
  424.         SOMObject* fromObj)
  425. {
  426. /*
  427.  *  A default copy constructor that uses a const fromObj.
  428.  */
  429.    SOM_ResolveD(this,ooxmemo,SOMObject,somDefaultConstCopyInit)
  430.     (this,ctrl,fromObj);
  431. }
  432.  
  433.  
  434. /* initializer method: somDefaultVCopyInit */
  435. void   somDefaultVCopyInit(som3InitCtrl* ctrl, 
  436.         SOMObject* fromObj)
  437. {
  438. /*
  439.  *  A default copy constructor that uses a volatile fromObj.
  440.  */
  441.    SOM_ResolveD(this,ooxmemo,SOMObject,somDefaultVCopyInit)
  442.     (this,ctrl,fromObj);
  443. }
  444.  
  445.  
  446. /* initializer method: somDefaultConstVCopyInit */
  447. void   somDefaultConstVCopyInit(som3InitCtrl* ctrl, 
  448.         SOMObject* fromObj)
  449. {
  450. /*
  451.  *  A default copy constructor that uses a const volatile fromObj.
  452.  */
  453.    SOM_ResolveD(this,ooxmemo,SOMObject,somDefaultConstVCopyInit)
  454.     (this,ctrl,fromObj);
  455. }
  456.  
  457.  
  458. /* method: somDefaultConstAssign */
  459. ooxmemo*  somDefaultConstAssign(som3AssignCtrl* ctrl, 
  460.         SOMObject* fromObj)
  461. {
  462. /*
  463.  *  A default assignment operator that uses a const fromObj.
  464.  */
  465.    return SOM_ResolveD(this,ooxmemo,SOMObject,somDefaultConstAssign)
  466.     (this,ctrl,fromObj);
  467. }
  468.  
  469.  
  470. /* method: somDefaultVAssign */
  471. ooxmemo*  somDefaultVAssign(som3AssignCtrl* ctrl, 
  472.         SOMObject* fromObj)
  473. {
  474. /*
  475.  *  A default assignment operator that uses a volatile fromObj.
  476.  */
  477.    return SOM_ResolveD(this,ooxmemo,SOMObject,somDefaultVAssign)
  478.     (this,ctrl,fromObj);
  479. }
  480.  
  481.  
  482. /* method: somDefaultConstVAssign */
  483. ooxmemo*  somDefaultConstVAssign(som3AssignCtrl* ctrl, 
  484.         SOMObject* fromObj)
  485. {
  486. /*
  487.  *  A default assignment operator that uses a const volatile fromObj.
  488.  */
  489.    return SOM_ResolveD(this,ooxmemo,SOMObject,somDefaultConstVAssign)
  490.     (this,ctrl,fromObj);
  491. }
  492.  
  493.  
  494. /* method: somInit */
  495. void   somInit()
  496. {
  497. /*
  498.  *  Obsolete but still supported. Override somDefaultInit instead of somInit.
  499.  */
  500.    SOM_ResolveD(this,ooxmemo,SOMObject,somInit)
  501.     (this);
  502. }
  503.  
  504.  
  505. /* method: somFree */
  506. void   somFree()
  507. {
  508. /*
  509.  *  Use as directed by framework implementations.
  510.  */
  511.    SOM_ResolveD(this,ooxmemo,SOMObject,somFree)
  512.     (this);
  513. }
  514.  
  515.  
  516. /* method: somGetClass */
  517. SOMClass*   somGetClass()
  518. {
  519. /*
  520.  *  Return the receiver's class.
  521.  */
  522.    return SOM_ResolveD(this,ooxmemo,SOMObject,somGetClass)
  523.     (this);
  524. }
  525.  
  526.  
  527. /* method: somGetClassName */
  528. string   somGetClassName()
  529. {
  530. /*
  531.  *  Return the name of the receiver's class.
  532.  */
  533.    return SOM_ResolveD(this,ooxmemo,SOMObject,somGetClassName)
  534.     (this);
  535. }
  536.  
  537.  
  538. /* method: somGetSize */
  539. long   somGetSize()
  540. {
  541. /*
  542.  *  Return the size of the receiver.
  543.  */
  544.    return SOM_ResolveD(this,ooxmemo,SOMObject,somGetSize)
  545.     (this);
  546. }
  547.  
  548.  
  549. /* method: somIsA */
  550. boolean   somIsA(SOMClass* aClassObj)
  551. {
  552. /*
  553.  *  Returns 1 (true) if the receiver responds to methods
  554.  *  introduced by <aClassObj>, and 0 (false) otherwise.
  555.  */
  556.    return SOM_ResolveD(this,ooxmemo,SOMObject,somIsA)
  557.     (this,aClassObj);
  558. }
  559.  
  560.  
  561. /* method: somIsInstanceOf */
  562. boolean   somIsInstanceOf(SOMClass* aClassObj)
  563. {
  564. /*
  565.  *  Returns 1 (true) if the receiver is an instance of
  566.  *  <aClassObj> and 0 (false) otherwise.
  567.  */
  568.    return SOM_ResolveD(this,ooxmemo,SOMObject,somIsInstanceOf)
  569.     (this,aClassObj);
  570. }
  571.  
  572.  
  573. /* method: somRespondsTo */
  574. boolean   somRespondsTo(somId mId)
  575. {
  576. /*
  577.  *  Returns 1 (true) if the indicated method can be invoked
  578.  *  on the receiver and 0 (false) otherwise.
  579.  */
  580.    return SOM_ResolveD(this,ooxmemo,SOMObject,somRespondsTo)
  581.     (this,mId);
  582. }
  583.  
  584.  
  585. /* va_list method: somDispatch */
  586.  
  587. /*
  588.  *  This method provides a generic, class-specific dispatch mechanism.
  589.  *  It accepts as input <retValue> a pointer to the memory area to be
  590.  *  loaded with the result of dispatching the method indicated by
  591.  *  <methodId> using the arguments in <ap>. <ap> contains the object
  592.  *  on which the method is to be invoked as the first argument.
  593.  */
  594. /* the va_list invocation form */
  595. boolean   ooxmemo_somDispatch(somToken* retValue, 
  596.         somId methodId, 
  597.         va_list ap)
  598. {return SOM_ResolveD(this,ooxmemo,SOMObject,somDispatch)
  599.     (this,retValue,methodId,ap);
  600. }
  601.  
  602. /* the varargs invocation form */
  603. boolean   somDispatch(somToken* retValue, 
  604.         somId methodId, 
  605.         ...)
  606. {
  607. /*
  608.  *  This method provides a generic, class-specific dispatch mechanism.
  609.  *  It accepts as input <retValue> a pointer to the memory area to be
  610.  *  loaded with the result of dispatching the method indicated by
  611.  *  <methodId> using the arguments in <ap>. <ap> contains the object
  612.  *  on which the method is to be invoked as the first argument.
  613.  */
  614.    va_list ap;
  615.    va_start(ap, methodId);
  616.    boolean __somResult = 
  617.       SOM_ResolveD(this,ooxmemo,SOMObject,somDispatch)
  618.     (this,retValue,methodId,ap);
  619.    va_end(ap);
  620.    return __somResult;
  621. }
  622.  
  623.  
  624. /* va_list method: somClassDispatch */
  625.  
  626. /*
  627.  *  Like somDispatch, but method resolution for static methods is done
  628.  *  according to the clsObj instance method table.
  629.  */
  630. /* the va_list invocation form */
  631. boolean   ooxmemo_somClassDispatch(SOMClass* clsObj, 
  632.         somToken* retValue, 
  633.         somId methodId, 
  634.         va_list ap)
  635. {return SOM_ResolveD(this,ooxmemo,SOMObject,somClassDispatch)
  636.     (this,clsObj,retValue,methodId,ap);
  637. }
  638.  
  639. /* the varargs invocation form */
  640. boolean   somClassDispatch(SOMClass* clsObj, 
  641.         somToken* retValue, 
  642.         somId methodId, 
  643.         ...)
  644. {
  645. /*
  646.  *  Like somDispatch, but method resolution for static methods is done
  647.  *  according to the clsObj instance method table.
  648.  */
  649.    va_list ap;
  650.    va_start(ap, methodId);
  651.    boolean __somResult = 
  652.       SOM_ResolveD(this,ooxmemo,SOMObject,somClassDispatch)
  653.     (this,clsObj,retValue,methodId,ap);
  654.    va_end(ap);
  655.    return __somResult;
  656. }
  657.  
  658.  
  659. /* method: somCastObj */
  660. boolean   somCastObj(SOMClass* cls)
  661. {
  662. /*
  663.  *  cast the receiving object to cls (which must be an ancestor of the
  664.  *  objects true class. Returns true on success.
  665.  */
  666.    return SOM_ResolveD(this,ooxmemo,SOMObject,somCastObj)
  667.     (this,cls);
  668. }
  669.  
  670.  
  671. /* method: somResetObj */
  672. boolean   somResetObj()
  673. {
  674. /*
  675.  *  reset an object to its true class. Returns true always.
  676.  */
  677.    return SOM_ResolveD(this,ooxmemo,SOMObject,somResetObj)
  678.     (this);
  679. }
  680.  
  681.  
  682. /* va_list method: somDispatchV */
  683.  
  684. /*
  685.  *  Obsolete. Use somDispatch instead.
  686.  */
  687. /* the va_list invocation form */
  688. void   ooxmemo_somDispatchV(somId methodId, 
  689.         somId descriptor, 
  690.         va_list ap)
  691. {   SOM_ResolveD(this,ooxmemo,SOMObject,somDispatchV)
  692.     (this,methodId,descriptor,ap);
  693. }
  694.  
  695. /* the varargs invocation form */
  696. void   somDispatchV(somId methodId, 
  697.         somId descriptor, 
  698.         ...)
  699. {
  700. /*
  701.  *  Obsolete. Use somDispatch instead.
  702.  */
  703.    va_list ap;
  704.    va_start(ap, descriptor);
  705.    SOM_ResolveD(this,ooxmemo,SOMObject,somDispatchV)
  706.     (this,methodId,descriptor,ap);
  707.    va_end(ap);
  708. }
  709.  
  710.  
  711. /* va_list method: somDispatchL */
  712.  
  713. /*
  714.  *  Obsolete. Use somDispatch instead.
  715.  */
  716. /* the va_list invocation form */
  717. long   ooxmemo_somDispatchL(somId methodId, 
  718.         somId descriptor, 
  719.         va_list ap)
  720. {return SOM_ResolveD(this,ooxmemo,SOMObject,somDispatchL)
  721.     (this,methodId,descriptor,ap);
  722. }
  723.  
  724. /* the varargs invocation form */
  725. long   somDispatchL(somId methodId, 
  726.         somId descriptor, 
  727.         ...)
  728. {
  729. /*
  730.  *  Obsolete. Use somDispatch instead.
  731.  */
  732.    va_list ap;
  733.    va_start(ap, descriptor);
  734.    long __somResult = 
  735.       SOM_ResolveD(this,ooxmemo,SOMObject,somDispatchL)
  736.     (this,methodId,descriptor,ap);
  737.    va_end(ap);
  738.    return __somResult;
  739. }
  740.  
  741.  
  742. /* va_list method: somDispatchA */
  743.  
  744. /*
  745.  *  Obsolete. Use somDispatch instead.
  746.  */
  747. /* the va_list invocation form */
  748. void*   ooxmemo_somDispatchA(somId methodId, 
  749.         somId descriptor, 
  750.         va_list ap)
  751. {return SOM_ResolveD(this,ooxmemo,SOMObject,somDispatchA)
  752.     (this,methodId,descriptor,ap);
  753. }
  754.  
  755. /* the varargs invocation form */
  756. void*   somDispatchA(somId methodId, 
  757.         somId descriptor, 
  758.         ...)
  759. {
  760. /*
  761.  *  Obsolete. Use somDispatch instead.
  762.  */
  763.    va_list ap;
  764.    va_start(ap, descriptor);
  765.    void* __somResult = 
  766.       SOM_ResolveD(this,ooxmemo,SOMObject,somDispatchA)
  767.     (this,methodId,descriptor,ap);
  768.    va_end(ap);
  769.    return __somResult;
  770. }
  771.  
  772.  
  773. /* va_list method: somDispatchD */
  774.  
  775. /*
  776.  *  Obsolete. Use somDispatch instead.
  777.  */
  778. /* the va_list invocation form */
  779. double   ooxmemo_somDispatchD(somId methodId, 
  780.         somId descriptor, 
  781.         va_list ap)
  782. {return SOM_ResolveD(this,ooxmemo,SOMObject,somDispatchD)
  783.     (this,methodId,descriptor,ap);
  784. }
  785.  
  786. /* the varargs invocation form */
  787. double   somDispatchD(somId methodId, 
  788.         somId descriptor, 
  789.         ...)
  790. {
  791. /*
  792.  *  Obsolete. Use somDispatch instead.
  793.  */
  794.    va_list ap;
  795.    va_start(ap, descriptor);
  796.    double __somResult = 
  797.       SOM_ResolveD(this,ooxmemo,SOMObject,somDispatchD)
  798.     (this,methodId,descriptor,ap);
  799.    va_end(ap);
  800.    return __somResult;
  801. }
  802.  
  803.  
  804. /* method: somPrintSelf */
  805. SOMObject*   somPrintSelf()
  806. {
  807. /*
  808.  *  Uses <SOMOutCharRoutine> to write a brief string with identifying
  809.  *  information about this object.  The default implementation just gives
  810.  *  the object's class name and its address in memory.
  811.  *  <self> is returned.
  812.  */
  813.    return SOM_ResolveD(this,ooxmemo,SOMObject,somPrintSelf)
  814.     (this);
  815. }
  816.  
  817.  
  818. /* method: somDumpSelf */
  819. void   somDumpSelf(long level)
  820. {
  821. /*
  822.  *  Uses <SOMOutCharRoutine> to write a detailed description of this object
  823.  *  and its current state.
  824.  * 
  825.  *  <level> indicates the nesting level for describing compound objects
  826.  *  it must be greater than or equal to zero.  All lines in the
  827.  *  description will be preceeded by <2*level> spaces.
  828.  * 
  829.  *  This routine only actually writes the data that concerns the object
  830.  *  as a whole, such as class, and uses <somDumpSelfInt> to describe
  831.  *  the object's current state.  This approach allows readable
  832.  *  descriptions of compound objects to be constructed.
  833.  * 
  834.  *  Generally it is not necessary to override this method, if it is
  835.  *  overriden it generally must be completely replaced.
  836.  */
  837.    SOM_ResolveD(this,ooxmemo,SOMObject,somDumpSelf)
  838.     (this,level);
  839. }
  840.  
  841.  
  842. /* method: somDumpSelfInt */
  843. void   somDumpSelfInt(long level)
  844. {
  845. /*
  846.  *  Uses <SOMOutCharRoutine> to write in the current state of this object.
  847.  *  Generally this method will need to be overridden.  When overriding
  848.  *  it, begin by calling the parent class form of this method and then
  849.  *  write in a description of your class's instance data. This will
  850.  *  result in a description of all the object's instance data going
  851.  *  from its root ancestor class to its specific class.
  852.  */
  853.    SOM_ResolveD(this,ooxmemo,SOMObject,somDumpSelfInt)
  854.     (this,level);
  855. }
  856.  
  857.  
  858.  
  859. };   /* ooxmemo */
  860.  
  861.  
  862.  
  863. #endif       /* SOM_ooxmemo_xh */
  864.