home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / pentlk11.zip / OEM.IH < prev    next >
Text File  |  1994-01-13  |  12KB  |  452 lines
  1.  
  2. /*
  3.  * This file was generated by the SOM Compiler.
  4.  * FileName: oem.ih.
  5.  * Generated using:
  6.  *     SOM Precompiler spc: 1.22
  7.  *     SOM Emitter emitih: 1.59
  8.  */
  9.  
  10. /*
  11.  * 
  12.  * 
  13.  * 
  14.  *   File Name   : OEM.CSC
  15.  * 
  16.  *   Description : Sample sublcass
  17.  * 
  18.  *   Function:  This is a sample of a subclass of PenLocatorPen
  19.  * 
  20.  *   Copyright (C) 1993 IBM Corporation
  21.  * 
  22.  *       DISCLAIMER OF WARRANTIES.  The following [enclosed] code is
  23.  *       sample code created by IBM Corporation. This sample code is not
  24.  *       part of any standard or IBM product and is provided to you solely
  25.  *       for  the purpose of assisting you in the development of your
  26.  *       applications.  The code is provided "AS IS", without
  27.  *       warranty of any kind.  IBM shall not be liable for any damages
  28.  *       arising out of your use of the sample code, even if they have been
  29.  *       advised of the possibility of such damages.
  30.  * 
  31.  */
  32.  
  33.  
  34. #ifndef oem_ih
  35. #define oem_ih
  36.  
  37.  
  38. #include "oem.h"
  39.  
  40. /*
  41.  * Set the scope of methods functions
  42.  */
  43. #ifndef SOM_Scope
  44. #define SOM_Scope static
  45. #endif
  46.  
  47. #ifndef SOM_CurrentClass
  48. #define SOM_CurrentClass oemCClassData.parentMtab
  49. #endif
  50.  
  51. #define oem_MaxNoMethods 1
  52.  
  53. /*
  54.  * Instance data
  55.  */
  56. typedef void oemData;
  57.  
  58. /*
  59.  * Trace/Debug macro
  60.  */
  61. #ifndef oemMethodDebug
  62. #define oemMethodDebug(c,m) SOMMethodDebug(c,m)
  63. #endif
  64.  
  65. /*
  66.  * Begin stuff that only goes in the primary file
  67.  */
  68. #ifdef oem_Class_Source
  69.  
  70. /*
  71.  * Current class macros for Instance and Meta classes.
  72.  */
  73. #undef SOMMeta
  74. #define SOMMeta M_oemCClassData.parentMtab
  75. #undef SOMInstance
  76. #define SOMInstance oemCClassData.parentMtab
  77.  
  78. #ifndef M_oem_Class_Source
  79. #define M_oem_Class_Source
  80. #endif    /* M_oem_Class_Source */
  81.  
  82. /*
  83.  * Generate the Apply Stubs.
  84.  */
  85. #pragma linkage(somAP_AddUserTypePage, system)
  86. static ULONG   SOMLINK somAP_AddUserTypePage(oem *somSelf,
  87.         somId __id,
  88.         somId __desc,
  89.         va_list __ap)
  90. {
  91.     HWND hwndOem = va_arg(__ap, HWND);
  92.     __ap; __id; __desc;           /* Referenced to prevent warning msg */
  93.  
  94.     return (oem_AddUserTypePage(somSelf,hwndOem));
  95. }
  96.  
  97.  
  98. /*
  99.  * Overridden method: wpAddSettingsPages
  100.  */
  101. #pragma linkage(wpAddSettingsPages, system)
  102. SOM_Scope BOOL   SOMLINK wpAddSettingsPages(oem *somSelf,
  103.         HWND hwndNotebook);
  104. #ifndef parent_wpAddSettingsPages
  105. static char *somMN_wpAddSettingsPages = "wpAddSettingsPages";
  106. static somId somId_wpAddSettingsPages = &somMN_wpAddSettingsPages;
  107. #define parent_wpAddSettingsPages(somSelf,hwndNotebook) \
  108.     ((SOM_ParentResolveE(WPObject, SOM_CurrentClass, wpAddSettingsPages)) \
  109.      (somSelf,hwndNotebook))
  110. #endif
  111. #define oemParent_wpAddSettingsPages parent_wpAddSettingsPages
  112.  
  113. /*
  114.  * Temporary class data structure used only in class creation
  115.  */
  116. static somClassDataStructure oemtempClassData;
  117.  
  118. /*
  119.  * Initialize the class data structure
  120.  */
  121. struct oemClassDataStructure oemClassData = {(SOMAny *) NULL};
  122.  
  123. /*
  124.  * Define the C class data structure
  125.  */
  126. struct oemCClassDataStructure oemCClassData = {(somMethodTab *) NULL};
  127.  
  128. /*
  129.  * New Method: AddUserTypePage
  130.  */
  131. #pragma linkage(AddUserTypePage, system)
  132. SOM_Scope ULONG   SOMLINK AddUserTypePage(oem *somSelf,
  133.         HWND hwndOem);
  134. static char *somMN_AddUserTypePage = "AddUserTypePage";
  135. static somId somId_AddUserTypePage = &somMN_AddUserTypePage;
  136. static char *somDS_AddUserTypePage = somMD_oem_AddUserTypePage;
  137. static somId somDI_AddUserTypePage = &somDS_AddUserTypePage;
  138. #pragma linkage(somRD_AddUserTypePage, system)
  139. static ULONG   SOMLINK somRD_AddUserTypePage(oem *somSelf,
  140.         HWND hwndOem)
  141. {
  142.     return ((ULONG) va_somDispatchL(somSelf, somId_AddUserTypePage,
  143.         _somGetMethodDescriptor(SOM_GetClass(somSelf),somId_AddUserTypePage),hwndOem));
  144. }
  145.  
  146. /*
  147.  * Routines to create the class object
  148.  */
  149.  
  150. /*
  151.  * Declare the Static Methods table.
  152.  */
  153. static somStaticMethod_t oemSM[] = {
  154.     {    &oemClassData.AddUserTypePage,
  155.          &somId_AddUserTypePage,
  156.          &somDI_AddUserTypePage,
  157.          (somMethodProc *) AddUserTypePage,
  158.          (somMethodProc *) somRD_AddUserTypePage,
  159.          (somMethodProc *) somAP_AddUserTypePage    },
  160. };
  161.  
  162.  
  163. /*
  164.  * Declare the Override Methods table.
  165.  */
  166. static somOverrideMethod_t oemOM[] = {
  167.     {    &somId_wpAddSettingsPages,
  168.          (somMethodProc *) wpAddSettingsPages    },
  169. };
  170.  
  171. static void oemsomInitializeClass ()
  172. {
  173.     int i;
  174.     somStaticMethod_t *smp;
  175.     somOverrideMethod_t *omp;
  176.  
  177. /*
  178.  * Add the Static Methods.
  179.  */
  180.     for (smp = oemSM, i = 0; i < 1; smp++, i++)
  181.         *(smp->classData) =
  182.             _somAddStaticMethod (oemtempClassData.classObject,
  183.                 *(smp->methodId), *(smp->methodDescriptor),
  184.                 smp->method, smp->redispatchStub,
  185.                 smp->applyStub);
  186.  
  187.  
  188. /*
  189.  * Override methods.
  190.  */
  191.     for (omp = oemOM, i = 0; i < 1; omp++, i++)
  192.         _somOverrideSMethod (oemtempClassData.classObject,
  193.             *(omp->methodId), omp->method);
  194.  
  195. }
  196.  
  197. #pragma linkage(oemsomCreateClass, system)
  198. static void SOMLINK oemsomCreateClass(SOMClass *pClsObj,
  199.                            SOMClass *mClsObj)
  200. {
  201.     oemtempClassData.classObject = _somNew (mClsObj);
  202.     _somInitClass (oemtempClassData.classObject,
  203.         "oem",
  204.         pClsObj,
  205.         0,
  206.         oem_MaxNoMethods,
  207.         oem_MajorVersion,
  208.         oem_MinorVersion);
  209.     oemCClassData.instanceDataToken = 
  210.     _somGetInstanceToken(oemtempClassData.classObject);
  211.     oemsomInitializeClass();
  212.     oemCClassData.parentMtab =
  213.     _somGetPClsMtab(oemtempClassData.classObject);
  214.     _somSetClassData(oemtempClassData.classObject, (somClassDataStructure *)&oemClassData);
  215.     _somClassReady(oemtempClassData.classObject);
  216.     /* make newly created class object visible */
  217.     oemClassData.classObject = oemtempClassData.classObject;
  218. }
  219.  
  220. oem * SOMLINK oemNewClass (integer4 scemajorVersion,
  221.         integer4 sceminorVersion)
  222. {
  223.     SOMClass *pClsObj;
  224.     SOMClass *mClsObj;
  225.  
  226.     /* Check the version numbers */
  227.     if (((scemajorVersion != 0) && 
  228.          (scemajorVersion != oem_MajorVersion)) ||
  229.         ((sceminorVersion != 0) && 
  230.          (sceminorVersion > oem_MinorVersion))) {
  231.     somPrintf("oemNewClass: Error, bad version numbers.\n");
  232.     SOM_Error(SOMERROR_BadVersion);
  233.     }
  234.     /* Don't do anything if class object is already created. */
  235.     if (oemClassData.classObject != (SOMAny *) NULL)
  236.     return(oemClassData.classObject);
  237.  
  238.     /* Make sure the environment is initialized. */
  239.     if (SOMClassMgrObject == (SOMAny *) NULL) somEnvironmentNew();
  240.     if (SOMClassMgrObject == (SOMAny *) NULL)
  241.     SOM_Error(SOMERROR_CouldNotStartup);
  242.  
  243.     /* Get the parent class object. */
  244.     PenLocatorPenNewClass(1,1);    /* static reference */
  245.     pClsObj = _somFindClass(SOMClassMgrObject,
  246.         SOM_IdFromString("PenLocatorPen"), 1, 1);
  247.     if (pClsObj == (SOMClass *) NULL)
  248.     SOM_Error(SOMERROR_NoParentClass);
  249.  
  250.     /* Explicit metaclass, so get it */ 
  251.     M_oemNewClass(0,0);    /* static reference */
  252.     mClsObj = _somFindClass(SOMClassMgrObject,
  253.         SOM_IdFromString("M_oem"), 0, 0);
  254.     if (mClsObj == (SOMClass *) NULL)
  255.     SOM_Error(SOMERROR_NoMetaClass);
  256.  
  257.     somConstructClass(oemsomCreateClass, pClsObj, mClsObj,
  258.              &oemtempClassData);
  259.     return (oemClassData.classObject);
  260. }
  261.  
  262. #endif                   /* oem_Class_Source */
  263.  
  264. #endif       /* oem_ih */
  265.  
  266. /*
  267.  * This file was generated by the SOM Compiler.
  268.  * FileName: oem.ih.
  269.  * Generated using:
  270.  *     SOM Precompiler spc: 1.22
  271.  *     SOM Emitter emitih: 1.59
  272.  */
  273.  
  274. #ifndef oem_mih
  275. #define oem_mih
  276.  
  277.  
  278. /*
  279.  * Set the scope of methods functions
  280.  */
  281. #ifndef SOM_Scope
  282. #define SOM_Scope static
  283. #endif
  284.  
  285. #ifndef SOM_CurrentClass
  286. #define SOM_CurrentClass M_oemCClassData.parentMtab
  287. #endif
  288.  
  289. #define M_oem_MaxNoMethods 0
  290.  
  291. /*
  292.  * Instance data
  293.  */
  294. typedef void M_oemData;
  295.  
  296. /*
  297.  * Trace/Debug macro
  298.  */
  299. #ifndef M_oemMethodDebug
  300. #define M_oemMethodDebug(c,m) SOMMethodDebug(c,m)
  301. #endif
  302.  
  303. /*
  304.  * Begin stuff that only goes in the primary file
  305.  */
  306. #ifdef M_oem_Class_Source
  307.  
  308. /*
  309.  * Current class macros for Instance and Meta classes.
  310.  */
  311.  
  312. /*
  313.  * Generate the Apply Stubs.
  314.  */
  315.  
  316. /*
  317.  * Overridden method: wpclsQueryTitle
  318.  */
  319. #pragma linkage(oemM_wpclsQueryTitle, system)
  320. SOM_Scope PSZ   SOMLINK oemM_wpclsQueryTitle(M_oem *somSelf);
  321. #ifndef parent_wpclsQueryTitle
  322. static char *somMN_wpclsQueryTitle = "wpclsQueryTitle";
  323. static somId somId_wpclsQueryTitle = &somMN_wpclsQueryTitle;
  324. #define parent_wpclsQueryTitle(somSelf) \
  325.     ((SOM_ParentResolveE(M_WPObject, SOM_CurrentClass, wpclsQueryTitle)) \
  326.      (somSelf))
  327. #endif
  328. #define M_oemParent_wpclsQueryTitle parent_wpclsQueryTitle
  329.  
  330. /*
  331.  * Overridden method: wpclsQueryIconData
  332.  */
  333. #pragma linkage(oemM_wpclsQueryIconData, system)
  334. SOM_Scope ULONG   SOMLINK oemM_wpclsQueryIconData(M_oem *somSelf,
  335.         PICONINFO pIconInfo);
  336. #ifndef parent_wpclsQueryIconData
  337. static char *somMN_wpclsQueryIconData = "wpclsQueryIconData";
  338. static somId somId_wpclsQueryIconData = &somMN_wpclsQueryIconData;
  339. #define parent_wpclsQueryIconData(somSelf,pIconInfo) \
  340.     ((SOM_ParentResolveE(M_WPObject, SOM_CurrentClass, wpclsQueryIconData)) \
  341.      (somSelf,pIconInfo))
  342. #endif
  343. #define M_oemParent_wpclsQueryIconData parent_wpclsQueryIconData
  344.  
  345. /*
  346.  * Temporary class data structure used only in class creation
  347.  */
  348. static somClassDataStructure M_oemtempClassData;
  349.  
  350. /*
  351.  * Initialize the class data structure
  352.  */
  353. struct M_oemClassDataStructure M_oemClassData = {(SOMAny *) NULL};
  354.  
  355. /*
  356.  * Define the C class data structure
  357.  */
  358. struct M_oemCClassDataStructure M_oemCClassData = {(somMethodTab *) NULL};
  359.  
  360. /*
  361.  * Routines to create the class object
  362.  */
  363.  
  364. /*
  365.  * Declare the Override Methods table.
  366.  */
  367. static somOverrideMethod_t M_oemOM[] = {
  368.     {    &somId_wpclsQueryTitle,
  369.          (somMethodProc *) oemM_wpclsQueryTitle    },
  370.     {    &somId_wpclsQueryIconData,
  371.          (somMethodProc *) oemM_wpclsQueryIconData    },
  372. };
  373.  
  374. static void M_oemsomInitializeClass ()
  375. {
  376.     int i;
  377.     somOverrideMethod_t *omp;
  378.  
  379. /*
  380.  * Override methods.
  381.  */
  382.     for (omp = M_oemOM, i = 0; i < 2; omp++, i++)
  383.         _somOverrideSMethod (M_oemtempClassData.classObject,
  384.             *(omp->methodId), omp->method);
  385.  
  386. }
  387.  
  388. #pragma linkage(M_oemsomCreateClass, system)
  389. static void SOMLINK M_oemsomCreateClass(SOMClass *pClsObj,
  390.                            SOMClass *mClsObj)
  391. {
  392.     M_oemtempClassData.classObject = _somNew (mClsObj);
  393.     _somInitClass (M_oemtempClassData.classObject,
  394.         "M_oem",
  395.         pClsObj,
  396.         0,
  397.         M_oem_MaxNoMethods,
  398.         M_oem_MajorVersion,
  399.         M_oem_MinorVersion);
  400.     M_oemCClassData.instanceDataToken = 
  401.     _somGetInstanceToken(M_oemtempClassData.classObject);
  402.     M_oemsomInitializeClass();
  403.     M_oemCClassData.parentMtab =
  404.     _somGetPClsMtab(M_oemtempClassData.classObject);
  405.     _somSetClassData(M_oemtempClassData.classObject, (somClassDataStructure *)&M_oemClassData);
  406.     _somClassReady(M_oemtempClassData.classObject);
  407.     /* make newly created class object visible */
  408.     M_oemClassData.classObject = M_oemtempClassData.classObject;
  409. }
  410.  
  411. M_oem * SOMLINK M_oemNewClass (integer4 scemajorVersion,
  412.         integer4 sceminorVersion)
  413. {
  414.     SOMClass *pClsObj;
  415.     SOMClass *mClsObj;
  416.  
  417.     /* Check the version numbers */
  418.     if (((scemajorVersion != 0) && 
  419.          (scemajorVersion != M_oem_MajorVersion)) ||
  420.         ((sceminorVersion != 0) && 
  421.          (sceminorVersion > M_oem_MinorVersion))) {
  422.     somPrintf("M_oemNewClass: Error, bad version numbers.\n");
  423.     SOM_Error(SOMERROR_BadVersion);
  424.     }
  425.     /* Don't do anything if class object is already created. */
  426.     if (M_oemClassData.classObject != (SOMAny *) NULL)
  427.     return(M_oemClassData.classObject);
  428.  
  429.     /* Make sure the environment is initialized. */
  430.     if (SOMClassMgrObject == (SOMAny *) NULL) somEnvironmentNew();
  431.     if (SOMClassMgrObject == (SOMAny *) NULL)
  432.     SOM_Error(SOMERROR_CouldNotStartup);
  433.  
  434.     /* Get the parent class object. */
  435.     M_PenLocatorPenNewClass(1,1);    /* static reference */
  436.     pClsObj = _somFindClass(SOMClassMgrObject,
  437.         SOM_IdFromString("M_PenLocatorPen"), 1, 1);
  438.     if (pClsObj == (SOMClass *) NULL)
  439.     SOM_Error(SOMERROR_NoParentClass);
  440.  
  441.     /* Use parent's metaclass */ 
  442.     mClsObj = SOM_GetClass(pClsObj);
  443.  
  444.     somConstructClass(M_oemsomCreateClass, pClsObj, mClsObj,
  445.              &M_oemtempClassData);
  446.     return (M_oemClassData.classObject);
  447. }
  448.  
  449. #endif                   /* M_oem_Class_Source */
  450.  
  451. #endif       /* oem_ih */
  452.