home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / wpentk.zip / WBPENTK4.DSK / IDOSTRK.IH < prev    next >
Text File  |  1994-10-07  |  75KB  |  2,047 lines
  1.  
  2. /*
  3.  * This file was generated by the SOM Compiler.
  4.  * FileName: ..\..\pentkt\h\idostrk.ih.
  5.  * Generated using:
  6.  *     SOM Precompiler somipc: 2.7
  7.  *     SOM Emitter emitih: 2.22
  8.  */
  9.  
  10. #ifndef SOM_IDOMStroke_ih
  11. #define SOM_IDOMStroke_ih
  12.  
  13. #pragma checkout(suspend)
  14.  
  15. /*
  16.  * Passthru lines: File: "C.ih", "before"
  17.  */
  18. #include <idocomm.h>
  19. #include <idoinker.h>
  20. #include <idoinkat.h>
  21.  
  22. #include <idostrk.h>
  23.  
  24. /*
  25.  * Set the scope of methods functions
  26.  */
  27. #ifndef SOM_Scope
  28. #ifdef __cplusplus
  29.   #define SOM_Scope extern "C"
  30. #else
  31.   #define SOM_Scope extern
  32. #endif  /* __cplusplus */
  33. #endif  /* SOM_Scope */
  34.  
  35. #ifndef SOM_CurrentClass
  36.     #define SOM_CurrentClass IDOMStrokeCClassData.parentMtab
  37. #endif  /* SOM_CurrentClass */
  38.  
  39. #define IDOMStroke_MaxNoMethods 1
  40.  
  41. /*
  42.  * Instance data
  43.  */
  44. typedef void IDOMStrokeData;
  45.  
  46. /*
  47.  * Begin stuff that only goes in the primary file
  48.  */
  49. #if (defined(IDOStroke_Class_Source) || defined(IDOMStroke_Class_Source) || defined(SOM_Module_idostrk_Source))
  50.  
  51. /*
  52.  * Trace/Debug macro
  53.  */
  54. #ifndef IDOMStrokeMethodDebug
  55.    #define IDOMStrokeMethodDebug(c,m) SOMMethodDebug(c,m)
  56. #endif  /* IDOMStrokeMethodDebug */
  57.  
  58. /*
  59.  * Current class macros for Instance and Meta classes.
  60.  */
  61. #undef SOMMeta
  62. #define SOMMeta M_IDOMStrokeCClassData.parentMtab
  63. #undef SOMInstance
  64. #define SOMInstance IDOMStrokeCClassData.parentMtab
  65.  
  66. #ifndef M_IDOMStroke_Class_Source
  67.    #define M_IDOMStroke_Class_Source
  68. #endif    /* M_IDOMStroke_Class_Source */
  69.  
  70. /*
  71.  * Generate the Apply Stubs.
  72.  */
  73. #pragma linkage(somAP_IDOMStrokeidoclsCreateStroke, system)
  74. static void SOMLINK somAP_IDOMStrokeidoclsCreateStroke(IDOMStroke *somSelf,
  75.         IDOStroke* *__retVal,
  76.         somMethodProc *__methodPtr,
  77.         va_list __ap)
  78. {
  79.     void *__somSelf = va_arg(__ap, void*);
  80.     Environment *ev = va_arg(__ap, Environment*);
  81.     PSTROKEDATA pStrokeBuf = va_arg(__ap, PSTROKEDATA);
  82.     PULONG pulBufLen = va_arg(__ap, PULONG);
  83.     HWND hwnd = va_arg(__ap, HWND);
  84.     ULONG flAuxData = va_arg(__ap, ULONG);
  85.  
  86.     *__retVal = ((somTD_IDOMStroke_idoclsCreateStroke) __methodPtr) (somSelf, ev, pStrokeBuf,pulBufLen,hwnd,flAuxData);
  87. }
  88.  
  89.  
  90. /*
  91.  * Initialize the class data structure
  92.  */
  93. struct IDOMStrokeClassDataStructure IDOMStrokeClassData = {(SOMAny *) NULL};
  94.  
  95. /*
  96.  * Define the C class data structure
  97.  */
  98. struct IDOMStrokeCClassDataStructure IDOMStrokeCClassData = {(somMethodTabs) NULL};
  99.  
  100. /*
  101.  * New Method: idoclsCreateStroke
  102.  */
  103. #pragma linkage(IDOMStrokeidoclsCreateStroke, system)
  104. SOM_Scope IDOStroke*  SOMLINK IDOMStrokeidoclsCreateStroke(IDOMStroke *somSelf, Environment *ev,
  105.         PSTROKEDATA pStrokeBuf,
  106.         PULONG pulBufLen,
  107.         HWND hwnd,
  108.         ULONG flAuxData);
  109. #ifndef somMN_idoclsCreateStroke_defined
  110. #define somMN_idoclsCreateStroke_defined
  111. static char *somMN_idoclsCreateStroke = "idoclsCreateStroke";
  112. static somId somId_idoclsCreateStroke = &somMN_idoclsCreateStroke;
  113. #endif  /* somMN_idoclsCreateStroke_defined */
  114. #ifndef somDS_idoclsCreateStroke_defined
  115. #define somDS_idoclsCreateStroke_defined
  116. static char *somDS_idoclsCreateStroke = somMD_IDOMStroke_idoclsCreateStroke;
  117. static somId somDI_idoclsCreateStroke = &somDS_idoclsCreateStroke;
  118. #endif  /* somDS_idoclsCreateStroke_defined */
  119. #pragma linkage(somRD_IDOMStrokeidoclsCreateStroke, system)
  120. static IDOStroke*  SOMLINK somRD_IDOMStrokeidoclsCreateStroke(IDOMStroke *somSelf, Environment *ev,
  121.         PSTROKEDATA pStrokeBuf,
  122.         PULONG pulBufLen,
  123.         HWND hwnd,
  124.         ULONG flAuxData)
  125. {
  126.     IDOStroke* __retVal;
  127.  
  128.     va_somDispatch(somSelf, (void **)&__retVal, somId_idoclsCreateStroke, somSelf , ev
  129.         ,pStrokeBuf,pulBufLen,hwnd,flAuxData);
  130.     return __retVal;
  131. }
  132.  
  133. /*
  134.  * Routines and Structures to create the class object
  135.  */
  136.  
  137. /*
  138.  * Declare the Static Methods table.
  139.  */
  140. static somStaticMethod_t IDOMStrokeSM[] = {
  141.     {    &IDOMStrokeClassData.idoclsCreateStroke,
  142.          &somId_idoclsCreateStroke,
  143.          &somDI_idoclsCreateStroke,
  144.          (somMethodProc *) IDOMStrokeidoclsCreateStroke,
  145.          (somMethodProc *) somRD_IDOMStrokeidoclsCreateStroke,
  146.          (somMethodProc *) somAP_IDOMStrokeidoclsCreateStroke    },
  147. };
  148.  
  149.  
  150. /*
  151.  *  Initializers for class Ids
  152.  */
  153. static char * somCN_IDOMStroke = "IDOMStroke";
  154. static char * somPCN_IDOMStroke_SOMClass = "SOMClass";
  155.  
  156. static somId somPCIDOMStroke[] = {
  157.     &somPCN_IDOMStroke_SOMClass,
  158. };
  159.  
  160. static somStaticClassInfo IDOMStrokeSCI = {
  161.     3, 1, 0, 0, 0, 0,
  162.     IDOMStroke_MajorVersion, IDOMStroke_MinorVersion,
  163.     0, IDOMStroke_MaxNoMethods, 1,
  164.     &somCN_IDOMStroke,
  165.     (somId) NULL, 1,
  166.     somPCIDOMStroke,
  167.     (somClassDataStructure *) &IDOMStrokeClassData,
  168.     (somCClassDataStructure *) &IDOMStrokeCClassData,
  169.     IDOMStrokeSM, (somOverrideMethod_t *) NULL,
  170.     (char *) NULL,
  171.     (somNonInternalData_t *) NULL,  (somProcMethods_t *) NULL,
  172.     (somVarargsFuncs_t *) NULL,
  173.     (somTP_somClassInitFunc *) NULL,
  174.     0,
  175.     0,  /* old style class, zero directinitclasses */
  176.     0, /* no directinitclasses */
  177.     0, /* number of methods */
  178.     0, /* methods of the class */
  179.     0, /* dataOffset1 */
  180.     0, /* dataOffset2 */
  181.     0, /* number of SelectInheritedMethods */
  182.     0, /* SelectInheritedMethods */
  183.     0, /* number of releaseorder entries */
  184.     0, /* ReleaseOrder */
  185.     0, /* number of migrated methods */
  186.     0, /* migrated method implementations */
  187.     0, /* number of initializers */
  188.     0, /* initializers */
  189.     0, /* used to identify a DTS class */
  190.     0, /* used to register dynamically computed info */
  191. };
  192.  
  193.  
  194. IDOMStroke * SOMLINK IDOMStrokeNewClass (integer4 somtmajorVersion,
  195.         integer4 somtminorVersion)
  196. {
  197.     SOMClassNewClass(SOMClass_MajorVersion,SOMClass_MinorVersion);    /* static reference */
  198.     return (somBuildClass(1,&IDOMStrokeSCI, somtmajorVersion, somtminorVersion));
  199. }
  200.  
  201. /*
  202.  * Functions for attributes.
  203.  */
  204.  
  205. #endif                   /* IDOMStroke_Class_Source */
  206. #pragma checkout(resume)
  207.  
  208. #endif       /* SOM_IDOMStroke_ih */
  209.  
  210. #ifndef SOM_IDOStroke_ih
  211. #define SOM_IDOStroke_ih
  212.  
  213. #pragma checkout(suspend)
  214.  
  215. /*
  216.  * Passthru lines: File: "C.ih", "before"
  217.  */
  218.  
  219.  
  220. #include <idostrk.h>
  221.  
  222. /*
  223.  * Set the scope of methods functions
  224.  */
  225. #ifndef SOM_Scope
  226. #ifdef __cplusplus
  227.   #define SOM_Scope extern "C"
  228. #else
  229.   #define SOM_Scope extern
  230. #endif  /* __cplusplus */
  231. #endif  /* SOM_Scope */
  232.  
  233. #ifndef SOM_CurrentClass
  234.     #define SOM_CurrentClass IDOStrokeCClassData.parentMtab
  235. #endif  /* SOM_CurrentClass */
  236.  
  237. #define IDOStroke_MaxNoMethods 29
  238.  
  239. /*
  240.  * Instance data
  241.  */
  242. typedef void IDOStrokeData;
  243.  
  244. /*
  245.  * Begin stuff that only goes in the primary file
  246.  */
  247. #if (defined(IDOStroke_Class_Source) || defined(SOM_Module_idostrk_Source))
  248.  
  249. /*
  250.  * Trace/Debug macro
  251.  */
  252. #ifndef IDOStrokeMethodDebug
  253.    #define IDOStrokeMethodDebug(c,m) SOMMethodDebug(c,m)
  254. #endif  /* IDOStrokeMethodDebug */
  255.  
  256. /*
  257.  * Current class macros for Instance and Meta classes.
  258.  */
  259. #undef SOMMeta
  260. #define SOMMeta M_IDOStrokeCClassData.parentMtab
  261. #undef SOMInstance
  262. #define SOMInstance IDOStrokeCClassData.parentMtab
  263.  
  264. #ifndef M_IDOStroke_Class_Source
  265.    #define M_IDOStroke_Class_Source
  266. #endif    /* M_IDOStroke_Class_Source */
  267.  
  268. /*
  269.  * Generate the Apply Stubs.
  270.  */
  271. #pragma linkage(somAP_IDOStrokeidoIsTap, system)
  272. static void SOMLINK somAP_IDOStrokeidoIsTap(IDOStroke *somSelf,
  273.         BOOL *__retVal,
  274.         somMethodProc *__methodPtr,
  275.         va_list __ap)
  276. {
  277.     void *__somSelf = va_arg(__ap, void*);
  278.     Environment *ev = va_arg(__ap, Environment*);
  279.     SOM_IgnoreWarning(__ap);
  280.  
  281.     *__retVal = ((somTD_IDOStroke_idoIsTap) __methodPtr) (somSelf, ev);
  282. }
  283.  
  284. #pragma linkage(somAP_IDOStrokeidoScale, system)
  285. static void SOMLINK somAP_IDOStrokeidoScale(IDOStroke *somSelf,
  286.         void *__retVal,
  287.         somMethodProc *__methodPtr,
  288.         va_list __ap)
  289. {
  290.     void *__somSelf = va_arg(__ap, void*);
  291.     Environment *ev = va_arg(__ap, Environment*);
  292.     ULONG ulScaleX = va_arg(__ap, ULONG);
  293.     ULONG ulScaleY = va_arg(__ap, ULONG);
  294.     SOM_IgnoreWarning(__retVal);
  295.  
  296.     ((somTD_IDOStroke_idoScale) __methodPtr) (somSelf, ev, ulScaleX,ulScaleY);
  297. }
  298.  
  299. #pragma linkage(somAP_IDOStrokeidoSetStrokeType, system)
  300. static void SOMLINK somAP_IDOStrokeidoSetStrokeType(IDOStroke *somSelf,
  301.         void *__retVal,
  302.         somMethodProc *__methodPtr,
  303.         va_list __ap)
  304. {
  305.     void *__somSelf = va_arg(__ap, void*);
  306.     Environment *ev = va_arg(__ap, Environment*);
  307.     ULONG ulStrokeType = va_arg(__ap, ULONG);
  308.     SOM_IgnoreWarning(__retVal);
  309.  
  310.     ((somTD_IDOStroke_idoSetStrokeType) __methodPtr) (somSelf, ev, ulStrokeType);
  311. }
  312.  
  313. #pragma linkage(somAP_IDOStrokeidoGetStrokeType, system)
  314. static void SOMLINK somAP_IDOStrokeidoGetStrokeType(IDOStroke *somSelf,
  315.         ULONG *__retVal,
  316.         somMethodProc *__methodPtr,
  317.         va_list __ap)
  318. {
  319.     void *__somSelf = va_arg(__ap, void*);
  320.     Environment *ev = va_arg(__ap, Environment*);
  321.     SOM_IgnoreWarning(__ap);
  322.  
  323.     *__retVal = ((somTD_IDOStroke_idoGetStrokeType) __methodPtr) (somSelf, ev);
  324. }
  325.  
  326. #pragma linkage(somAP_IDOStrokeidoSetStrokeData, system)
  327. static void SOMLINK somAP_IDOStrokeidoSetStrokeData(IDOStroke *somSelf,
  328.         void *__retVal,
  329.         somMethodProc *__methodPtr,
  330.         va_list __ap)
  331. {
  332.     void *__somSelf = va_arg(__ap, void*);
  333.     Environment *ev = va_arg(__ap, Environment*);
  334.     PSTROKEDATA pStrokeBuf = va_arg(__ap, PSTROKEDATA);
  335.     PULONG pulBufLen = va_arg(__ap, PULONG);
  336.     HWND hwnd = va_arg(__ap, HWND);
  337.     ULONG flAuxData = va_arg(__ap, ULONG);
  338.     SOM_IgnoreWarning(__retVal);
  339.  
  340.     ((somTD_IDOStroke_idoSetStrokeData) __methodPtr) (somSelf, ev, pStrokeBuf,pulBufLen,hwnd,flAuxData);
  341. }
  342.  
  343. #pragma linkage(somAP_IDOStrokeidoGetStrokeData, system)
  344. static void SOMLINK somAP_IDOStrokeidoGetStrokeData(IDOStroke *somSelf,
  345.         void *__retVal,
  346.         somMethodProc *__methodPtr,
  347.         va_list __ap)
  348. {
  349.     void *__somSelf = va_arg(__ap, void*);
  350.     Environment *ev = va_arg(__ap, Environment*);
  351.     PSTROKEDATA pStrokeBuf = va_arg(__ap, PSTROKEDATA);
  352.     PULONG pulBufLen = va_arg(__ap, PULONG);
  353.     HWND hwnd = va_arg(__ap, HWND);
  354.     ULONG flAuxData = va_arg(__ap, ULONG);
  355.     SOM_IgnoreWarning(__retVal);
  356.  
  357.     ((somTD_IDOStroke_idoGetStrokeData) __methodPtr) (somSelf, ev, pStrokeBuf,pulBufLen,hwnd,flAuxData);
  358. }
  359.  
  360. #pragma linkage(somAP_IDOStrokeidoGetSource, system)
  361. static void SOMLINK somAP_IDOStrokeidoGetSource(IDOStroke *somSelf,
  362.         ULONG *__retVal,
  363.         somMethodProc *__methodPtr,
  364.         va_list __ap)
  365. {
  366.     void *__somSelf = va_arg(__ap, void*);
  367.     Environment *ev = va_arg(__ap, Environment*);
  368.     SOM_IgnoreWarning(__ap);
  369.  
  370.     *__retVal = ((somTD_IDOStroke_idoGetSource) __methodPtr) (somSelf, ev);
  371. }
  372.  
  373. #pragma linkage(somAP_IDOStrokeidoGetSeq, system)
  374. static void SOMLINK somAP_IDOStrokeidoGetSeq(IDOStroke *somSelf,
  375.         ULONG *__retVal,
  376.         somMethodProc *__methodPtr,
  377.         va_list __ap)
  378. {
  379.     void *__somSelf = va_arg(__ap, void*);
  380.     Environment *ev = va_arg(__ap, Environment*);
  381.     SOM_IgnoreWarning(__ap);
  382.  
  383.     *__retVal = ((somTD_IDOStroke_idoGetSeq) __methodPtr) (somSelf, ev);
  384. }
  385.  
  386. #pragma linkage(somAP_IDOStrokeidoGetResolution, system)
  387. static void SOMLINK somAP_IDOStrokeidoGetResolution(IDOStroke *somSelf,
  388.         ULONG *__retVal,
  389.         somMethodProc *__methodPtr,
  390.         va_list __ap)
  391. {
  392.     void *__somSelf = va_arg(__ap, void*);
  393.     Environment *ev = va_arg(__ap, Environment*);
  394.     SOM_IgnoreWarning(__ap);
  395.  
  396.     *__retVal = ((somTD_IDOStroke_idoGetResolution) __methodPtr) (somSelf, ev);
  397. }
  398.  
  399. #pragma linkage(somAP_IDOStrokeidoGetSampleRate, system)
  400. static void SOMLINK somAP_IDOStrokeidoGetSampleRate(IDOStroke *somSelf,
  401.         ULONG *__retVal,
  402.         somMethodProc *__methodPtr,
  403.         va_list __ap)
  404. {
  405.     void *__somSelf = va_arg(__ap, void*);
  406.     Environment *ev = va_arg(__ap, Environment*);
  407.     SOM_IgnoreWarning(__ap);
  408.  
  409.     *__retVal = ((somTD_IDOStroke_idoGetSampleRate) __methodPtr) (somSelf, ev);
  410. }
  411.  
  412. #pragma linkage(somAP_IDOStrokeidoGetNumPoints, system)
  413. static void SOMLINK somAP_IDOStrokeidoGetNumPoints(IDOStroke *somSelf,
  414.         ULONG *__retVal,
  415.         somMethodProc *__methodPtr,
  416.         va_list __ap)
  417. {
  418.     void *__somSelf = va_arg(__ap, void*);
  419.     Environment *ev = va_arg(__ap, Environment*);
  420.     SOM_IgnoreWarning(__ap);
  421.  
  422.     *__retVal = ((somTD_IDOStroke_idoGetNumPoints) __methodPtr) (somSelf, ev);
  423. }
  424.  
  425. #pragma linkage(somAP_IDOStrokeidoGetStrokeFlags, system)
  426. static void SOMLINK somAP_IDOStrokeidoGetStrokeFlags(IDOStroke *somSelf,
  427.         ULONG *__retVal,
  428.         somMethodProc *__methodPtr,
  429.         va_list __ap)
  430. {
  431.     void *__somSelf = va_arg(__ap, void*);
  432.     Environment *ev = va_arg(__ap, Environment*);
  433.     SOM_IgnoreWarning(__ap);
  434.  
  435.     *__retVal = ((somTD_IDOStroke_idoGetStrokeFlags) __methodPtr) (somSelf, ev);
  436. }
  437.  
  438. #pragma linkage(somAP_IDOStrokeidoGetXExtent, system)
  439. static void SOMLINK somAP_IDOStrokeidoGetXExtent(IDOStroke *somSelf,
  440.         ULONG *__retVal,
  441.         somMethodProc *__methodPtr,
  442.         va_list __ap)
  443. {
  444.     void *__somSelf = va_arg(__ap, void*);
  445.     Environment *ev = va_arg(__ap, Environment*);
  446.     SOM_IgnoreWarning(__ap);
  447.  
  448.     *__retVal = ((somTD_IDOStroke_idoGetXExtent) __methodPtr) (somSelf, ev);
  449. }
  450.  
  451. #pragma linkage(somAP_IDOStrokeidoGetYExtent, system)
  452. static void SOMLINK somAP_IDOStrokeidoGetYExtent(IDOStroke *somSelf,
  453.         ULONG *__retVal,
  454.         somMethodProc *__methodPtr,
  455.         va_list __ap)
  456. {
  457.     void *__somSelf = va_arg(__ap, void*);
  458.     Environment *ev = va_arg(__ap, Environment*);
  459.     SOM_IgnoreWarning(__ap);
  460.  
  461.     *__retVal = ((somTD_IDOStroke_idoGetYExtent) __methodPtr) (somSelf, ev);
  462. }
  463.  
  464. #pragma linkage(somAP_IDOStrokeidoGetSensorResolution, system)
  465. static void SOMLINK somAP_IDOStrokeidoGetSensorResolution(IDOStroke *somSelf,
  466.         ULONG *__retVal,
  467.         somMethodProc *__methodPtr,
  468.         va_list __ap)
  469. {
  470.     void *__somSelf = va_arg(__ap, void*);
  471.     Environment *ev = va_arg(__ap, Environment*);
  472.     SOM_IgnoreWarning(__ap);
  473.  
  474.     *__retVal = ((somTD_IDOStroke_idoGetSensorResolution) __methodPtr) (somSelf, ev);
  475. }
  476.  
  477. #pragma linkage(somAP_IDOStrokeidoGetSensorXExtent, system)
  478. static void SOMLINK somAP_IDOStrokeidoGetSensorXExtent(IDOStroke *somSelf,
  479.         ULONG *__retVal,
  480.         somMethodProc *__methodPtr,
  481.         va_list __ap)
  482. {
  483.     void *__somSelf = va_arg(__ap, void*);
  484.     Environment *ev = va_arg(__ap, Environment*);
  485.     SOM_IgnoreWarning(__ap);
  486.  
  487.     *__retVal = ((somTD_IDOStroke_idoGetSensorXExtent) __methodPtr) (somSelf, ev);
  488. }
  489.  
  490. #pragma linkage(somAP_IDOStrokeidoGetSensorYExtent, system)
  491. static void SOMLINK somAP_IDOStrokeidoGetSensorYExtent(IDOStroke *somSelf,
  492.         ULONG *__retVal,
  493.         somMethodProc *__methodPtr,
  494.         va_list __ap)
  495. {
  496.     void *__somSelf = va_arg(__ap, void*);
  497.     Environment *ev = va_arg(__ap, Environment*);
  498.     SOM_IgnoreWarning(__ap);
  499.  
  500.     *__retVal = ((somTD_IDOStroke_idoGetSensorYExtent) __methodPtr) (somSelf, ev);
  501. }
  502.  
  503. #pragma linkage(somAP_IDOStrokeidoGetTimestamp, system)
  504. static void SOMLINK somAP_IDOStrokeidoGetTimestamp(IDOStroke *somSelf,
  505.         ULONG *__retVal,
  506.         somMethodProc *__methodPtr,
  507.         va_list __ap)
  508. {
  509.     void *__somSelf = va_arg(__ap, void*);
  510.     Environment *ev = va_arg(__ap, Environment*);
  511.     SOM_IgnoreWarning(__ap);
  512.  
  513.     *__retVal = ((somTD_IDOStroke_idoGetTimestamp) __methodPtr) (somSelf, ev);
  514. }
  515.  
  516. #pragma linkage(somAP_IDOStrokeidoGetDevTimestampRes, system)
  517. static void SOMLINK somAP_IDOStrokeidoGetDevTimestampRes(IDOStroke *somSelf,
  518.         ULONG *__retVal,
  519.         somMethodProc *__methodPtr,
  520.         va_list __ap)
  521. {
  522.     void *__somSelf = va_arg(__ap, void*);
  523.     Environment *ev = va_arg(__ap, Environment*);
  524.     SOM_IgnoreWarning(__ap);
  525.  
  526.     *__retVal = ((somTD_IDOStroke_idoGetDevTimestampRes) __methodPtr) (somSelf, ev);
  527. }
  528.  
  529. #pragma linkage(somAP_IDOStrokeidoSetInkColor, system)
  530. static void SOMLINK somAP_IDOStrokeidoSetInkColor(IDOStroke *somSelf,
  531.         void *__retVal,
  532.         somMethodProc *__methodPtr,
  533.         va_list __ap)
  534. {
  535.     void *__somSelf = va_arg(__ap, void*);
  536.     Environment *ev = va_arg(__ap, Environment*);
  537.     ULONG ulColor = va_arg(__ap, ULONG);
  538.     SOM_IgnoreWarning(__retVal);
  539.  
  540.     ((somTD_IDOStroke_idoSetInkColor) __methodPtr) (somSelf, ev, ulColor);
  541. }
  542.  
  543. #pragma linkage(somAP_IDOStrokeidoGetInkColor, system)
  544. static void SOMLINK somAP_IDOStrokeidoGetInkColor(IDOStroke *somSelf,
  545.         ULONG *__retVal,
  546.         somMethodProc *__methodPtr,
  547.         va_list __ap)
  548. {
  549.     void *__somSelf = va_arg(__ap, void*);
  550.     Environment *ev = va_arg(__ap, Environment*);
  551.     SOM_IgnoreWarning(__ap);
  552.  
  553.     *__retVal = ((somTD_IDOStroke_idoGetInkColor) __methodPtr) (somSelf, ev);
  554. }
  555.  
  556. #pragma linkage(somAP_IDOStrokeidoSetInkWidth, system)
  557. static void SOMLINK somAP_IDOStrokeidoSetInkWidth(IDOStroke *somSelf,
  558.         void *__retVal,
  559.         somMethodProc *__methodPtr,
  560.         va_list __ap)
  561. {
  562.     void *__somSelf = va_arg(__ap, void*);
  563.     Environment *ev = va_arg(__ap, Environment*);
  564.     ULONG ulWidth = va_arg(__ap, ULONG);
  565.     SOM_IgnoreWarning(__retVal);
  566.  
  567.     ((somTD_IDOStroke_idoSetInkWidth) __methodPtr) (somSelf, ev, ulWidth);
  568. }
  569.  
  570. #pragma linkage(somAP_IDOStrokeidoGetInkWidth, system)
  571. static void SOMLINK somAP_IDOStrokeidoGetInkWidth(IDOStroke *somSelf,
  572.         ULONG *__retVal,
  573.         somMethodProc *__methodPtr,
  574.         va_list __ap)
  575. {
  576.     void *__somSelf = va_arg(__ap, void*);
  577.     Environment *ev = va_arg(__ap, Environment*);
  578.     SOM_IgnoreWarning(__ap);
  579.  
  580.     *__retVal = ((somTD_IDOStroke_idoGetInkWidth) __methodPtr) (somSelf, ev);
  581. }
  582.  
  583. #pragma linkage(somAP_IDOStrokeidoSetInkMix, system)
  584. static void SOMLINK somAP_IDOStrokeidoSetInkMix(IDOStroke *somSelf,
  585.         void *__retVal,
  586.         somMethodProc *__methodPtr,
  587.         va_list __ap)
  588. {
  589.     void *__somSelf = va_arg(__ap, void*);
  590.     Environment *ev = va_arg(__ap, Environment*);
  591.     ULONG ulMix = va_arg(__ap, ULONG);
  592.     SOM_IgnoreWarning(__retVal);
  593.  
  594.     ((somTD_IDOStroke_idoSetInkMix) __methodPtr) (somSelf, ev, ulMix);
  595. }
  596.  
  597. #pragma linkage(somAP_IDOStrokeidoGetInkMix, system)
  598. static void SOMLINK somAP_IDOStrokeidoGetInkMix(IDOStroke *somSelf,
  599.         ULONG *__retVal,
  600.         somMethodProc *__methodPtr,
  601.         va_list __ap)
  602. {
  603.     void *__somSelf = va_arg(__ap, void*);
  604.     Environment *ev = va_arg(__ap, Environment*);
  605.     SOM_IgnoreWarning(__ap);
  606.  
  607.     *__retVal = ((somTD_IDOStroke_idoGetInkMix) __methodPtr) (somSelf, ev);
  608. }
  609.  
  610. #pragma linkage(somAP_IDOStrokeidoSetInkLineType, system)
  611. static void SOMLINK somAP_IDOStrokeidoSetInkLineType(IDOStroke *somSelf,
  612.         void *__retVal,
  613.         somMethodProc *__methodPtr,
  614.         va_list __ap)
  615. {
  616.     void *__somSelf = va_arg(__ap, void*);
  617.     Environment *ev = va_arg(__ap, Environment*);
  618.     ULONG ulLineStyle = va_arg(__ap, ULONG);
  619.     SOM_IgnoreWarning(__retVal);
  620.  
  621.     ((somTD_IDOStroke_idoSetInkLineType) __methodPtr) (somSelf, ev, ulLineStyle);
  622. }
  623.  
  624. #pragma linkage(somAP_IDOStrokeidoGetInkLineType, system)
  625. static void SOMLINK somAP_IDOStrokeidoGetInkLineType(IDOStroke *somSelf,
  626.         ULONG *__retVal,
  627.         somMethodProc *__methodPtr,
  628.         va_list __ap)
  629. {
  630.     void *__somSelf = va_arg(__ap, void*);
  631.     Environment *ev = va_arg(__ap, Environment*);
  632.     SOM_IgnoreWarning(__ap);
  633.  
  634.     *__retVal = ((somTD_IDOStroke_idoGetInkLineType) __methodPtr) (somSelf, ev);
  635. }
  636.  
  637. #pragma linkage(somAP_IDOStrokeidoGetScaledData, system)
  638. static void SOMLINK somAP_IDOStrokeidoGetScaledData(IDOStroke *somSelf,
  639.         void *__retVal,
  640.         somMethodProc *__methodPtr,
  641.         va_list __ap)
  642. {
  643.     void *__somSelf = va_arg(__ap, void*);
  644.     Environment *ev = va_arg(__ap, Environment*);
  645.     PSTROKEDATA pStrokeBuf = va_arg(__ap, PSTROKEDATA);
  646.     PULONG pulBufLen = va_arg(__ap, PULONG);
  647.     HWND hwnd = va_arg(__ap, HWND);
  648.     ULONG flAuxData = va_arg(__ap, ULONG);
  649.     SOM_IgnoreWarning(__retVal);
  650.  
  651.     ((somTD_IDOStroke_idoGetScaledData) __methodPtr) (somSelf, ev, pStrokeBuf,pulBufLen,hwnd,flAuxData);
  652. }
  653.  
  654. #pragma linkage(somAP_IDOStrokeidoGetScaledPoints, system)
  655. static void SOMLINK somAP_IDOStrokeidoGetScaledPoints(IDOStroke *somSelf,
  656.         void *__retVal,
  657.         somMethodProc *__methodPtr,
  658.         va_list __ap)
  659. {
  660.     void *__somSelf = va_arg(__ap, void*);
  661.     Environment *ev = va_arg(__ap, Environment*);
  662.     PULONG pulNumPoints = va_arg(__ap, PULONG);
  663.     PPOINTL pPoints = va_arg(__ap, PPOINTL);
  664.     PULONG pulBufLen = va_arg(__ap, PULONG);
  665.     SOM_IgnoreWarning(__retVal);
  666.  
  667.     ((somTD_IDOStroke_idoGetScaledPoints) __methodPtr) (somSelf, ev, pulNumPoints,pPoints,pulBufLen);
  668. }
  669.  
  670.  
  671. /*
  672.  * Overridden method: somUninit
  673.  */
  674. #pragma linkage(IDOStrokesomUninit, system)
  675. SOM_Scope void  SOMLINK IDOStrokesomUninit(IDOStroke *somSelf);
  676. #ifndef somMN_somUninit_defined
  677. #define somMN_somUninit_defined
  678.    static char *somMN_somUninit = "somUninit";
  679.    static somId somId_somUninit = &somMN_somUninit;
  680. #endif  /* somMN_somUninit_defined */
  681. #define IDOStroke_parent_IDOCommon_somUninit(somSelf) \
  682.     ((SOM_ParentNumResolve(SOMObject, 1, IDOStrokeCClassData.parentMtab, somUninit)) \
  683.      (somSelf))
  684. #ifndef SOMGD_pmc_IDOCommon_somUninit
  685.   #ifdef parent_IDOCommon_somUninit
  686.      #undef parent_IDOCommon_somUninit
  687.      #define SOMGD_pmc_IDOCommon_somUninit 1
  688.   #else
  689.      #define parent_IDOCommon_somUninit IDOStroke_parent_IDOCommon_somUninit
  690.   #endif /* parent_IDOCommon_somUninit */
  691. #endif /* SOMGD_pmc_IDOCommon_somUninit */
  692. #ifndef parent_somUninit
  693.    #define parent_somUninit(somSelf) \
  694.     ((SOM_ParentNumResolve(SOMObject, 1, SOM_CurrentClass, somUninit)) \
  695.      (somSelf))
  696. #endif  /* parent_somUninit */
  697. #define IDOStroke_parents_somUninit(arg0) \
  698.   (void) IDOStroke_parent_IDOCommon_somUninit(arg0);
  699.  
  700. /*
  701.  * Overridden method: somFree
  702.  */
  703. #pragma linkage(IDOStrokesomFree, system)
  704. SOM_Scope void  SOMLINK IDOStrokesomFree(IDOStroke *somSelf);
  705. #ifndef somMN_somFree_defined
  706. #define somMN_somFree_defined
  707.    static char *somMN_somFree = "somFree";
  708.    static somId somId_somFree = &somMN_somFree;
  709. #endif  /* somMN_somFree_defined */
  710. #define IDOStroke_parent_IDOCommon_somFree(somSelf) \
  711.     ((SOM_ParentNumResolve(SOMObject, 1, IDOStrokeCClassData.parentMtab, somFree)) \
  712.      (somSelf))
  713. #ifndef SOMGD_pmc_IDOCommon_somFree
  714.   #ifdef parent_IDOCommon_somFree
  715.      #undef parent_IDOCommon_somFree
  716.      #define SOMGD_pmc_IDOCommon_somFree 1
  717.   #else
  718.      #define parent_IDOCommon_somFree IDOStroke_parent_IDOCommon_somFree
  719.   #endif /* parent_IDOCommon_somFree */
  720. #endif /* SOMGD_pmc_IDOCommon_somFree */
  721. #ifndef parent_somFree
  722.    #define parent_somFree(somSelf) \
  723.     ((SOM_ParentNumResolve(SOMObject, 1, SOM_CurrentClass, somFree)) \
  724.      (somSelf))
  725. #endif  /* parent_somFree */
  726. #define IDOStroke_parents_somFree(arg0) \
  727.   (void) IDOStroke_parent_IDOCommon_somFree(arg0);
  728.  
  729. /*
  730.  * Overridden method: idoDraw
  731.  */
  732. #pragma linkage(IDOStrokeidoDraw, system)
  733. SOM_Scope void  SOMLINK IDOStrokeidoDraw(IDOStroke *somSelf, Environment *ev,
  734.         HPS hps);
  735. #ifndef somMN_idoDraw_defined
  736. #define somMN_idoDraw_defined
  737.    static char *somMN_idoDraw = "idoDraw";
  738.    static somId somId_idoDraw = &somMN_idoDraw;
  739. #endif  /* somMN_idoDraw_defined */
  740. #define IDOStroke_parent_IDOCommon_idoDraw(somSelf,ev,hps) \
  741.     ((SOM_ParentNumResolve(IDOCommon, 1, IDOStrokeCClassData.parentMtab, idoDraw)) \
  742.      (somSelf,ev,hps))
  743. #ifndef SOMGD_pmc_IDOCommon_idoDraw
  744.   #ifdef parent_IDOCommon_idoDraw
  745.      #undef parent_IDOCommon_idoDraw
  746.      #define SOMGD_pmc_IDOCommon_idoDraw 1
  747.   #else
  748.      #define parent_IDOCommon_idoDraw IDOStroke_parent_IDOCommon_idoDraw
  749.   #endif /* parent_IDOCommon_idoDraw */
  750. #endif /* SOMGD_pmc_IDOCommon_idoDraw */
  751. #ifndef parent_idoDraw
  752.    #define parent_idoDraw(somSelf,ev,hps) \
  753.     ((SOM_ParentNumResolve(IDOCommon, 1, SOM_CurrentClass, idoDraw)) \
  754.      (somSelf,ev,hps))
  755. #endif  /* parent_idoDraw */
  756. #define IDOStroke_parents_idoDraw(arg0,arg1) \
  757.   (void) IDOStroke_parent_IDOCommon_idoDraw(arg0,arg1);
  758.  
  759. /*
  760.  * Overridden method: idoInkerDraw
  761.  */
  762. #pragma linkage(IDOStrokeidoInkerDraw, system)
  763. SOM_Scope void  SOMLINK IDOStrokeidoInkerDraw(IDOStroke *somSelf, Environment *ev,
  764.         IDOInker* pInkerObject);
  765. #ifndef somMN_idoInkerDraw_defined
  766. #define somMN_idoInkerDraw_defined
  767.    static char *somMN_idoInkerDraw = "idoInkerDraw";
  768.    static somId somId_idoInkerDraw = &somMN_idoInkerDraw;
  769. #endif  /* somMN_idoInkerDraw_defined */
  770. #define IDOStroke_parent_IDOCommon_idoInkerDraw(somSelf,ev,pInkerObject) \
  771.     ((SOM_ParentNumResolve(IDOCommon, 1, IDOStrokeCClassData.parentMtab, idoInkerDraw)) \
  772.      (somSelf,ev,pInkerObject))
  773. #ifndef SOMGD_pmc_IDOCommon_idoInkerDraw
  774.   #ifdef parent_IDOCommon_idoInkerDraw
  775.      #undef parent_IDOCommon_idoInkerDraw
  776.      #define SOMGD_pmc_IDOCommon_idoInkerDraw 1
  777.   #else
  778.      #define parent_IDOCommon_idoInkerDraw IDOStroke_parent_IDOCommon_idoInkerDraw
  779.   #endif /* parent_IDOCommon_idoInkerDraw */
  780. #endif /* SOMGD_pmc_IDOCommon_idoInkerDraw */
  781. #ifndef parent_idoInkerDraw
  782.    #define parent_idoInkerDraw(somSelf,ev,pInkerObject) \
  783.     ((SOM_ParentNumResolve(IDOCommon, 1, SOM_CurrentClass, idoInkerDraw)) \
  784.      (somSelf,ev,pInkerObject))
  785. #endif  /* parent_idoInkerDraw */
  786. #define IDOStroke_parents_idoInkerDraw(arg0,arg1) \
  787.   (void) IDOStroke_parent_IDOCommon_idoInkerDraw(arg0,arg1);
  788.  
  789. /*
  790.  * Overridden method: idoGetBoundingBox
  791.  */
  792. #pragma linkage(IDOStrokeidoGetBoundingBox, system)
  793. SOM_Scope void  SOMLINK IDOStrokeidoGetBoundingBox(IDOStroke *somSelf, Environment *ev,
  794.         PRECTL pBoundBox);
  795. #ifndef somMN_idoGetBoundingBox_defined
  796. #define somMN_idoGetBoundingBox_defined
  797.    static char *somMN_idoGetBoundingBox = "idoGetBoundingBox";
  798.    static somId somId_idoGetBoundingBox = &somMN_idoGetBoundingBox;
  799. #endif  /* somMN_idoGetBoundingBox_defined */
  800. #define IDOStroke_parent_IDOCommon_idoGetBoundingBox(somSelf,ev,pBoundBox) \
  801.     ((SOM_ParentNumResolve(IDOCommon, 1, IDOStrokeCClassData.parentMtab, idoGetBoundingBox)) \
  802.      (somSelf,ev,pBoundBox))
  803. #ifndef SOMGD_pmc_IDOCommon_idoGetBoundingBox
  804.   #ifdef parent_IDOCommon_idoGetBoundingBox
  805.      #undef parent_IDOCommon_idoGetBoundingBox
  806.      #define SOMGD_pmc_IDOCommon_idoGetBoundingBox 1
  807.   #else
  808.      #define parent_IDOCommon_idoGetBoundingBox IDOStroke_parent_IDOCommon_idoGetBoundingBox
  809.   #endif /* parent_IDOCommon_idoGetBoundingBox */
  810. #endif /* SOMGD_pmc_IDOCommon_idoGetBoundingBox */
  811. #ifndef parent_idoGetBoundingBox
  812.    #define parent_idoGetBoundingBox(somSelf,ev,pBoundBox) \
  813.     ((SOM_ParentNumResolve(IDOCommon, 1, SOM_CurrentClass, idoGetBoundingBox)) \
  814.      (somSelf,ev,pBoundBox))
  815. #endif  /* parent_idoGetBoundingBox */
  816. #define IDOStroke_parents_idoGetBoundingBox(arg0,arg1) \
  817.   (void) IDOStroke_parent_IDOCommon_idoGetBoundingBox(arg0,arg1);
  818.  
  819. /*
  820.  * Overridden method: idoSetInkAttr
  821.  */
  822. #pragma linkage(IDOStrokeidoSetInkAttr, system)
  823. SOM_Scope void  SOMLINK IDOStrokeidoSetInkAttr(IDOStroke *somSelf, Environment *ev,
  824.         IDOInkAttr* pInkAttrObject);
  825. #ifndef somMN_idoSetInkAttr_defined
  826. #define somMN_idoSetInkAttr_defined
  827.    static char *somMN_idoSetInkAttr = "idoSetInkAttr";
  828.    static somId somId_idoSetInkAttr = &somMN_idoSetInkAttr;
  829. #endif  /* somMN_idoSetInkAttr_defined */
  830. #define IDOStroke_parent_IDOCommon_idoSetInkAttr(somSelf,ev,pInkAttrObject) \
  831.     ((SOM_ParentNumResolve(IDOCommon, 1, IDOStrokeCClassData.parentMtab, idoSetInkAttr)) \
  832.      (somSelf,ev,pInkAttrObject))
  833. #ifndef SOMGD_pmc_IDOCommon_idoSetInkAttr
  834.   #ifdef parent_IDOCommon_idoSetInkAttr
  835.      #undef parent_IDOCommon_idoSetInkAttr
  836.      #define SOMGD_pmc_IDOCommon_idoSetInkAttr 1
  837.   #else
  838.      #define parent_IDOCommon_idoSetInkAttr IDOStroke_parent_IDOCommon_idoSetInkAttr
  839.   #endif /* parent_IDOCommon_idoSetInkAttr */
  840. #endif /* SOMGD_pmc_IDOCommon_idoSetInkAttr */
  841. #ifndef parent_idoSetInkAttr
  842.    #define parent_idoSetInkAttr(somSelf,ev,pInkAttrObject) \
  843.     ((SOM_ParentNumResolve(IDOCommon, 1, SOM_CurrentClass, idoSetInkAttr)) \
  844.      (somSelf,ev,pInkAttrObject))
  845. #endif  /* parent_idoSetInkAttr */
  846. #define IDOStroke_parents_idoSetInkAttr(arg0,arg1) \
  847.   (void) IDOStroke_parent_IDOCommon_idoSetInkAttr(arg0,arg1);
  848.  
  849. /*
  850.  * Overridden method: idoGetInkAttr
  851.  */
  852. #pragma linkage(IDOStrokeidoGetInkAttr, system)
  853. SOM_Scope IDOInkAttr*  SOMLINK IDOStrokeidoGetInkAttr(IDOStroke *somSelf, Environment *ev);
  854. #ifndef somMN_idoGetInkAttr_defined
  855. #define somMN_idoGetInkAttr_defined
  856.    static char *somMN_idoGetInkAttr = "idoGetInkAttr";
  857.    static somId somId_idoGetInkAttr = &somMN_idoGetInkAttr;
  858. #endif  /* somMN_idoGetInkAttr_defined */
  859. #define IDOStroke_parent_IDOCommon_idoGetInkAttr(somSelf,ev) \
  860.     ((SOM_ParentNumResolve(IDOCommon, 1, IDOStrokeCClassData.parentMtab, idoGetInkAttr)) \
  861.      (somSelf,ev))
  862. #ifndef SOMGD_pmc_IDOCommon_idoGetInkAttr
  863.   #ifdef parent_IDOCommon_idoGetInkAttr
  864.      #undef parent_IDOCommon_idoGetInkAttr
  865.      #define SOMGD_pmc_IDOCommon_idoGetInkAttr 1
  866.   #else
  867.      #define parent_IDOCommon_idoGetInkAttr IDOStroke_parent_IDOCommon_idoGetInkAttr
  868.   #endif /* parent_IDOCommon_idoGetInkAttr */
  869. #endif /* SOMGD_pmc_IDOCommon_idoGetInkAttr */
  870. #ifndef parent_idoGetInkAttr
  871.    #define parent_idoGetInkAttr(somSelf,ev) \
  872.     ((SOM_ParentNumResolve(IDOCommon, 1, SOM_CurrentClass, idoGetInkAttr)) \
  873.      (somSelf,ev))
  874. #endif  /* parent_idoGetInkAttr */
  875. #define IDOStroke_parents_idoGetInkAttr(arg0) \
  876.   (void) IDOStroke_parent_IDOCommon_idoGetInkAttr(arg0);
  877.  
  878. /*
  879.  * Overridden method: idoSetOffset
  880.  */
  881. #pragma linkage(IDOStrokeidoSetOffset, system)
  882. SOM_Scope void  SOMLINK IDOStrokeidoSetOffset(IDOStroke *somSelf, Environment *ev,
  883.         PPOINTL pPointl);
  884. #ifndef somMN_idoSetOffset_defined
  885. #define somMN_idoSetOffset_defined
  886.    static char *somMN_idoSetOffset = "idoSetOffset";
  887.    static somId somId_idoSetOffset = &somMN_idoSetOffset;
  888. #endif  /* somMN_idoSetOffset_defined */
  889. #define IDOStroke_parent_IDOCommon_idoSetOffset(somSelf,ev,pPointl) \
  890.     ((SOM_ParentNumResolve(IDOCommon, 1, IDOStrokeCClassData.parentMtab, idoSetOffset)) \
  891.      (somSelf,ev,pPointl))
  892. #ifndef SOMGD_pmc_IDOCommon_idoSetOffset
  893.   #ifdef parent_IDOCommon_idoSetOffset
  894.      #undef parent_IDOCommon_idoSetOffset
  895.      #define SOMGD_pmc_IDOCommon_idoSetOffset 1
  896.   #else
  897.      #define parent_IDOCommon_idoSetOffset IDOStroke_parent_IDOCommon_idoSetOffset
  898.   #endif /* parent_IDOCommon_idoSetOffset */
  899. #endif /* SOMGD_pmc_IDOCommon_idoSetOffset */
  900. #ifndef parent_idoSetOffset
  901.    #define parent_idoSetOffset(somSelf,ev,pPointl) \
  902.     ((SOM_ParentNumResolve(IDOCommon, 1, SOM_CurrentClass, idoSetOffset)) \
  903.      (somSelf,ev,pPointl))
  904. #endif  /* parent_idoSetOffset */
  905. #define IDOStroke_parents_idoSetOffset(arg0,arg1) \
  906.   (void) IDOStroke_parent_IDOCommon_idoSetOffset(arg0,arg1);
  907.  
  908. /*
  909.  * Overridden method: idoGetOffset
  910.  */
  911. #pragma linkage(IDOStrokeidoGetOffset, system)
  912. SOM_Scope void  SOMLINK IDOStrokeidoGetOffset(IDOStroke *somSelf, Environment *ev,
  913.         PPOINTL pPointl);
  914. #ifndef somMN_idoGetOffset_defined
  915. #define somMN_idoGetOffset_defined
  916.    static char *somMN_idoGetOffset = "idoGetOffset";
  917.    static somId somId_idoGetOffset = &somMN_idoGetOffset;
  918. #endif  /* somMN_idoGetOffset_defined */
  919. #define IDOStroke_parent_IDOCommon_idoGetOffset(somSelf,ev,pPointl) \
  920.     ((SOM_ParentNumResolve(IDOCommon, 1, IDOStrokeCClassData.parentMtab, idoGetOffset)) \
  921.      (somSelf,ev,pPointl))
  922. #ifndef SOMGD_pmc_IDOCommon_idoGetOffset
  923.   #ifdef parent_IDOCommon_idoGetOffset
  924.      #undef parent_IDOCommon_idoGetOffset
  925.      #define SOMGD_pmc_IDOCommon_idoGetOffset 1
  926.   #else
  927.      #define parent_IDOCommon_idoGetOffset IDOStroke_parent_IDOCommon_idoGetOffset
  928.   #endif /* parent_IDOCommon_idoGetOffset */
  929. #endif /* SOMGD_pmc_IDOCommon_idoGetOffset */
  930. #ifndef parent_idoGetOffset
  931.    #define parent_idoGetOffset(somSelf,ev,pPointl) \
  932.     ((SOM_ParentNumResolve(IDOCommon, 1, SOM_CurrentClass, idoGetOffset)) \
  933.      (somSelf,ev,pPointl))
  934. #endif  /* parent_idoGetOffset */
  935. #define IDOStroke_parents_idoGetOffset(arg0,arg1) \
  936.   (void) IDOStroke_parent_IDOCommon_idoGetOffset(arg0,arg1);
  937.  
  938. /*
  939.  * Overridden method: idoSetInkerData
  940.  */
  941. #pragma linkage(IDOStrokeidoSetInkerData, system)
  942. SOM_Scope void  SOMLINK IDOStrokeidoSetInkerData(IDOStroke *somSelf, Environment *ev,
  943.         PINKERDATA pNewInkerData,
  944.         PINKERDATA pOldInkerData);
  945. #ifndef somMN_idoSetInkerData_defined
  946. #define somMN_idoSetInkerData_defined
  947.    static char *somMN_idoSetInkerData = "idoSetInkerData";
  948.    static somId somId_idoSetInkerData = &somMN_idoSetInkerData;
  949. #endif  /* somMN_idoSetInkerData_defined */
  950. #define IDOStroke_parent_IDOCommon_idoSetInkerData(somSelf,ev,pNewInkerData,pOldInkerData) \
  951.     ((SOM_ParentNumResolve(IDOCommon, 1, IDOStrokeCClassData.parentMtab, idoSetInkerData)) \
  952.      (somSelf,ev,pNewInkerData,pOldInkerData))
  953. #ifndef SOMGD_pmc_IDOCommon_idoSetInkerData
  954.   #ifdef parent_IDOCommon_idoSetInkerData
  955.      #undef parent_IDOCommon_idoSetInkerData
  956.      #define SOMGD_pmc_IDOCommon_idoSetInkerData 1
  957.   #else
  958.      #define parent_IDOCommon_idoSetInkerData IDOStroke_parent_IDOCommon_idoSetInkerData
  959.   #endif /* parent_IDOCommon_idoSetInkerData */
  960. #endif /* SOMGD_pmc_IDOCommon_idoSetInkerData */
  961. #ifndef parent_idoSetInkerData
  962.    #define parent_idoSetInkerData(somSelf,ev,pNewInkerData,pOldInkerData) \
  963.     ((SOM_ParentNumResolve(IDOCommon, 1, SOM_CurrentClass, idoSetInkerData)) \
  964.      (somSelf,ev,pNewInkerData,pOldInkerData))
  965. #endif  /* parent_idoSetInkerData */
  966. #define IDOStroke_parents_idoSetInkerData(arg0,arg1,arg2) \
  967.   (void) IDOStroke_parent_IDOCommon_idoSetInkerData(arg0,arg1,arg2);
  968.  
  969. /*
  970.  * Overridden method: idoGetInkerData
  971.  */
  972. #pragma linkage(IDOStrokeidoGetInkerData, system)
  973. SOM_Scope void  SOMLINK IDOStrokeidoGetInkerData(IDOStroke *somSelf, Environment *ev,
  974.         PINKERDATA pInkerData);
  975. #ifndef somMN_idoGetInkerData_defined
  976. #define somMN_idoGetInkerData_defined
  977.    static char *somMN_idoGetInkerData = "idoGetInkerData";
  978.    static somId somId_idoGetInkerData = &somMN_idoGetInkerData;
  979. #endif  /* somMN_idoGetInkerData_defined */
  980. #define IDOStroke_parent_IDOCommon_idoGetInkerData(somSelf,ev,pInkerData) \
  981.     ((SOM_ParentNumResolve(IDOCommon, 1, IDOStrokeCClassData.parentMtab, idoGetInkerData)) \
  982.      (somSelf,ev,pInkerData))
  983. #ifndef SOMGD_pmc_IDOCommon_idoGetInkerData
  984.   #ifdef parent_IDOCommon_idoGetInkerData
  985.      #undef parent_IDOCommon_idoGetInkerData
  986.      #define SOMGD_pmc_IDOCommon_idoGetInkerData 1
  987.   #else
  988.      #define parent_IDOCommon_idoGetInkerData IDOStroke_parent_IDOCommon_idoGetInkerData
  989.   #endif /* parent_IDOCommon_idoGetInkerData */
  990. #endif /* SOMGD_pmc_IDOCommon_idoGetInkerData */
  991. #ifndef parent_idoGetInkerData
  992.    #define parent_idoGetInkerData(somSelf,ev,pInkerData) \
  993.     ((SOM_ParentNumResolve(IDOCommon, 1, SOM_CurrentClass, idoGetInkerData)) \
  994.      (somSelf,ev,pInkerData))
  995. #endif  /* parent_idoGetInkerData */
  996. #define IDOStroke_parents_idoGetInkerData(arg0,arg1) \
  997.   (void) IDOStroke_parent_IDOCommon_idoGetInkerData(arg0,arg1);
  998.  
  999. /*
  1000.  * Initialize the class data structure
  1001.  */
  1002. struct IDOStrokeClassDataStructure IDOStrokeClassData = {(SOMAny *) NULL};
  1003.  
  1004. /*
  1005.  * Define the C class data structure
  1006.  */
  1007. struct IDOStrokeCClassDataStructure IDOStrokeCClassData = {(somMethodTabs) NULL};
  1008.  
  1009. /*
  1010.  * New Method: idoIsTap
  1011.  */
  1012. #pragma linkage(IDOStrokeidoIsTap, system)
  1013. SOM_Scope BOOL  SOMLINK IDOStrokeidoIsTap(IDOStroke *somSelf, Environment *ev);
  1014. #ifndef somMN_idoIsTap_defined
  1015. #define somMN_idoIsTap_defined
  1016. static char *somMN_idoIsTap = "idoIsTap";
  1017. static somId somId_idoIsTap = &somMN_idoIsTap;
  1018. #endif  /* somMN_idoIsTap_defined */
  1019. #ifndef somDS_idoIsTap_defined
  1020. #define somDS_idoIsTap_defined
  1021. static char *somDS_idoIsTap = somMD_IDOStroke_idoIsTap;
  1022. static somId somDI_idoIsTap = &somDS_idoIsTap;
  1023. #endif  /* somDS_idoIsTap_defined */
  1024. #pragma linkage(somRD_IDOStrokeidoIsTap, system)
  1025. static BOOL  SOMLINK somRD_IDOStrokeidoIsTap(IDOStroke *somSelf, Environment *ev)
  1026. {
  1027.     BOOL __retVal;
  1028.  
  1029.     va_somDispatch(somSelf, (void **)&__retVal, somId_idoIsTap, somSelf , ev
  1030.         );
  1031.     return __retVal;
  1032. }
  1033.  
  1034. /*
  1035.  * New Method: idoScale
  1036.  */
  1037. #pragma linkage(IDOStrokeidoScale, system)
  1038. SOM_Scope void  SOMLINK IDOStrokeidoScale(IDOStroke *somSelf, Environment *ev,
  1039.         ULONG ulScaleX,
  1040.         ULONG ulScaleY);
  1041. #ifndef somMN_idoScale_defined
  1042. #define somMN_idoScale_defined
  1043. static char *somMN_idoScale = "idoScale";
  1044. static somId somId_idoScale = &somMN_idoScale;
  1045. #endif  /* somMN_idoScale_defined */
  1046. #ifndef somDS_idoScale_defined
  1047. #define somDS_idoScale_defined
  1048. static char *somDS_idoScale = somMD_IDOStroke_idoScale;
  1049. static somId somDI_idoScale = &somDS_idoScale;
  1050. #endif  /* somDS_idoScale_defined */
  1051. #pragma linkage(somRD_IDOStrokeidoScale, system)
  1052. static void  SOMLINK somRD_IDOStrokeidoScale(IDOStroke *somSelf, Environment *ev,
  1053.         ULONG ulScaleX,
  1054.         ULONG ulScaleY)
  1055. {
  1056.     void* __retVal;
  1057.  
  1058.     va_somDispatch(somSelf, (void **)&__retVal, somId_idoScale, somSelf , ev
  1059.         ,ulScaleX,ulScaleY);
  1060. }
  1061.  
  1062. /*
  1063.  * New Method: idoSetStrokeType
  1064.  */
  1065. #pragma linkage(IDOStrokeidoSetStrokeType, system)
  1066. SOM_Scope void  SOMLINK IDOStrokeidoSetStrokeType(IDOStroke *somSelf, Environment *ev,
  1067.         ULONG ulStrokeType);
  1068. #ifndef somMN_idoSetStrokeType_defined
  1069. #define somMN_idoSetStrokeType_defined
  1070. static char *somMN_idoSetStrokeType = "idoSetStrokeType";
  1071. static somId somId_idoSetStrokeType = &somMN_idoSetStrokeType;
  1072. #endif  /* somMN_idoSetStrokeType_defined */
  1073. #ifndef somDS_idoSetStrokeType_defined
  1074. #define somDS_idoSetStrokeType_defined
  1075. static char *somDS_idoSetStrokeType = somMD_IDOStroke_idoSetStrokeType;
  1076. static somId somDI_idoSetStrokeType = &somDS_idoSetStrokeType;
  1077. #endif  /* somDS_idoSetStrokeType_defined */
  1078. #pragma linkage(somRD_IDOStrokeidoSetStrokeType, system)
  1079. static void  SOMLINK somRD_IDOStrokeidoSetStrokeType(IDOStroke *somSelf, Environment *ev,
  1080.         ULONG ulStrokeType)
  1081. {
  1082.     void* __retVal;
  1083.  
  1084.     va_somDispatch(somSelf, (void **)&__retVal, somId_idoSetStrokeType, somSelf , ev
  1085.         ,ulStrokeType);
  1086. }
  1087.  
  1088. /*
  1089.  * New Method: idoGetStrokeType
  1090.  */
  1091. #pragma linkage(IDOStrokeidoGetStrokeType, system)
  1092. SOM_Scope ULONG  SOMLINK IDOStrokeidoGetStrokeType(IDOStroke *somSelf, Environment *ev);
  1093. #ifndef somMN_idoGetStrokeType_defined
  1094. #define somMN_idoGetStrokeType_defined
  1095. static char *somMN_idoGetStrokeType = "idoGetStrokeType";
  1096. static somId somId_idoGetStrokeType = &somMN_idoGetStrokeType;
  1097. #endif  /* somMN_idoGetStrokeType_defined */
  1098. #ifndef somDS_idoGetStrokeType_defined
  1099. #define somDS_idoGetStrokeType_defined
  1100. static char *somDS_idoGetStrokeType = somMD_IDOStroke_idoGetStrokeType;
  1101. static somId somDI_idoGetStrokeType = &somDS_idoGetStrokeType;
  1102. #endif  /* somDS_idoGetStrokeType_defined */
  1103. #pragma linkage(somRD_IDOStrokeidoGetStrokeType, system)
  1104. static ULONG  SOMLINK somRD_IDOStrokeidoGetStrokeType(IDOStroke *somSelf, Environment *ev)
  1105. {
  1106.     ULONG __retVal;
  1107.  
  1108.     va_somDispatch(somSelf, (void **)&__retVal, somId_idoGetStrokeType, somSelf , ev
  1109.         );
  1110.     return __retVal;
  1111. }
  1112.  
  1113. /*
  1114.  * New Method: idoSetStrokeData
  1115.  */
  1116. #pragma linkage(IDOStrokeidoSetStrokeData, system)
  1117. SOM_Scope void  SOMLINK IDOStrokeidoSetStrokeData(IDOStroke *somSelf, Environment *ev,
  1118.         PSTROKEDATA pStrokeBuf,
  1119.         PULONG pulBufLen,
  1120.         HWND hwnd,
  1121.         ULONG flAuxData);
  1122. #ifndef somMN_idoSetStrokeData_defined
  1123. #define somMN_idoSetStrokeData_defined
  1124. static char *somMN_idoSetStrokeData = "idoSetStrokeData";
  1125. static somId somId_idoSetStrokeData = &somMN_idoSetStrokeData;
  1126. #endif  /* somMN_idoSetStrokeData_defined */
  1127. #ifndef somDS_idoSetStrokeData_defined
  1128. #define somDS_idoSetStrokeData_defined
  1129. static char *somDS_idoSetStrokeData = somMD_IDOStroke_idoSetStrokeData;
  1130. static somId somDI_idoSetStrokeData = &somDS_idoSetStrokeData;
  1131. #endif  /* somDS_idoSetStrokeData_defined */
  1132. #pragma linkage(somRD_IDOStrokeidoSetStrokeData, system)
  1133. static void  SOMLINK somRD_IDOStrokeidoSetStrokeData(IDOStroke *somSelf, Environment *ev,
  1134.         PSTROKEDATA pStrokeBuf,
  1135.         PULONG pulBufLen,
  1136.         HWND hwnd,
  1137.         ULONG flAuxData)
  1138. {
  1139.     void* __retVal;
  1140.  
  1141.     va_somDispatch(somSelf, (void **)&__retVal, somId_idoSetStrokeData, somSelf , ev
  1142.         ,pStrokeBuf,pulBufLen,hwnd,flAuxData);
  1143. }
  1144.  
  1145. /*
  1146.  * New Method: idoGetStrokeData
  1147.  */
  1148. #pragma linkage(IDOStrokeidoGetStrokeData, system)
  1149. SOM_Scope void  SOMLINK IDOStrokeidoGetStrokeData(IDOStroke *somSelf, Environment *ev,
  1150.         PSTROKEDATA pStrokeBuf,
  1151.         PULONG pulBufLen,
  1152.         HWND hwnd,
  1153.         ULONG flAuxData);
  1154. #ifndef somMN_idoGetStrokeData_defined
  1155. #define somMN_idoGetStrokeData_defined
  1156. static char *somMN_idoGetStrokeData = "idoGetStrokeData";
  1157. static somId somId_idoGetStrokeData = &somMN_idoGetStrokeData;
  1158. #endif  /* somMN_idoGetStrokeData_defined */
  1159. #ifndef somDS_idoGetStrokeData_defined
  1160. #define somDS_idoGetStrokeData_defined
  1161. static char *somDS_idoGetStrokeData = somMD_IDOStroke_idoGetStrokeData;
  1162. static somId somDI_idoGetStrokeData = &somDS_idoGetStrokeData;
  1163. #endif  /* somDS_idoGetStrokeData_defined */
  1164. #pragma linkage(somRD_IDOStrokeidoGetStrokeData, system)
  1165. static void  SOMLINK somRD_IDOStrokeidoGetStrokeData(IDOStroke *somSelf, Environment *ev,
  1166.         PSTROKEDATA pStrokeBuf,
  1167.         PULONG pulBufLen,
  1168.         HWND hwnd,
  1169.         ULONG flAuxData)
  1170. {
  1171.     void* __retVal;
  1172.  
  1173.     va_somDispatch(somSelf, (void **)&__retVal, somId_idoGetStrokeData, somSelf , ev
  1174.         ,pStrokeBuf,pulBufLen,hwnd,flAuxData);
  1175. }
  1176.  
  1177. /*
  1178.  * New Method: idoGetSource
  1179.  */
  1180. #pragma linkage(IDOStrokeidoGetSource, system)
  1181. SOM_Scope ULONG  SOMLINK IDOStrokeidoGetSource(IDOStroke *somSelf, Environment *ev);
  1182. #ifndef somMN_idoGetSource_defined
  1183. #define somMN_idoGetSource_defined
  1184. static char *somMN_idoGetSource = "idoGetSource";
  1185. static somId somId_idoGetSource = &somMN_idoGetSource;
  1186. #endif  /* somMN_idoGetSource_defined */
  1187. #ifndef somDS_idoGetSource_defined
  1188. #define somDS_idoGetSource_defined
  1189. static char *somDS_idoGetSource = somMD_IDOStroke_idoGetSource;
  1190. static somId somDI_idoGetSource = &somDS_idoGetSource;
  1191. #endif  /* somDS_idoGetSource_defined */
  1192. #pragma linkage(somRD_IDOStrokeidoGetSource, system)
  1193. static ULONG  SOMLINK somRD_IDOStrokeidoGetSource(IDOStroke *somSelf, Environment *ev)
  1194. {
  1195.     ULONG __retVal;
  1196.  
  1197.     va_somDispatch(somSelf, (void **)&__retVal, somId_idoGetSource, somSelf , ev
  1198.         );
  1199.     return __retVal;
  1200. }
  1201.  
  1202. /*
  1203.  * New Method: idoGetSeq
  1204.  */
  1205. #pragma linkage(IDOStrokeidoGetSeq, system)
  1206. SOM_Scope ULONG  SOMLINK IDOStrokeidoGetSeq(IDOStroke *somSelf, Environment *ev);
  1207. #ifndef somMN_idoGetSeq_defined
  1208. #define somMN_idoGetSeq_defined
  1209. static char *somMN_idoGetSeq = "idoGetSeq";
  1210. static somId somId_idoGetSeq = &somMN_idoGetSeq;
  1211. #endif  /* somMN_idoGetSeq_defined */
  1212. #ifndef somDS_idoGetSeq_defined
  1213. #define somDS_idoGetSeq_defined
  1214. static char *somDS_idoGetSeq = somMD_IDOStroke_idoGetSeq;
  1215. static somId somDI_idoGetSeq = &somDS_idoGetSeq;
  1216. #endif  /* somDS_idoGetSeq_defined */
  1217. #pragma linkage(somRD_IDOStrokeidoGetSeq, system)
  1218. static ULONG  SOMLINK somRD_IDOStrokeidoGetSeq(IDOStroke *somSelf, Environment *ev)
  1219. {
  1220.     ULONG __retVal;
  1221.  
  1222.     va_somDispatch(somSelf, (void **)&__retVal, somId_idoGetSeq, somSelf , ev
  1223.         );
  1224.     return __retVal;
  1225. }
  1226.  
  1227. /*
  1228.  * New Method: idoGetResolution
  1229.  */
  1230. #pragma linkage(IDOStrokeidoGetResolution, system)
  1231. SOM_Scope ULONG  SOMLINK IDOStrokeidoGetResolution(IDOStroke *somSelf, Environment *ev);
  1232. #ifndef somMN_idoGetResolution_defined
  1233. #define somMN_idoGetResolution_defined
  1234. static char *somMN_idoGetResolution = "idoGetResolution";
  1235. static somId somId_idoGetResolution = &somMN_idoGetResolution;
  1236. #endif  /* somMN_idoGetResolution_defined */
  1237. #ifndef somDS_idoGetResolution_defined
  1238. #define somDS_idoGetResolution_defined
  1239. static char *somDS_idoGetResolution = somMD_IDOStroke_idoGetResolution;
  1240. static somId somDI_idoGetResolution = &somDS_idoGetResolution;
  1241. #endif  /* somDS_idoGetResolution_defined */
  1242. #pragma linkage(somRD_IDOStrokeidoGetResolution, system)
  1243. static ULONG  SOMLINK somRD_IDOStrokeidoGetResolution(IDOStroke *somSelf, Environment *ev)
  1244. {
  1245.     ULONG __retVal;
  1246.  
  1247.     va_somDispatch(somSelf, (void **)&__retVal, somId_idoGetResolution, somSelf , ev
  1248.         );
  1249.     return __retVal;
  1250. }
  1251.  
  1252. /*
  1253.  * New Method: idoGetSampleRate
  1254.  */
  1255. #pragma linkage(IDOStrokeidoGetSampleRate, system)
  1256. SOM_Scope ULONG  SOMLINK IDOStrokeidoGetSampleRate(IDOStroke *somSelf, Environment *ev);
  1257. #ifndef somMN_idoGetSampleRate_defined
  1258. #define somMN_idoGetSampleRate_defined
  1259. static char *somMN_idoGetSampleRate = "idoGetSampleRate";
  1260. static somId somId_idoGetSampleRate = &somMN_idoGetSampleRate;
  1261. #endif  /* somMN_idoGetSampleRate_defined */
  1262. #ifndef somDS_idoGetSampleRate_defined
  1263. #define somDS_idoGetSampleRate_defined
  1264. static char *somDS_idoGetSampleRate = somMD_IDOStroke_idoGetSampleRate;
  1265. static somId somDI_idoGetSampleRate = &somDS_idoGetSampleRate;
  1266. #endif  /* somDS_idoGetSampleRate_defined */
  1267. #pragma linkage(somRD_IDOStrokeidoGetSampleRate, system)
  1268. static ULONG  SOMLINK somRD_IDOStrokeidoGetSampleRate(IDOStroke *somSelf, Environment *ev)
  1269. {
  1270.     ULONG __retVal;
  1271.  
  1272.     va_somDispatch(somSelf, (void **)&__retVal, somId_idoGetSampleRate, somSelf , ev
  1273.         );
  1274.     return __retVal;
  1275. }
  1276.  
  1277. /*
  1278.  * New Method: idoGetNumPoints
  1279.  */
  1280. #pragma linkage(IDOStrokeidoGetNumPoints, system)
  1281. SOM_Scope ULONG  SOMLINK IDOStrokeidoGetNumPoints(IDOStroke *somSelf, Environment *ev);
  1282. #ifndef somMN_idoGetNumPoints_defined
  1283. #define somMN_idoGetNumPoints_defined
  1284. static char *somMN_idoGetNumPoints = "idoGetNumPoints";
  1285. static somId somId_idoGetNumPoints = &somMN_idoGetNumPoints;
  1286. #endif  /* somMN_idoGetNumPoints_defined */
  1287. #ifndef somDS_idoGetNumPoints_defined
  1288. #define somDS_idoGetNumPoints_defined
  1289. static char *somDS_idoGetNumPoints = somMD_IDOStroke_idoGetNumPoints;
  1290. static somId somDI_idoGetNumPoints = &somDS_idoGetNumPoints;
  1291. #endif  /* somDS_idoGetNumPoints_defined */
  1292. #pragma linkage(somRD_IDOStrokeidoGetNumPoints, system)
  1293. static ULONG  SOMLINK somRD_IDOStrokeidoGetNumPoints(IDOStroke *somSelf, Environment *ev)
  1294. {
  1295.     ULONG __retVal;
  1296.  
  1297.     va_somDispatch(somSelf, (void **)&__retVal, somId_idoGetNumPoints, somSelf , ev
  1298.         );
  1299.     return __retVal;
  1300. }
  1301.  
  1302. /*
  1303.  * New Method: idoGetStrokeFlags
  1304.  */
  1305. #pragma linkage(IDOStrokeidoGetStrokeFlags, system)
  1306. SOM_Scope ULONG  SOMLINK IDOStrokeidoGetStrokeFlags(IDOStroke *somSelf, Environment *ev);
  1307. #ifndef somMN_idoGetStrokeFlags_defined
  1308. #define somMN_idoGetStrokeFlags_defined
  1309. static char *somMN_idoGetStrokeFlags = "idoGetStrokeFlags";
  1310. static somId somId_idoGetStrokeFlags = &somMN_idoGetStrokeFlags;
  1311. #endif  /* somMN_idoGetStrokeFlags_defined */
  1312. #ifndef somDS_idoGetStrokeFlags_defined
  1313. #define somDS_idoGetStrokeFlags_defined
  1314. static char *somDS_idoGetStrokeFlags = somMD_IDOStroke_idoGetStrokeFlags;
  1315. static somId somDI_idoGetStrokeFlags = &somDS_idoGetStrokeFlags;
  1316. #endif  /* somDS_idoGetStrokeFlags_defined */
  1317. #pragma linkage(somRD_IDOStrokeidoGetStrokeFlags, system)
  1318. static ULONG  SOMLINK somRD_IDOStrokeidoGetStrokeFlags(IDOStroke *somSelf, Environment *ev)
  1319. {
  1320.     ULONG __retVal;
  1321.  
  1322.     va_somDispatch(somSelf, (void **)&__retVal, somId_idoGetStrokeFlags, somSelf , ev
  1323.         );
  1324.     return __retVal;
  1325. }
  1326.  
  1327. /*
  1328.  * New Method: idoGetXExtent
  1329.  */
  1330. #pragma linkage(IDOStrokeidoGetXExtent, system)
  1331. SOM_Scope ULONG  SOMLINK IDOStrokeidoGetXExtent(IDOStroke *somSelf, Environment *ev);
  1332. #ifndef somMN_idoGetXExtent_defined
  1333. #define somMN_idoGetXExtent_defined
  1334. static char *somMN_idoGetXExtent = "idoGetXExtent";
  1335. static somId somId_idoGetXExtent = &somMN_idoGetXExtent;
  1336. #endif  /* somMN_idoGetXExtent_defined */
  1337. #ifndef somDS_idoGetXExtent_defined
  1338. #define somDS_idoGetXExtent_defined
  1339. static char *somDS_idoGetXExtent = somMD_IDOStroke_idoGetXExtent;
  1340. static somId somDI_idoGetXExtent = &somDS_idoGetXExtent;
  1341. #endif  /* somDS_idoGetXExtent_defined */
  1342. #pragma linkage(somRD_IDOStrokeidoGetXExtent, system)
  1343. static ULONG  SOMLINK somRD_IDOStrokeidoGetXExtent(IDOStroke *somSelf, Environment *ev)
  1344. {
  1345.     ULONG __retVal;
  1346.  
  1347.     va_somDispatch(somSelf, (void **)&__retVal, somId_idoGetXExtent, somSelf , ev
  1348.         );
  1349.     return __retVal;
  1350. }
  1351.  
  1352. /*
  1353.  * New Method: idoGetYExtent
  1354.  */
  1355. #pragma linkage(IDOStrokeidoGetYExtent, system)
  1356. SOM_Scope ULONG  SOMLINK IDOStrokeidoGetYExtent(IDOStroke *somSelf, Environment *ev);
  1357. #ifndef somMN_idoGetYExtent_defined
  1358. #define somMN_idoGetYExtent_defined
  1359. static char *somMN_idoGetYExtent = "idoGetYExtent";
  1360. static somId somId_idoGetYExtent = &somMN_idoGetYExtent;
  1361. #endif  /* somMN_idoGetYExtent_defined */
  1362. #ifndef somDS_idoGetYExtent_defined
  1363. #define somDS_idoGetYExtent_defined
  1364. static char *somDS_idoGetYExtent = somMD_IDOStroke_idoGetYExtent;
  1365. static somId somDI_idoGetYExtent = &somDS_idoGetYExtent;
  1366. #endif  /* somDS_idoGetYExtent_defined */
  1367. #pragma linkage(somRD_IDOStrokeidoGetYExtent, system)
  1368. static ULONG  SOMLINK somRD_IDOStrokeidoGetYExtent(IDOStroke *somSelf, Environment *ev)
  1369. {
  1370.     ULONG __retVal;
  1371.  
  1372.     va_somDispatch(somSelf, (void **)&__retVal, somId_idoGetYExtent, somSelf , ev
  1373.         );
  1374.     return __retVal;
  1375. }
  1376.  
  1377. /*
  1378.  * New Method: idoGetSensorResolution
  1379.  */
  1380. #pragma linkage(IDOStrokeidoGetSensorResolution, system)
  1381. SOM_Scope ULONG  SOMLINK IDOStrokeidoGetSensorResolution(IDOStroke *somSelf, Environment *ev);
  1382. #ifndef somMN_idoGetSensorResolution_defined
  1383. #define somMN_idoGetSensorResolution_defined
  1384. static char *somMN_idoGetSensorResolution = "idoGetSensorResolution";
  1385. static somId somId_idoGetSensorResolution = &somMN_idoGetSensorResolution;
  1386. #endif  /* somMN_idoGetSensorResolution_defined */
  1387. #ifndef somDS_idoGetSensorResolution_defined
  1388. #define somDS_idoGetSensorResolution_defined
  1389. static char *somDS_idoGetSensorResolution = somMD_IDOStroke_idoGetSensorResolution;
  1390. static somId somDI_idoGetSensorResolution = &somDS_idoGetSensorResolution;
  1391. #endif  /* somDS_idoGetSensorResolution_defined */
  1392. #pragma linkage(somRD_IDOStrokeidoGetSensorResolution, system)
  1393. static ULONG  SOMLINK somRD_IDOStrokeidoGetSensorResolution(IDOStroke *somSelf, Environment *ev)
  1394. {
  1395.     ULONG __retVal;
  1396.  
  1397.     va_somDispatch(somSelf, (void **)&__retVal, somId_idoGetSensorResolution, somSelf , ev
  1398.         );
  1399.     return __retVal;
  1400. }
  1401.  
  1402. /*
  1403.  * New Method: idoGetSensorXExtent
  1404.  */
  1405. #pragma linkage(IDOStrokeidoGetSensorXExtent, system)
  1406. SOM_Scope ULONG  SOMLINK IDOStrokeidoGetSensorXExtent(IDOStroke *somSelf, Environment *ev);
  1407. #ifndef somMN_idoGetSensorXExtent_defined
  1408. #define somMN_idoGetSensorXExtent_defined
  1409. static char *somMN_idoGetSensorXExtent = "idoGetSensorXExtent";
  1410. static somId somId_idoGetSensorXExtent = &somMN_idoGetSensorXExtent;
  1411. #endif  /* somMN_idoGetSensorXExtent_defined */
  1412. #ifndef somDS_idoGetSensorXExtent_defined
  1413. #define somDS_idoGetSensorXExtent_defined
  1414. static char *somDS_idoGetSensorXExtent = somMD_IDOStroke_idoGetSensorXExtent;
  1415. static somId somDI_idoGetSensorXExtent = &somDS_idoGetSensorXExtent;
  1416. #endif  /* somDS_idoGetSensorXExtent_defined */
  1417. #pragma linkage(somRD_IDOStrokeidoGetSensorXExtent, system)
  1418. static ULONG  SOMLINK somRD_IDOStrokeidoGetSensorXExtent(IDOStroke *somSelf, Environment *ev)
  1419. {
  1420.     ULONG __retVal;
  1421.  
  1422.     va_somDispatch(somSelf, (void **)&__retVal, somId_idoGetSensorXExtent, somSelf , ev
  1423.         );
  1424.     return __retVal;
  1425. }
  1426.  
  1427. /*
  1428.  * New Method: idoGetSensorYExtent
  1429.  */
  1430. #pragma linkage(IDOStrokeidoGetSensorYExtent, system)
  1431. SOM_Scope ULONG  SOMLINK IDOStrokeidoGetSensorYExtent(IDOStroke *somSelf, Environment *ev);
  1432. #ifndef somMN_idoGetSensorYExtent_defined
  1433. #define somMN_idoGetSensorYExtent_defined
  1434. static char *somMN_idoGetSensorYExtent = "idoGetSensorYExtent";
  1435. static somId somId_idoGetSensorYExtent = &somMN_idoGetSensorYExtent;
  1436. #endif  /* somMN_idoGetSensorYExtent_defined */
  1437. #ifndef somDS_idoGetSensorYExtent_defined
  1438. #define somDS_idoGetSensorYExtent_defined
  1439. static char *somDS_idoGetSensorYExtent = somMD_IDOStroke_idoGetSensorYExtent;
  1440. static somId somDI_idoGetSensorYExtent = &somDS_idoGetSensorYExtent;
  1441. #endif  /* somDS_idoGetSensorYExtent_defined */
  1442. #pragma linkage(somRD_IDOStrokeidoGetSensorYExtent, system)
  1443. static ULONG  SOMLINK somRD_IDOStrokeidoGetSensorYExtent(IDOStroke *somSelf, Environment *ev)
  1444. {
  1445.     ULONG __retVal;
  1446.  
  1447.     va_somDispatch(somSelf, (void **)&__retVal, somId_idoGetSensorYExtent, somSelf , ev
  1448.         );
  1449.     return __retVal;
  1450. }
  1451.  
  1452. /*
  1453.  * New Method: idoGetTimestamp
  1454.  */
  1455. #pragma linkage(IDOStrokeidoGetTimestamp, system)
  1456. SOM_Scope ULONG  SOMLINK IDOStrokeidoGetTimestamp(IDOStroke *somSelf, Environment *ev);
  1457. #ifndef somMN_idoGetTimestamp_defined
  1458. #define somMN_idoGetTimestamp_defined
  1459. static char *somMN_idoGetTimestamp = "idoGetTimestamp";
  1460. static somId somId_idoGetTimestamp = &somMN_idoGetTimestamp;
  1461. #endif  /* somMN_idoGetTimestamp_defined */
  1462. #ifndef somDS_idoGetTimestamp_defined
  1463. #define somDS_idoGetTimestamp_defined
  1464. static char *somDS_idoGetTimestamp = somMD_IDOStroke_idoGetTimestamp;
  1465. static somId somDI_idoGetTimestamp = &somDS_idoGetTimestamp;
  1466. #endif  /* somDS_idoGetTimestamp_defined */
  1467. #pragma linkage(somRD_IDOStrokeidoGetTimestamp, system)
  1468. static ULONG  SOMLINK somRD_IDOStrokeidoGetTimestamp(IDOStroke *somSelf, Environment *ev)
  1469. {
  1470.     ULONG __retVal;
  1471.  
  1472.     va_somDispatch(somSelf, (void **)&__retVal, somId_idoGetTimestamp, somSelf , ev
  1473.         );
  1474.     return __retVal;
  1475. }
  1476.  
  1477. /*
  1478.  * New Method: idoGetDevTimestampRes
  1479.  */
  1480. #pragma linkage(IDOStrokeidoGetDevTimestampRes, system)
  1481. SOM_Scope ULONG  SOMLINK IDOStrokeidoGetDevTimestampRes(IDOStroke *somSelf, Environment *ev);
  1482. #ifndef somMN_idoGetDevTimestampRes_defined
  1483. #define somMN_idoGetDevTimestampRes_defined
  1484. static char *somMN_idoGetDevTimestampRes = "idoGetDevTimestampRes";
  1485. static somId somId_idoGetDevTimestampRes = &somMN_idoGetDevTimestampRes;
  1486. #endif  /* somMN_idoGetDevTimestampRes_defined */
  1487. #ifndef somDS_idoGetDevTimestampRes_defined
  1488. #define somDS_idoGetDevTimestampRes_defined
  1489. static char *somDS_idoGetDevTimestampRes = somMD_IDOStroke_idoGetDevTimestampRes;
  1490. static somId somDI_idoGetDevTimestampRes = &somDS_idoGetDevTimestampRes;
  1491. #endif  /* somDS_idoGetDevTimestampRes_defined */
  1492. #pragma linkage(somRD_IDOStrokeidoGetDevTimestampRes, system)
  1493. static ULONG  SOMLINK somRD_IDOStrokeidoGetDevTimestampRes(IDOStroke *somSelf, Environment *ev)
  1494. {
  1495.     ULONG __retVal;
  1496.  
  1497.     va_somDispatch(somSelf, (void **)&__retVal, somId_idoGetDevTimestampRes, somSelf , ev
  1498.         );
  1499.     return __retVal;
  1500. }
  1501.  
  1502. /*
  1503.  * New Method: idoSetInkColor
  1504.  */
  1505. #pragma linkage(IDOStrokeidoSetInkColor, system)
  1506. SOM_Scope void  SOMLINK IDOStrokeidoSetInkColor(IDOStroke *somSelf, Environment *ev,
  1507.         ULONG ulColor);
  1508. #ifndef somMN_idoSetInkColor_defined
  1509. #define somMN_idoSetInkColor_defined
  1510. static char *somMN_idoSetInkColor = "idoSetInkColor";
  1511. static somId somId_idoSetInkColor = &somMN_idoSetInkColor;
  1512. #endif  /* somMN_idoSetInkColor_defined */
  1513. #ifndef somDS_idoSetInkColor_defined
  1514. #define somDS_idoSetInkColor_defined
  1515. static char *somDS_idoSetInkColor = somMD_IDOStroke_idoSetInkColor;
  1516. static somId somDI_idoSetInkColor = &somDS_idoSetInkColor;
  1517. #endif  /* somDS_idoSetInkColor_defined */
  1518. #pragma linkage(somRD_IDOStrokeidoSetInkColor, system)
  1519. static void  SOMLINK somRD_IDOStrokeidoSetInkColor(IDOStroke *somSelf, Environment *ev,
  1520.         ULONG ulColor)
  1521. {
  1522.     void* __retVal;
  1523.  
  1524.     va_somDispatch(somSelf, (void **)&__retVal, somId_idoSetInkColor, somSelf , ev
  1525.         ,ulColor);
  1526. }
  1527.  
  1528. /*
  1529.  * New Method: idoGetInkColor
  1530.  */
  1531. #pragma linkage(IDOStrokeidoGetInkColor, system)
  1532. SOM_Scope ULONG  SOMLINK IDOStrokeidoGetInkColor(IDOStroke *somSelf, Environment *ev);
  1533. #ifndef somMN_idoGetInkColor_defined
  1534. #define somMN_idoGetInkColor_defined
  1535. static char *somMN_idoGetInkColor = "idoGetInkColor";
  1536. static somId somId_idoGetInkColor = &somMN_idoGetInkColor;
  1537. #endif  /* somMN_idoGetInkColor_defined */
  1538. #ifndef somDS_idoGetInkColor_defined
  1539. #define somDS_idoGetInkColor_defined
  1540. static char *somDS_idoGetInkColor = somMD_IDOStroke_idoGetInkColor;
  1541. static somId somDI_idoGetInkColor = &somDS_idoGetInkColor;
  1542. #endif  /* somDS_idoGetInkColor_defined */
  1543. #pragma linkage(somRD_IDOStrokeidoGetInkColor, system)
  1544. static ULONG  SOMLINK somRD_IDOStrokeidoGetInkColor(IDOStroke *somSelf, Environment *ev)
  1545. {
  1546.     ULONG __retVal;
  1547.  
  1548.     va_somDispatch(somSelf, (void **)&__retVal, somId_idoGetInkColor, somSelf , ev
  1549.         );
  1550.     return __retVal;
  1551. }
  1552.  
  1553. /*
  1554.  * New Method: idoSetInkWidth
  1555.  */
  1556. #pragma linkage(IDOStrokeidoSetInkWidth, system)
  1557. SOM_Scope void  SOMLINK IDOStrokeidoSetInkWidth(IDOStroke *somSelf, Environment *ev,
  1558.         ULONG ulWidth);
  1559. #ifndef somMN_idoSetInkWidth_defined
  1560. #define somMN_idoSetInkWidth_defined
  1561. static char *somMN_idoSetInkWidth = "idoSetInkWidth";
  1562. static somId somId_idoSetInkWidth = &somMN_idoSetInkWidth;
  1563. #endif  /* somMN_idoSetInkWidth_defined */
  1564. #ifndef somDS_idoSetInkWidth_defined
  1565. #define somDS_idoSetInkWidth_defined
  1566. static char *somDS_idoSetInkWidth = somMD_IDOStroke_idoSetInkWidth;
  1567. static somId somDI_idoSetInkWidth = &somDS_idoSetInkWidth;
  1568. #endif  /* somDS_idoSetInkWidth_defined */
  1569. #pragma linkage(somRD_IDOStrokeidoSetInkWidth, system)
  1570. static void  SOMLINK somRD_IDOStrokeidoSetInkWidth(IDOStroke *somSelf, Environment *ev,
  1571.         ULONG ulWidth)
  1572. {
  1573.     void* __retVal;
  1574.  
  1575.     va_somDispatch(somSelf, (void **)&__retVal, somId_idoSetInkWidth, somSelf , ev
  1576.         ,ulWidth);
  1577. }
  1578.  
  1579. /*
  1580.  * New Method: idoGetInkWidth
  1581.  */
  1582. #pragma linkage(IDOStrokeidoGetInkWidth, system)
  1583. SOM_Scope ULONG  SOMLINK IDOStrokeidoGetInkWidth(IDOStroke *somSelf, Environment *ev);
  1584. #ifndef somMN_idoGetInkWidth_defined
  1585. #define somMN_idoGetInkWidth_defined
  1586. static char *somMN_idoGetInkWidth = "idoGetInkWidth";
  1587. static somId somId_idoGetInkWidth = &somMN_idoGetInkWidth;
  1588. #endif  /* somMN_idoGetInkWidth_defined */
  1589. #ifndef somDS_idoGetInkWidth_defined
  1590. #define somDS_idoGetInkWidth_defined
  1591. static char *somDS_idoGetInkWidth = somMD_IDOStroke_idoGetInkWidth;
  1592. static somId somDI_idoGetInkWidth = &somDS_idoGetInkWidth;
  1593. #endif  /* somDS_idoGetInkWidth_defined */
  1594. #pragma linkage(somRD_IDOStrokeidoGetInkWidth, system)
  1595. static ULONG  SOMLINK somRD_IDOStrokeidoGetInkWidth(IDOStroke *somSelf, Environment *ev)
  1596. {
  1597.     ULONG __retVal;
  1598.  
  1599.     va_somDispatch(somSelf, (void **)&__retVal, somId_idoGetInkWidth, somSelf , ev
  1600.         );
  1601.     return __retVal;
  1602. }
  1603.  
  1604. /*
  1605.  * New Method: idoSetInkMix
  1606.  */
  1607. #pragma linkage(IDOStrokeidoSetInkMix, system)
  1608. SOM_Scope void  SOMLINK IDOStrokeidoSetInkMix(IDOStroke *somSelf, Environment *ev,
  1609.         ULONG ulMix);
  1610. #ifndef somMN_idoSetInkMix_defined
  1611. #define somMN_idoSetInkMix_defined
  1612. static char *somMN_idoSetInkMix = "idoSetInkMix";
  1613. static somId somId_idoSetInkMix = &somMN_idoSetInkMix;
  1614. #endif  /* somMN_idoSetInkMix_defined */
  1615. #ifndef somDS_idoSetInkMix_defined
  1616. #define somDS_idoSetInkMix_defined
  1617. static char *somDS_idoSetInkMix = somMD_IDOStroke_idoSetInkMix;
  1618. static somId somDI_idoSetInkMix = &somDS_idoSetInkMix;
  1619. #endif  /* somDS_idoSetInkMix_defined */
  1620. #pragma linkage(somRD_IDOStrokeidoSetInkMix, system)
  1621. static void  SOMLINK somRD_IDOStrokeidoSetInkMix(IDOStroke *somSelf, Environment *ev,
  1622.         ULONG ulMix)
  1623. {
  1624.     void* __retVal;
  1625.  
  1626.     va_somDispatch(somSelf, (void **)&__retVal, somId_idoSetInkMix, somSelf , ev
  1627.         ,ulMix);
  1628. }
  1629.  
  1630. /*
  1631.  * New Method: idoGetInkMix
  1632.  */
  1633. #pragma linkage(IDOStrokeidoGetInkMix, system)
  1634. SOM_Scope ULONG  SOMLINK IDOStrokeidoGetInkMix(IDOStroke *somSelf, Environment *ev);
  1635. #ifndef somMN_idoGetInkMix_defined
  1636. #define somMN_idoGetInkMix_defined
  1637. static char *somMN_idoGetInkMix = "idoGetInkMix";
  1638. static somId somId_idoGetInkMix = &somMN_idoGetInkMix;
  1639. #endif  /* somMN_idoGetInkMix_defined */
  1640. #ifndef somDS_idoGetInkMix_defined
  1641. #define somDS_idoGetInkMix_defined
  1642. static char *somDS_idoGetInkMix = somMD_IDOStroke_idoGetInkMix;
  1643. static somId somDI_idoGetInkMix = &somDS_idoGetInkMix;
  1644. #endif  /* somDS_idoGetInkMix_defined */
  1645. #pragma linkage(somRD_IDOStrokeidoGetInkMix, system)
  1646. static ULONG  SOMLINK somRD_IDOStrokeidoGetInkMix(IDOStroke *somSelf, Environment *ev)
  1647. {
  1648.     ULONG __retVal;
  1649.  
  1650.     va_somDispatch(somSelf, (void **)&__retVal, somId_idoGetInkMix, somSelf , ev
  1651.         );
  1652.     return __retVal;
  1653. }
  1654.  
  1655. /*
  1656.  * New Method: idoSetInkLineType
  1657.  */
  1658. #pragma linkage(IDOStrokeidoSetInkLineType, system)
  1659. SOM_Scope void  SOMLINK IDOStrokeidoSetInkLineType(IDOStroke *somSelf, Environment *ev,
  1660.         ULONG ulLineStyle);
  1661. #ifndef somMN_idoSetInkLineType_defined
  1662. #define somMN_idoSetInkLineType_defined
  1663. static char *somMN_idoSetInkLineType = "idoSetInkLineType";
  1664. static somId somId_idoSetInkLineType = &somMN_idoSetInkLineType;
  1665. #endif  /* somMN_idoSetInkLineType_defined */
  1666. #ifndef somDS_idoSetInkLineType_defined
  1667. #define somDS_idoSetInkLineType_defined
  1668. static char *somDS_idoSetInkLineType = somMD_IDOStroke_idoSetInkLineType;
  1669. static somId somDI_idoSetInkLineType = &somDS_idoSetInkLineType;
  1670. #endif  /* somDS_idoSetInkLineType_defined */
  1671. #pragma linkage(somRD_IDOStrokeidoSetInkLineType, system)
  1672. static void  SOMLINK somRD_IDOStrokeidoSetInkLineType(IDOStroke *somSelf, Environment *ev,
  1673.         ULONG ulLineStyle)
  1674. {
  1675.     void* __retVal;
  1676.  
  1677.     va_somDispatch(somSelf, (void **)&__retVal, somId_idoSetInkLineType, somSelf , ev
  1678.         ,ulLineStyle);
  1679. }
  1680.  
  1681. /*
  1682.  * New Method: idoGetInkLineType
  1683.  */
  1684. #pragma linkage(IDOStrokeidoGetInkLineType, system)
  1685. SOM_Scope ULONG  SOMLINK IDOStrokeidoGetInkLineType(IDOStroke *somSelf, Environment *ev);
  1686. #ifndef somMN_idoGetInkLineType_defined
  1687. #define somMN_idoGetInkLineType_defined
  1688. static char *somMN_idoGetInkLineType = "idoGetInkLineType";
  1689. static somId somId_idoGetInkLineType = &somMN_idoGetInkLineType;
  1690. #endif  /* somMN_idoGetInkLineType_defined */
  1691. #ifndef somDS_idoGetInkLineType_defined
  1692. #define somDS_idoGetInkLineType_defined
  1693. static char *somDS_idoGetInkLineType = somMD_IDOStroke_idoGetInkLineType;
  1694. static somId somDI_idoGetInkLineType = &somDS_idoGetInkLineType;
  1695. #endif  /* somDS_idoGetInkLineType_defined */
  1696. #pragma linkage(somRD_IDOStrokeidoGetInkLineType, system)
  1697. static ULONG  SOMLINK somRD_IDOStrokeidoGetInkLineType(IDOStroke *somSelf, Environment *ev)
  1698. {
  1699.     ULONG __retVal;
  1700.  
  1701.     va_somDispatch(somSelf, (void **)&__retVal, somId_idoGetInkLineType, somSelf , ev
  1702.         );
  1703.     return __retVal;
  1704. }
  1705.  
  1706. /*
  1707.  * New Method: idoGetScaledData
  1708.  */
  1709. #pragma linkage(IDOStrokeidoGetScaledData, system)
  1710. SOM_Scope void  SOMLINK IDOStrokeidoGetScaledData(IDOStroke *somSelf, Environment *ev,
  1711.         PSTROKEDATA pStrokeBuf,
  1712.         PULONG pulBufLen,
  1713.         HWND hwnd,
  1714.         ULONG flAuxData);
  1715. #ifndef somMN_idoGetScaledData_defined
  1716. #define somMN_idoGetScaledData_defined
  1717. static char *somMN_idoGetScaledData = "idoGetScaledData";
  1718. static somId somId_idoGetScaledData = &somMN_idoGetScaledData;
  1719. #endif  /* somMN_idoGetScaledData_defined */
  1720. #ifndef somDS_idoGetScaledData_defined
  1721. #define somDS_idoGetScaledData_defined
  1722. static char *somDS_idoGetScaledData = somMD_IDOStroke_idoGetScaledData;
  1723. static somId somDI_idoGetScaledData = &somDS_idoGetScaledData;
  1724. #endif  /* somDS_idoGetScaledData_defined */
  1725. #pragma linkage(somRD_IDOStrokeidoGetScaledData, system)
  1726. static void  SOMLINK somRD_IDOStrokeidoGetScaledData(IDOStroke *somSelf, Environment *ev,
  1727.         PSTROKEDATA pStrokeBuf,
  1728.         PULONG pulBufLen,
  1729.         HWND hwnd,
  1730.         ULONG flAuxData)
  1731. {
  1732.     void* __retVal;
  1733.  
  1734.     va_somDispatch(somSelf, (void **)&__retVal, somId_idoGetScaledData, somSelf , ev
  1735.         ,pStrokeBuf,pulBufLen,hwnd,flAuxData);
  1736. }
  1737.  
  1738. /*
  1739.  * New Method: idoGetScaledPoints
  1740.  */
  1741. #pragma linkage(IDOStrokeidoGetScaledPoints, system)
  1742. SOM_Scope void  SOMLINK IDOStrokeidoGetScaledPoints(IDOStroke *somSelf, Environment *ev,
  1743.         PULONG pulNumPoints,
  1744.         PPOINTL pPoints,
  1745.         PULONG pulBufLen);
  1746. #ifndef somMN_idoGetScaledPoints_defined
  1747. #define somMN_idoGetScaledPoints_defined
  1748. static char *somMN_idoGetScaledPoints = "idoGetScaledPoints";
  1749. static somId somId_idoGetScaledPoints = &somMN_idoGetScaledPoints;
  1750. #endif  /* somMN_idoGetScaledPoints_defined */
  1751. #ifndef somDS_idoGetScaledPoints_defined
  1752. #define somDS_idoGetScaledPoints_defined
  1753. static char *somDS_idoGetScaledPoints = somMD_IDOStroke_idoGetScaledPoints;
  1754. static somId somDI_idoGetScaledPoints = &somDS_idoGetScaledPoints;
  1755. #endif  /* somDS_idoGetScaledPoints_defined */
  1756. #pragma linkage(somRD_IDOStrokeidoGetScaledPoints, system)
  1757. static void  SOMLINK somRD_IDOStrokeidoGetScaledPoints(IDOStroke *somSelf, Environment *ev,
  1758.         PULONG pulNumPoints,
  1759.         PPOINTL pPoints,
  1760.         PULONG pulBufLen)
  1761. {
  1762.     void* __retVal;
  1763.  
  1764.     va_somDispatch(somSelf, (void **)&__retVal, somId_idoGetScaledPoints, somSelf , ev
  1765.         ,pulNumPoints,pPoints,pulBufLen);
  1766. }
  1767.  
  1768. /*
  1769.  * Routines and Structures to create the class object
  1770.  */
  1771.  
  1772. /*
  1773.  * Declare the Static Methods table.
  1774.  */
  1775. static somStaticMethod_t IDOStrokeSM[] = {
  1776.     {    &IDOStrokeClassData.idoIsTap,
  1777.          &somId_idoIsTap,
  1778.          &somDI_idoIsTap,
  1779.          (somMethodProc *) IDOStrokeidoIsTap,
  1780.          (somMethodProc *) somRD_IDOStrokeidoIsTap,
  1781.          (somMethodProc *) somAP_IDOStrokeidoIsTap    },
  1782.     {    &IDOStrokeClassData.idoScale,
  1783.          &somId_idoScale,
  1784.          &somDI_idoScale,
  1785.          (somMethodProc *) IDOStrokeidoScale,
  1786.          (somMethodProc *) somRD_IDOStrokeidoScale,
  1787.          (somMethodProc *) somAP_IDOStrokeidoScale    },
  1788.     {    &IDOStrokeClassData.idoSetStrokeType,
  1789.          &somId_idoSetStrokeType,
  1790.          &somDI_idoSetStrokeType,
  1791.          (somMethodProc *) IDOStrokeidoSetStrokeType,
  1792.          (somMethodProc *) somRD_IDOStrokeidoSetStrokeType,
  1793.          (somMethodProc *) somAP_IDOStrokeidoSetStrokeType    },
  1794.     {    &IDOStrokeClassData.idoGetStrokeType,
  1795.          &somId_idoGetStrokeType,
  1796.          &somDI_idoGetStrokeType,
  1797.          (somMethodProc *) IDOStrokeidoGetStrokeType,
  1798.          (somMethodProc *) somRD_IDOStrokeidoGetStrokeType,
  1799.          (somMethodProc *) somAP_IDOStrokeidoGetStrokeType    },
  1800.     {    &IDOStrokeClassData.idoSetStrokeData,
  1801.          &somId_idoSetStrokeData,
  1802.          &somDI_idoSetStrokeData,
  1803.          (somMethodProc *) IDOStrokeidoSetStrokeData,
  1804.          (somMethodProc *) somRD_IDOStrokeidoSetStrokeData,
  1805.          (somMethodProc *) somAP_IDOStrokeidoSetStrokeData    },
  1806.     {    &IDOStrokeClassData.idoGetStrokeData,
  1807.          &somId_idoGetStrokeData,
  1808.          &somDI_idoGetStrokeData,
  1809.          (somMethodProc *) IDOStrokeidoGetStrokeData,
  1810.          (somMethodProc *) somRD_IDOStrokeidoGetStrokeData,
  1811.          (somMethodProc *) somAP_IDOStrokeidoGetStrokeData    },
  1812.     {    &IDOStrokeClassData.idoGetSource,
  1813.          &somId_idoGetSource,
  1814.          &somDI_idoGetSource,
  1815.          (somMethodProc *) IDOStrokeidoGetSource,
  1816.          (somMethodProc *) somRD_IDOStrokeidoGetSource,
  1817.          (somMethodProc *) somAP_IDOStrokeidoGetSource    },
  1818.     {    &IDOStrokeClassData.idoGetSeq,
  1819.          &somId_idoGetSeq,
  1820.          &somDI_idoGetSeq,
  1821.          (somMethodProc *) IDOStrokeidoGetSeq,
  1822.          (somMethodProc *) somRD_IDOStrokeidoGetSeq,
  1823.          (somMethodProc *) somAP_IDOStrokeidoGetSeq    },
  1824.     {    &IDOStrokeClassData.idoGetResolution,
  1825.          &somId_idoGetResolution,
  1826.          &somDI_idoGetResolution,
  1827.          (somMethodProc *) IDOStrokeidoGetResolution,
  1828.          (somMethodProc *) somRD_IDOStrokeidoGetResolution,
  1829.          (somMethodProc *) somAP_IDOStrokeidoGetResolution    },
  1830.     {    &IDOStrokeClassData.idoGetSampleRate,
  1831.          &somId_idoGetSampleRate,
  1832.          &somDI_idoGetSampleRate,
  1833.          (somMethodProc *) IDOStrokeidoGetSampleRate,
  1834.          (somMethodProc *) somRD_IDOStrokeidoGetSampleRate,
  1835.          (somMethodProc *) somAP_IDOStrokeidoGetSampleRate    },
  1836.     {    &IDOStrokeClassData.idoGetNumPoints,
  1837.          &somId_idoGetNumPoints,
  1838.          &somDI_idoGetNumPoints,
  1839.          (somMethodProc *) IDOStrokeidoGetNumPoints,
  1840.          (somMethodProc *) somRD_IDOStrokeidoGetNumPoints,
  1841.          (somMethodProc *) somAP_IDOStrokeidoGetNumPoints    },
  1842.     {    &IDOStrokeClassData.idoGetStrokeFlags,
  1843.          &somId_idoGetStrokeFlags,
  1844.          &somDI_idoGetStrokeFlags,
  1845.          (somMethodProc *) IDOStrokeidoGetStrokeFlags,
  1846.          (somMethodProc *) somRD_IDOStrokeidoGetStrokeFlags,
  1847.          (somMethodProc *) somAP_IDOStrokeidoGetStrokeFlags    },
  1848.     {    &IDOStrokeClassData.idoGetXExtent,
  1849.          &somId_idoGetXExtent,
  1850.          &somDI_idoGetXExtent,
  1851.          (somMethodProc *) IDOStrokeidoGetXExtent,
  1852.          (somMethodProc *) somRD_IDOStrokeidoGetXExtent,
  1853.          (somMethodProc *) somAP_IDOStrokeidoGetXExtent    },
  1854.     {    &IDOStrokeClassData.idoGetYExtent,
  1855.          &somId_idoGetYExtent,
  1856.          &somDI_idoGetYExtent,
  1857.          (somMethodProc *) IDOStrokeidoGetYExtent,
  1858.          (somMethodProc *) somRD_IDOStrokeidoGetYExtent,
  1859.          (somMethodProc *) somAP_IDOStrokeidoGetYExtent    },
  1860.     {    &IDOStrokeClassData.idoGetSensorResolution,
  1861.          &somId_idoGetSensorResolution,
  1862.          &somDI_idoGetSensorResolution,
  1863.          (somMethodProc *) IDOStrokeidoGetSensorResolution,
  1864.          (somMethodProc *) somRD_IDOStrokeidoGetSensorResolution,
  1865.          (somMethodProc *) somAP_IDOStrokeidoGetSensorResolution    },
  1866.     {    &IDOStrokeClassData.idoGetSensorXExtent,
  1867.          &somId_idoGetSensorXExtent,
  1868.          &somDI_idoGetSensorXExtent,
  1869.          (somMethodProc *) IDOStrokeidoGetSensorXExtent,
  1870.          (somMethodProc *) somRD_IDOStrokeidoGetSensorXExtent,
  1871.          (somMethodProc *) somAP_IDOStrokeidoGetSensorXExtent    },
  1872.     {    &IDOStrokeClassData.idoGetSensorYExtent,
  1873.          &somId_idoGetSensorYExtent,
  1874.          &somDI_idoGetSensorYExtent,
  1875.          (somMethodProc *) IDOStrokeidoGetSensorYExtent,
  1876.          (somMethodProc *) somRD_IDOStrokeidoGetSensorYExtent,
  1877.          (somMethodProc *) somAP_IDOStrokeidoGetSensorYExtent    },
  1878.     {    &IDOStrokeClassData.idoGetTimestamp,
  1879.          &somId_idoGetTimestamp,
  1880.          &somDI_idoGetTimestamp,
  1881.          (somMethodProc *) IDOStrokeidoGetTimestamp,
  1882.          (somMethodProc *) somRD_IDOStrokeidoGetTimestamp,
  1883.          (somMethodProc *) somAP_IDOStrokeidoGetTimestamp    },
  1884.     {    &IDOStrokeClassData.idoGetDevTimestampRes,
  1885.          &somId_idoGetDevTimestampRes,
  1886.          &somDI_idoGetDevTimestampRes,
  1887.          (somMethodProc *) IDOStrokeidoGetDevTimestampRes,
  1888.          (somMethodProc *) somRD_IDOStrokeidoGetDevTimestampRes,
  1889.          (somMethodProc *) somAP_IDOStrokeidoGetDevTimestampRes    },
  1890.     {    &IDOStrokeClassData.idoSetInkColor,
  1891.          &somId_idoSetInkColor,
  1892.          &somDI_idoSetInkColor,
  1893.          (somMethodProc *) IDOStrokeidoSetInkColor,
  1894.          (somMethodProc *) somRD_IDOStrokeidoSetInkColor,
  1895.          (somMethodProc *) somAP_IDOStrokeidoSetInkColor    },
  1896.     {    &IDOStrokeClassData.idoGetInkColor,
  1897.          &somId_idoGetInkColor,
  1898.          &somDI_idoGetInkColor,
  1899.          (somMethodProc *) IDOStrokeidoGetInkColor,
  1900.          (somMethodProc *) somRD_IDOStrokeidoGetInkColor,
  1901.          (somMethodProc *) somAP_IDOStrokeidoGetInkColor    },
  1902.     {    &IDOStrokeClassData.idoSetInkWidth,
  1903.          &somId_idoSetInkWidth,
  1904.          &somDI_idoSetInkWidth,
  1905.          (somMethodProc *) IDOStrokeidoSetInkWidth,
  1906.          (somMethodProc *) somRD_IDOStrokeidoSetInkWidth,
  1907.          (somMethodProc *) somAP_IDOStrokeidoSetInkWidth    },
  1908.     {    &IDOStrokeClassData.idoGetInkWidth,
  1909.          &somId_idoGetInkWidth,
  1910.          &somDI_idoGetInkWidth,
  1911.          (somMethodProc *) IDOStrokeidoGetInkWidth,
  1912.          (somMethodProc *) somRD_IDOStrokeidoGetInkWidth,
  1913.          (somMethodProc *) somAP_IDOStrokeidoGetInkWidth    },
  1914.     {    &IDOStrokeClassData.idoSetInkMix,
  1915.          &somId_idoSetInkMix,
  1916.          &somDI_idoSetInkMix,
  1917.          (somMethodProc *) IDOStrokeidoSetInkMix,
  1918.          (somMethodProc *) somRD_IDOStrokeidoSetInkMix,
  1919.          (somMethodProc *) somAP_IDOStrokeidoSetInkMix    },
  1920.     {    &IDOStrokeClassData.idoGetInkMix,
  1921.          &somId_idoGetInkMix,
  1922.          &somDI_idoGetInkMix,
  1923.          (somMethodProc *) IDOStrokeidoGetInkMix,
  1924.          (somMethodProc *) somRD_IDOStrokeidoGetInkMix,
  1925.          (somMethodProc *) somAP_IDOStrokeidoGetInkMix    },
  1926.     {    &IDOStrokeClassData.idoSetInkLineType,
  1927.          &somId_idoSetInkLineType,
  1928.          &somDI_idoSetInkLineType,
  1929.          (somMethodProc *) IDOStrokeidoSetInkLineType,
  1930.          (somMethodProc *) somRD_IDOStrokeidoSetInkLineType,
  1931.          (somMethodProc *) somAP_IDOStrokeidoSetInkLineType    },
  1932.     {    &IDOStrokeClassData.idoGetInkLineType,
  1933.          &somId_idoGetInkLineType,
  1934.          &somDI_idoGetInkLineType,
  1935.          (somMethodProc *) IDOStrokeidoGetInkLineType,
  1936.          (somMethodProc *) somRD_IDOStrokeidoGetInkLineType,
  1937.          (somMethodProc *) somAP_IDOStrokeidoGetInkLineType    },
  1938.     {    &IDOStrokeClassData.idoGetScaledData,
  1939.          &somId_idoGetScaledData,
  1940.          &somDI_idoGetScaledData,
  1941.          (somMethodProc *) IDOStrokeidoGetScaledData,
  1942.          (somMethodProc *) somRD_IDOStrokeidoGetScaledData,
  1943.          (somMethodProc *) somAP_IDOStrokeidoGetScaledData    },
  1944.     {    &IDOStrokeClassData.idoGetScaledPoints,
  1945.          &somId_idoGetScaledPoints,
  1946.          &somDI_idoGetScaledPoints,
  1947.          (somMethodProc *) IDOStrokeidoGetScaledPoints,
  1948.          (somMethodProc *) somRD_IDOStrokeidoGetScaledPoints,
  1949.          (somMethodProc *) somAP_IDOStrokeidoGetScaledPoints    },
  1950. };
  1951.  
  1952.  
  1953. /*
  1954.  * Declare the Override Methods table.
  1955.  */
  1956. static somOverrideMethod_t IDOStrokeOM[] = {
  1957.     {    &somId_somUninit,
  1958.          (somMethodProc *) IDOStrokesomUninit    },
  1959.     {    &somId_somFree,
  1960.          (somMethodProc *) IDOStrokesomFree    },
  1961.     {    &somId_idoDraw,
  1962.          (somMethodProc *) IDOStrokeidoDraw    },
  1963.     {    &somId_idoInkerDraw,
  1964.          (somMethodProc *) IDOStrokeidoInkerDraw    },
  1965.     {    &somId_idoGetBoundingBox,
  1966.          (somMethodProc *) IDOStrokeidoGetBoundingBox    },
  1967.     {    &somId_idoSetInkAttr,
  1968.          (somMethodProc *) IDOStrokeidoSetInkAttr    },
  1969.     {    &somId_idoGetInkAttr,
  1970.          (somMethodProc *) IDOStrokeidoGetInkAttr    },
  1971.     {    &somId_idoSetOffset,
  1972.          (somMethodProc *) IDOStrokeidoSetOffset    },
  1973.     {    &somId_idoGetOffset,
  1974.          (somMethodProc *) IDOStrokeidoGetOffset    },
  1975.     {    &somId_idoSetInkerData,
  1976.          (somMethodProc *) IDOStrokeidoSetInkerData    },
  1977.     {    &somId_idoGetInkerData,
  1978.          (somMethodProc *) IDOStrokeidoGetInkerData    },
  1979. };
  1980.  
  1981.  
  1982. /*
  1983.  *  Initializers for class Ids
  1984.  */
  1985. static char * somCN_IDOStroke = "IDOStroke";
  1986. #ifndef somEMC_IDOMStroke_defined
  1987. #define somEMC_IDOMStroke_defined
  1988. static char * somEMC_IDOMStroke = "IDOMStroke";
  1989. #endif
  1990. static char * somPCN_IDOStroke_IDOCommon = "IDOCommon";
  1991.  
  1992. static somId somPCIDOStroke[] = {
  1993.     &somPCN_IDOStroke_IDOCommon,
  1994. };
  1995.  
  1996. static somStaticClassInfo IDOStrokeSCI = {
  1997.     3, 29, 11, 0, 0, 0,
  1998.     IDOStroke_MajorVersion, IDOStroke_MinorVersion,
  1999.     0, IDOStroke_MaxNoMethods, 1,
  2000.     &somCN_IDOStroke,
  2001.     &somEMC_IDOMStroke, 0,
  2002.     somPCIDOStroke,
  2003.     (somClassDataStructure *) &IDOStrokeClassData,
  2004.     (somCClassDataStructure *) &IDOStrokeCClassData,
  2005.     IDOStrokeSM, IDOStrokeOM,
  2006.     (char *) NULL,
  2007.     (somNonInternalData_t *) NULL,  (somProcMethods_t *) NULL,
  2008.     (somVarargsFuncs_t *) NULL,
  2009.     (somTP_somClassInitFunc *) NULL,
  2010.     0,
  2011.     0,  /* old style class, zero directinitclasses */
  2012.     0, /* no directinitclasses */
  2013.     0, /* number of methods */
  2014.     0, /* methods of the class */
  2015.     0, /* dataOffset1 */
  2016.     0, /* dataOffset2 */
  2017.     0, /* number of SelectInheritedMethods */
  2018.     0, /* SelectInheritedMethods */
  2019.     0, /* number of releaseorder entries */
  2020.     0, /* ReleaseOrder */
  2021.     0, /* number of migrated methods */
  2022.     0, /* migrated method implementations */
  2023.     0, /* number of initializers */
  2024.     0, /* initializers */
  2025.     0, /* used to identify a DTS class */
  2026.     0, /* used to register dynamically computed info */
  2027. };
  2028.  
  2029.  
  2030. IDOStroke * SOMLINK IDOStrokeNewClass (integer4 somtmajorVersion,
  2031.         integer4 somtminorVersion)
  2032. {
  2033.     IDOCommonNewClass(IDOCommon_MajorVersion,IDOCommon_MinorVersion);    /* static reference */
  2034.     /* Explicit metaclass, so get it */ 
  2035.     IDOMStrokeNewClass(IDOMStroke_MajorVersion,IDOMStroke_MinorVersion);    /* static reference */
  2036.     return (somBuildClass(1,&IDOStrokeSCI, somtmajorVersion, somtminorVersion));
  2037. }
  2038.  
  2039. /*
  2040.  * Functions for attributes.
  2041.  */
  2042.  
  2043. #endif                   /* IDOStroke_Class_Source */
  2044. #pragma checkout(resume)
  2045.  
  2046. #endif       /* SOM_IDOStroke_ih */
  2047.