home *** CD-ROM | disk | FTP | other *** search
/ Power-Programmierung / CD2.mdf / c / library / os2 / rb3774 / pwfolder / pwfolder.ih < prev    next >
Encoding:
Text File  |  1992-06-28  |  20.6 KB  |  693 lines
  1.  
  2. /*
  3.  * This file was generated by the SOM Compiler.
  4.  * FileName: pwfolder.ih.
  5.  * Generated using:
  6.  *     SOM Precompiler spc: 1.22
  7.  *     SOM Emitter emitih: 1.59
  8.  */
  9.  
  10. #ifndef pwfolder_ih
  11. #define pwfolder_ih
  12.  
  13.  
  14. #include "pwfolder.ph"
  15.  
  16. /*
  17.  * Set the scope of methods functions
  18.  */
  19. #ifndef SOM_Scope
  20. #ifdef __cplusplus
  21. #define SOM_Scope extern "C"
  22. #else
  23. #define SOM_Scope extern
  24. #endif
  25. #endif
  26.  
  27. #ifndef SOM_CurrentClass
  28. #define SOM_CurrentClass PWFolderCClassData.parentMtab
  29. #endif
  30.  
  31. #define PWFolder_MaxNoMethods 3
  32.  
  33. /*
  34.  * Instance data
  35.  */
  36. typedef struct {
  37.     CHAR szPassword[20];
  38.     CHAR szCurrentPassword[20];
  39.     CHAR szUserid[20];
  40. } PWFolderData;
  41.  
  42. /*
  43.  * Instance variable access macros
  44.  */
  45. #define _szPassword (somThis->szPassword)
  46. #define _szCurrentPassword (somThis->szCurrentPassword)
  47. #define _szUserid (somThis->szUserid)
  48.  
  49. /*
  50.  * Getdata macro
  51.  */
  52. #define PWFolderGetData(somSelf) \
  53.     ((PWFolderData *) \
  54.         SOM_DataResolve(somSelf, PWFolderCClassData.instanceDataToken))
  55.  
  56. /*
  57.  * Trace/Debug macro
  58.  */
  59. #ifndef PWFolderMethodDebug
  60. #define PWFolderMethodDebug(c,m) SOMMethodDebug(c,m)
  61. #endif
  62.  
  63. /*
  64.  * Begin stuff that only goes in the primary file
  65.  */
  66. #ifdef PWFolder_Class_Source
  67.  
  68. /*
  69.  * Current class macros for Instance and Meta classes.
  70.  */
  71. #undef SOMMeta
  72. #define SOMMeta M_PWFolderCClassData.parentMtab
  73. #undef SOMInstance
  74. #define SOMInstance PWFolderCClassData.parentMtab
  75.  
  76. #ifndef M_PWFolder_Class_Source
  77. #define M_PWFolder_Class_Source
  78. #endif    /* M_PWFolder_Class_Source */
  79.  
  80. /*
  81.  * Generate the Apply Stubs.
  82.  */
  83. #pragma linkage(somAP_QueryInfo, system)
  84. static BOOL   SOMLINK somAP_QueryInfo(PWFolder *somSelf,
  85.         somId __id,
  86.         somId __desc,
  87.         va_list __ap)
  88. {
  89.     PPWF_INFO pPWFolderInfo = va_arg(__ap, PPWF_INFO);
  90.     __ap; __id; __desc;           /* Referenced to prevent warning msg */
  91.  
  92.     return (PWFolder_QueryInfo(somSelf,pPWFolderInfo));
  93. }
  94.  
  95. #pragma linkage(somAP_SetInfo, system)
  96. static BOOL   SOMLINK somAP_SetInfo(PWFolder *somSelf,
  97.         somId __id,
  98.         somId __desc,
  99.         va_list __ap)
  100. {
  101.     PPWF_INFO pPWFolderInfo = va_arg(__ap, PPWF_INFO);
  102.     __ap; __id; __desc;           /* Referenced to prevent warning msg */
  103.  
  104.     return (PWFolder_SetInfo(somSelf,pPWFolderInfo));
  105. }
  106.  
  107. #pragma linkage(somAP_LockFolder, system)
  108. static BOOL   SOMLINK somAP_LockFolder(PWFolder *somSelf,
  109.         somId __id,
  110.         somId __desc,
  111.         va_list __ap)
  112. {
  113.     __ap; __id; __desc;           /* Referenced to prevent warning msg */
  114.  
  115.     return (PWFolder_LockFolder(somSelf));
  116. }
  117.  
  118.  
  119. /*
  120.  * Overridden method: wpInitData
  121.  */
  122. #pragma linkage(pwfolder_wpInitData, system)
  123. SOM_Scope void   SOMLINK pwfolder_wpInitData(PWFolder *somSelf);
  124. #ifndef parent_wpInitData
  125. static char *somMN_wpInitData = "wpInitData";
  126. static somId somId_wpInitData = &somMN_wpInitData;
  127. #define parent_wpInitData(somSelf) \
  128.     ((SOM_ParentResolveE(WPObject, SOM_CurrentClass, wpInitData)) \
  129.      (somSelf))
  130. #endif
  131. #define PWFolderParent_wpInitData parent_wpInitData
  132.  
  133. /*
  134.  * Overridden method: wpModifyPopupMenu
  135.  */
  136. #pragma linkage(pwfolder_wpModifyPopupMenu, system)
  137. SOM_Scope BOOL   SOMLINK pwfolder_wpModifyPopupMenu(PWFolder *somSelf,
  138.         HWND hwndMenu,
  139.         HWND hwndCnr,
  140.         ULONG iPosition);
  141. #ifndef parent_wpModifyPopupMenu
  142. static char *somMN_wpModifyPopupMenu = "wpModifyPopupMenu";
  143. static somId somId_wpModifyPopupMenu = &somMN_wpModifyPopupMenu;
  144. #define parent_wpModifyPopupMenu(somSelf,hwndMenu,hwndCnr,iPosition) \
  145.     ((SOM_ParentResolveE(WPObject, SOM_CurrentClass, wpModifyPopupMenu)) \
  146.      (somSelf,hwndMenu,hwndCnr,iPosition))
  147. #endif
  148. #define PWFolderParent_wpModifyPopupMenu parent_wpModifyPopupMenu
  149.  
  150. /*
  151.  * Overridden method: wpMenuItemSelected
  152.  */
  153. #pragma linkage(pwfolder_wpMenuItemSelected, system)
  154. SOM_Scope BOOL   SOMLINK pwfolder_wpMenuItemSelected(PWFolder *somSelf,
  155.         HWND hwndFrame,
  156.         ULONG ulMenuId);
  157. #ifndef parent_wpMenuItemSelected
  158. static char *somMN_wpMenuItemSelected = "wpMenuItemSelected";
  159. static somId somId_wpMenuItemSelected = &somMN_wpMenuItemSelected;
  160. #define parent_wpMenuItemSelected(somSelf,hwndFrame,ulMenuId) \
  161.     ((SOM_ParentResolveE(WPObject, SOM_CurrentClass, wpMenuItemSelected)) \
  162.      (somSelf,hwndFrame,ulMenuId))
  163. #endif
  164. #define PWFolderParent_wpMenuItemSelected parent_wpMenuItemSelected
  165.  
  166. /*
  167.  * Overridden method: wpOpen
  168.  */
  169. #pragma linkage(pwfolder_wpOpen, system)
  170. SOM_Scope HWND   SOMLINK pwfolder_wpOpen(PWFolder *somSelf,
  171.         HWND hwndCnr,
  172.         ULONG ulView,
  173.         ULONG param);
  174. #ifndef parent_wpOpen
  175. static char *somMN_wpOpen = "wpOpen";
  176. static somId somId_wpOpen = &somMN_wpOpen;
  177. #define parent_wpOpen(somSelf,hwndCnr,ulView,param) \
  178.     ((SOM_ParentResolveE(WPObject, SOM_CurrentClass, wpOpen)) \
  179.      (somSelf,hwndCnr,ulView,param))
  180. #endif
  181. #define PWFolderParent_wpOpen parent_wpOpen
  182.  
  183. /*
  184.  * Overridden method: wpSetTitle
  185.  */
  186. #pragma linkage(pwfolder_wpSetTitle, system)
  187. SOM_Scope BOOL   SOMLINK pwfolder_wpSetTitle(PWFolder *somSelf,
  188.         PSZ pszNewTitle);
  189. #ifndef parent_wpSetTitle
  190. static char *somMN_wpSetTitle = "wpSetTitle";
  191. static somId somId_wpSetTitle = &somMN_wpSetTitle;
  192. #define parent_wpSetTitle(somSelf,pszNewTitle) \
  193.     ((SOM_ParentResolveE(WPObject, SOM_CurrentClass, wpSetTitle)) \
  194.      (somSelf,pszNewTitle))
  195. #endif
  196. #define PWFolderParent_wpSetTitle parent_wpSetTitle
  197.  
  198. /*
  199.  * Overridden method: wpSetup
  200.  */
  201. #pragma linkage(pwfolder_wpSetup, system)
  202. SOM_Scope BOOL   SOMLINK pwfolder_wpSetup(PWFolder *somSelf,
  203.         PSZ pszSetupString);
  204. #ifndef parent_wpSetup
  205. static char *somMN_wpSetup = "wpSetup";
  206. static somId somId_wpSetup = &somMN_wpSetup;
  207. #define parent_wpSetup(somSelf,pszSetupString) \
  208.     ((SOM_ParentResolveE(WPObject, SOM_CurrentClass, wpSetup)) \
  209.      (somSelf,pszSetupString))
  210. #endif
  211. #define PWFolderParent_wpSetup parent_wpSetup
  212.  
  213. /*
  214.  * Overridden method: wpSaveState
  215.  */
  216. #pragma linkage(pwfolder_wpSaveState, system)
  217. SOM_Scope BOOL   SOMLINK pwfolder_wpSaveState(PWFolder *somSelf);
  218. #ifndef parent_wpSaveState
  219. static char *somMN_wpSaveState = "wpSaveState";
  220. static somId somId_wpSaveState = &somMN_wpSaveState;
  221. #define parent_wpSaveState(somSelf) \
  222.     ((SOM_ParentResolveE(WPObject, SOM_CurrentClass, wpSaveState)) \
  223.      (somSelf))
  224. #endif
  225. #define PWFolderParent_wpSaveState parent_wpSaveState
  226.  
  227. /*
  228.  * Overridden method: wpRestoreState
  229.  */
  230. #pragma linkage(pwfolder_wpRestoreState, system)
  231. SOM_Scope BOOL   SOMLINK pwfolder_wpRestoreState(PWFolder *somSelf,
  232.         ULONG ulReserved);
  233. #ifndef parent_wpRestoreState
  234. static char *somMN_wpRestoreState = "wpRestoreState";
  235. static somId somId_wpRestoreState = &somMN_wpRestoreState;
  236. #define parent_wpRestoreState(somSelf,ulReserved) \
  237.     ((SOM_ParentResolveE(WPObject, SOM_CurrentClass, wpRestoreState)) \
  238.      (somSelf,ulReserved))
  239. #endif
  240. #define PWFolderParent_wpRestoreState parent_wpRestoreState
  241.  
  242. /*
  243.  * Overridden method: wpSetIcon
  244.  */
  245. #pragma linkage(pwfolder_wpSetIcon, system)
  246. SOM_Scope BOOL   SOMLINK pwfolder_wpSetIcon(PWFolder *somSelf,
  247.         HPOINTER hptrNewIcon);
  248. #ifndef parent_wpSetIcon
  249. static char *somMN_wpSetIcon = "wpSetIcon";
  250. static somId somId_wpSetIcon = &somMN_wpSetIcon;
  251. #define parent_wpSetIcon(somSelf,hptrNewIcon) \
  252.     ((SOM_ParentResolveE(WPObject, SOM_CurrentClass, wpSetIcon)) \
  253.      (somSelf,hptrNewIcon))
  254. #endif
  255. #define PWFolderParent_wpSetIcon parent_wpSetIcon
  256.  
  257. /*
  258.  * Temporary class data structure used only in class creation
  259.  */
  260. static somClassDataStructure PWFoldertempClassData;
  261.  
  262. /*
  263.  * Initialize the class data structure
  264.  */
  265. struct PWFolderClassDataStructure PWFolderClassData = {(SOMAny *) NULL};
  266.  
  267. /*
  268.  * Define the C class data structure
  269.  */
  270. struct PWFolderCClassDataStructure PWFolderCClassData = {(somMethodTab *) NULL};
  271.  
  272. /*
  273.  * New Method: QueryInfo
  274.  */
  275. #pragma linkage(pwfolder_QueryInfo, system)
  276. SOM_Scope BOOL   SOMLINK pwfolder_QueryInfo(PWFolder *somSelf,
  277.         PPWF_INFO pPWFolderInfo);
  278. static char *somMN_QueryInfo = "QueryInfo";
  279. static somId somId_QueryInfo = &somMN_QueryInfo;
  280. static char *somDS_QueryInfo = somMD_PWFolder_QueryInfo;
  281. static somId somDI_QueryInfo = &somDS_QueryInfo;
  282. #pragma linkage(somRD_QueryInfo, system)
  283. static BOOL   SOMLINK somRD_QueryInfo(PWFolder *somSelf,
  284.         PPWF_INFO pPWFolderInfo)
  285. {
  286.     return ((BOOL) va_somDispatchL(somSelf, somId_QueryInfo,
  287.         _somGetMethodDescriptor(SOM_GetClass(somSelf),somId_QueryInfo),pPWFolderInfo));
  288. }
  289.  
  290. /*
  291.  * New Method: SetInfo
  292.  */
  293. #pragma linkage(pwfolder_SetInfo, system)
  294. SOM_Scope BOOL   SOMLINK pwfolder_SetInfo(PWFolder *somSelf,
  295.         PPWF_INFO pPWFolderInfo);
  296. static char *somMN_SetInfo = "SetInfo";
  297. static somId somId_SetInfo = &somMN_SetInfo;
  298. static char *somDS_SetInfo = somMD_PWFolder_SetInfo;
  299. static somId somDI_SetInfo = &somDS_SetInfo;
  300. #pragma linkage(somRD_SetInfo, system)
  301. static BOOL   SOMLINK somRD_SetInfo(PWFolder *somSelf,
  302.         PPWF_INFO pPWFolderInfo)
  303. {
  304.     return ((BOOL) va_somDispatchL(somSelf, somId_SetInfo,
  305.         _somGetMethodDescriptor(SOM_GetClass(somSelf),somId_SetInfo),pPWFolderInfo));
  306. }
  307.  
  308. /*
  309.  * New Method: LockFolder
  310.  */
  311. #pragma linkage(pwfolder_LockFolder, system)
  312. SOM_Scope BOOL   SOMLINK pwfolder_LockFolder(PWFolder *somSelf);
  313. static char *somMN_LockFolder = "LockFolder";
  314. static somId somId_LockFolder = &somMN_LockFolder;
  315. static char *somDS_LockFolder = somMD_PWFolder_LockFolder;
  316. static somId somDI_LockFolder = &somDS_LockFolder;
  317. #pragma linkage(somRD_LockFolder, system)
  318. static BOOL   SOMLINK somRD_LockFolder(PWFolder *somSelf)
  319. {
  320.     return ((BOOL) va_somDispatchL(somSelf, somId_LockFolder,
  321.         _somGetMethodDescriptor(SOM_GetClass(somSelf),somId_LockFolder)));
  322. }
  323.  
  324. /*
  325.  * Routines to create the class object
  326.  */
  327.  
  328. /*
  329.  * Declare the Static Methods table.
  330.  */
  331. static somStaticMethod_t PWFolderSM[] = {
  332.     {    &PWFolderClassData.QueryInfo,
  333.          &somId_QueryInfo,
  334.          &somDI_QueryInfo,
  335.          (somMethodProc *) pwfolder_QueryInfo,
  336.          (somMethodProc *) somRD_QueryInfo,
  337.          (somMethodProc *) somAP_QueryInfo    },
  338.     {    &PWFolderClassData.SetInfo,
  339.          &somId_SetInfo,
  340.          &somDI_SetInfo,
  341.          (somMethodProc *) pwfolder_SetInfo,
  342.          (somMethodProc *) somRD_SetInfo,
  343.          (somMethodProc *) somAP_SetInfo    },
  344.     {    &PWFolderClassData.LockFolder,
  345.          &somId_LockFolder,
  346.          &somDI_LockFolder,
  347.          (somMethodProc *) pwfolder_LockFolder,
  348.          (somMethodProc *) somRD_LockFolder,
  349.          (somMethodProc *) somAP_LockFolder    },
  350. };
  351.  
  352.  
  353. /*
  354.  * Declare the Override Methods table.
  355.  */
  356. static somOverrideMethod_t PWFolderOM[] = {
  357.     {    &somId_wpInitData,
  358.          (somMethodProc *) pwfolder_wpInitData    },
  359.     {    &somId_wpModifyPopupMenu,
  360.          (somMethodProc *) pwfolder_wpModifyPopupMenu    },
  361.     {    &somId_wpMenuItemSelected,
  362.          (somMethodProc *) pwfolder_wpMenuItemSelected    },
  363.     {    &somId_wpOpen,
  364.          (somMethodProc *) pwfolder_wpOpen    },
  365.     {    &somId_wpSetTitle,
  366.          (somMethodProc *) pwfolder_wpSetTitle    },
  367.     {    &somId_wpSetup,
  368.          (somMethodProc *) pwfolder_wpSetup    },
  369.     {    &somId_wpSaveState,
  370.          (somMethodProc *) pwfolder_wpSaveState    },
  371.     {    &somId_wpRestoreState,
  372.          (somMethodProc *) pwfolder_wpRestoreState    },
  373.     {    &somId_wpSetIcon,
  374.          (somMethodProc *) pwfolder_wpSetIcon    },
  375. };
  376.  
  377. static void PWFoldersomInitializeClass ()
  378. {
  379.     int i;
  380.     somStaticMethod_t *smp;
  381.     somOverrideMethod_t *omp;
  382.  
  383. /*
  384.  * Add the Static Methods.
  385.  */
  386.     for (smp = PWFolderSM, i = 0; i < 3; smp++, i++)
  387.         *(smp->classData) =
  388.             _somAddStaticMethod (PWFoldertempClassData.classObject,
  389.                 *(smp->methodId), *(smp->methodDescriptor),
  390.                 smp->method, smp->redispatchStub,
  391.                 smp->applyStub);
  392.  
  393.  
  394. /*
  395.  * Override methods.
  396.  */
  397.     for (omp = PWFolderOM, i = 0; i < 9; omp++, i++)
  398.         _somOverrideSMethod (PWFoldertempClassData.classObject,
  399.             *(omp->methodId), omp->method);
  400.  
  401. }
  402.  
  403. #pragma linkage(PWFoldersomCreateClass, system)
  404. static void SOMLINK PWFoldersomCreateClass(SOMClass *pClsObj,
  405.                            SOMClass *mClsObj)
  406. {
  407.     PWFoldertempClassData.classObject = _somNew (mClsObj);
  408.     _somInitClass (PWFoldertempClassData.classObject,
  409.         "PWFolder",
  410.         pClsObj,
  411.         sizeof(PWFolderData),
  412.         PWFolder_MaxNoMethods,
  413.         PWFolder_MajorVersion,
  414.         PWFolder_MinorVersion);
  415.     PWFolderCClassData.instanceDataToken = 
  416.     _somGetInstanceToken(PWFoldertempClassData.classObject);
  417.     PWFoldersomInitializeClass();
  418.     PWFolderCClassData.parentMtab =
  419.     _somGetPClsMtab(PWFoldertempClassData.classObject);
  420.     _somSetClassData(PWFoldertempClassData.classObject, (somClassDataStructure *)&PWFolderClassData);
  421.     _somClassReady(PWFoldertempClassData.classObject);
  422.     /* make newly created class object visible */
  423.     PWFolderClassData.classObject = PWFoldertempClassData.classObject;
  424. }
  425.  
  426. PWFolder * SOMLINK PWFolderNewClass (integer4 scemajorVersion,
  427.         integer4 sceminorVersion)
  428. {
  429.     SOMClass *pClsObj;
  430.     SOMClass *mClsObj;
  431.  
  432.     /* Check the version numbers */
  433.     if (((scemajorVersion != 0) && 
  434.          (scemajorVersion != PWFolder_MajorVersion)) ||
  435.         ((sceminorVersion != 0) && 
  436.          (sceminorVersion > PWFolder_MinorVersion))) {
  437.     somPrintf("PWFolderNewClass: Error, bad version numbers.\n");
  438.     SOM_Error(SOMERROR_BadVersion);
  439.     }
  440.     /* Don't do anything if class object is already created. */
  441.     if (PWFolderClassData.classObject != (SOMAny *) NULL)
  442.     return(PWFolderClassData.classObject);
  443.  
  444.     /* Make sure the environment is initialized. */
  445.     if (SOMClassMgrObject == (SOMAny *) NULL) somEnvironmentNew();
  446.     if (SOMClassMgrObject == (SOMAny *) NULL)
  447.     SOM_Error(SOMERROR_CouldNotStartup);
  448.  
  449.     /* Get the parent class object. */
  450.     WPFolderNewClass(1,2);    /* static reference */
  451.     pClsObj = _somFindClass(SOMClassMgrObject,
  452.         SOM_IdFromString("WPFolder"), 1, 2);
  453.     if (pClsObj == (SOMClass *) NULL)
  454.     SOM_Error(SOMERROR_NoParentClass);
  455.  
  456.     /* Explicit metaclass, so get it */ 
  457.     M_PWFolderNewClass(0,0);    /* static reference */
  458.     mClsObj = _somFindClass(SOMClassMgrObject,
  459.         SOM_IdFromString("M_PWFolder"), 0, 0);
  460.     if (mClsObj == (SOMClass *) NULL)
  461.     SOM_Error(SOMERROR_NoMetaClass);
  462.  
  463.     somConstructClass(PWFoldersomCreateClass, pClsObj, mClsObj,
  464.              &PWFoldertempClassData);
  465.     return (PWFolderClassData.classObject);
  466. }
  467.  
  468. #endif                   /* PWFolder_Class_Source */
  469.  
  470. #endif       /* pwfolder_ih */
  471.  
  472. /*
  473.  * This file was generated by the SOM Compiler.
  474.  * FileName: pwfolder.ih.
  475.  * Generated using:
  476.  *     SOM Precompiler spc: 1.22
  477.  *     SOM Emitter emitih: 1.59
  478.  */
  479.  
  480. #ifndef pwfolder_mih
  481. #define pwfolder_mih
  482.  
  483.  
  484. /*
  485.  * Set the scope of methods functions
  486.  */
  487. #ifndef SOM_Scope
  488. #ifdef __cplusplus
  489. #define SOM_Scope extern "C"
  490. #else
  491. #define SOM_Scope extern
  492. #endif
  493. #endif
  494.  
  495. #ifndef SOM_CurrentClass
  496. #define SOM_CurrentClass M_PWFolderCClassData.parentMtab
  497. #endif
  498.  
  499. #define M_PWFolder_MaxNoMethods 0
  500.  
  501. /*
  502.  * Instance data
  503.  */
  504. typedef void M_PWFolderData;
  505.  
  506. /*
  507.  * Trace/Debug macro
  508.  */
  509. #ifndef M_PWFolderMethodDebug
  510. #define M_PWFolderMethodDebug(c,m) SOMMethodDebug(c,m)
  511. #endif
  512.  
  513. /*
  514.  * Begin stuff that only goes in the primary file
  515.  */
  516. #ifdef M_PWFolder_Class_Source
  517.  
  518. /*
  519.  * Current class macros for Instance and Meta classes.
  520.  */
  521.  
  522. /*
  523.  * Generate the Apply Stubs.
  524.  */
  525.  
  526. /*
  527.  * Overridden method: wpclsQueryTitle
  528.  */
  529. #pragma linkage(pwfoldercls_wpclsQueryTitle, system)
  530. SOM_Scope PSZ   SOMLINK pwfoldercls_wpclsQueryTitle(M_PWFolder *somSelf);
  531. #ifndef parent_wpclsQueryTitle
  532. static char *somMN_wpclsQueryTitle = "wpclsQueryTitle";
  533. static somId somId_wpclsQueryTitle = &somMN_wpclsQueryTitle;
  534. #define parent_wpclsQueryTitle(somSelf) \
  535.     ((SOM_ParentResolveE(M_WPObject, SOM_CurrentClass, wpclsQueryTitle)) \
  536.      (somSelf))
  537. #endif
  538. #define M_PWFolderParent_wpclsQueryTitle parent_wpclsQueryTitle
  539.  
  540. /*
  541.  * Overridden method: wpclsInitData
  542.  */
  543. #pragma linkage(pwfoldercls_wpclsInitData, system)
  544. SOM_Scope void   SOMLINK pwfoldercls_wpclsInitData(M_PWFolder *somSelf);
  545. #ifndef parent_wpclsInitData
  546. static char *somMN_wpclsInitData = "wpclsInitData";
  547. static somId somId_wpclsInitData = &somMN_wpclsInitData;
  548. #define parent_wpclsInitData(somSelf) \
  549.     ((SOM_ParentResolveE(M_WPObject, SOM_CurrentClass, wpclsInitData)) \
  550.      (somSelf))
  551. #endif
  552. #define M_PWFolderParent_wpclsInitData parent_wpclsInitData
  553.  
  554. /*
  555.  * Overridden method: wpclsQueryIcon
  556.  */
  557. #pragma linkage(pwfoldercls_wpclsQueryIcon, system)
  558. SOM_Scope HPOINTER   SOMLINK pwfoldercls_wpclsQueryIcon(M_PWFolder *somSelf);
  559. #ifndef parent_wpclsQueryIcon
  560. static char *somMN_wpclsQueryIcon = "wpclsQueryIcon";
  561. static somId somId_wpclsQueryIcon = &somMN_wpclsQueryIcon;
  562. #define parent_wpclsQueryIcon(somSelf) \
  563.     ((SOM_ParentResolveE(M_WPObject, SOM_CurrentClass, wpclsQueryIcon)) \
  564.      (somSelf))
  565. #endif
  566. #define M_PWFolderParent_wpclsQueryIcon parent_wpclsQueryIcon
  567.  
  568. /*
  569.  * Overridden method: wpclsUnInitData
  570.  */
  571. #pragma linkage(pwfoldercls_wpclsUnInitData, system)
  572. SOM_Scope void   SOMLINK pwfoldercls_wpclsUnInitData(M_PWFolder *somSelf);
  573. #ifndef parent_wpclsUnInitData
  574. static char *somMN_wpclsUnInitData = "wpclsUnInitData";
  575. static somId somId_wpclsUnInitData = &somMN_wpclsUnInitData;
  576. #define parent_wpclsUnInitData(somSelf) \
  577.     ((SOM_ParentResolveE(M_WPObject, SOM_CurrentClass, wpclsUnInitData)) \
  578.      (somSelf))
  579. #endif
  580. #define M_PWFolderParent_wpclsUnInitData parent_wpclsUnInitData
  581.  
  582. /*
  583.  * Temporary class data structure used only in class creation
  584.  */
  585. static somClassDataStructure M_PWFoldertempClassData;
  586.  
  587. /*
  588.  * Initialize the class data structure
  589.  */
  590. struct M_PWFolderClassDataStructure M_PWFolderClassData = {(SOMAny *) NULL};
  591.  
  592. /*
  593.  * Define the C class data structure
  594.  */
  595. struct M_PWFolderCClassDataStructure M_PWFolderCClassData = {(somMethodTab *) NULL};
  596.  
  597. /*
  598.  * Routines to create the class object
  599.  */
  600.  
  601. /*
  602.  * Declare the Override Methods table.
  603.  */
  604. static somOverrideMethod_t M_PWFolderOM[] = {
  605.     {    &somId_wpclsQueryTitle,
  606.          (somMethodProc *) pwfoldercls_wpclsQueryTitle    },
  607.     {    &somId_wpclsInitData,
  608.          (somMethodProc *) pwfoldercls_wpclsInitData    },
  609.     {    &somId_wpclsQueryIcon,
  610.          (somMethodProc *) pwfoldercls_wpclsQueryIcon    },
  611.     {    &somId_wpclsUnInitData,
  612.          (somMethodProc *) pwfoldercls_wpclsUnInitData    },
  613. };
  614.  
  615. static void M_PWFoldersomInitializeClass ()
  616. {
  617.     int i;
  618.     somOverrideMethod_t *omp;
  619.  
  620. /*
  621.  * Override methods.
  622.  */
  623.     for (omp = M_PWFolderOM, i = 0; i < 4; omp++, i++)
  624.         _somOverrideSMethod (M_PWFoldertempClassData.classObject,
  625.             *(omp->methodId), omp->method);
  626.  
  627. }
  628.  
  629. #pragma linkage(M_PWFoldersomCreateClass, system)
  630. static void SOMLINK M_PWFoldersomCreateClass(SOMClass *pClsObj,
  631.                            SOMClass *mClsObj)
  632. {
  633.     M_PWFoldertempClassData.classObject = _somNew (mClsObj);
  634.     _somInitClass (M_PWFoldertempClassData.classObject,
  635.         "M_PWFolder",
  636.         pClsObj,
  637.         0,
  638.         M_PWFolder_MaxNoMethods,
  639.         M_PWFolder_MajorVersion,
  640.         M_PWFolder_MinorVersion);
  641.     M_PWFolderCClassData.instanceDataToken = 
  642.     _somGetInstanceToken(M_PWFoldertempClassData.classObject);
  643.     M_PWFoldersomInitializeClass();
  644.     M_PWFolderCClassData.parentMtab =
  645.     _somGetPClsMtab(M_PWFoldertempClassData.classObject);
  646.     _somSetClassData(M_PWFoldertempClassData.classObject, (somClassDataStructure *)&M_PWFolderClassData);
  647.     _somClassReady(M_PWFoldertempClassData.classObject);
  648.     /* make newly created class object visible */
  649.     M_PWFolderClassData.classObject = M_PWFoldertempClassData.classObject;
  650. }
  651.  
  652. M_PWFolder * SOMLINK M_PWFolderNewClass (integer4 scemajorVersion,
  653.         integer4 sceminorVersion)
  654. {
  655.     SOMClass *pClsObj;
  656.     SOMClass *mClsObj;
  657.  
  658.     /* Check the version numbers */
  659.     if (((scemajorVersion != 0) && 
  660.          (scemajorVersion != M_PWFolder_MajorVersion)) ||
  661.         ((sceminorVersion != 0) && 
  662.          (sceminorVersion > M_PWFolder_MinorVersion))) {
  663.     somPrintf("M_PWFolderNewClass: Error, bad version numbers.\n");
  664.     SOM_Error(SOMERROR_BadVersion);
  665.     }
  666.     /* Don't do anything if class object is already created. */
  667.     if (M_PWFolderClassData.classObject != (SOMAny *) NULL)
  668.     return(M_PWFolderClassData.classObject);
  669.  
  670.     /* Make sure the environment is initialized. */
  671.     if (SOMClassMgrObject == (SOMAny *) NULL) somEnvironmentNew();
  672.     if (SOMClassMgrObject == (SOMAny *) NULL)
  673.     SOM_Error(SOMERROR_CouldNotStartup);
  674.  
  675.     /* Get the parent class object. */
  676.     M_WPFolderNewClass(1,2);    /* static reference */
  677.     pClsObj = _somFindClass(SOMClassMgrObject,
  678.         SOM_IdFromString("M_WPFolder"), 1, 2);
  679.     if (pClsObj == (SOMClass *) NULL)
  680.     SOM_Error(SOMERROR_NoParentClass);
  681.  
  682.     /* Use parent's metaclass */ 
  683.     mClsObj = SOM_GetClass(pClsObj);
  684.  
  685.     somConstructClass(M_PWFoldersomCreateClass, pClsObj, mClsObj,
  686.              &M_PWFoldertempClassData);
  687.     return (M_PWFolderClassData.classObject);
  688. }
  689.  
  690. #endif                   /* M_PWFolder_Class_Source */
  691.  
  692. #endif       /* pwfolder_ih */
  693.