home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / wpsprgm.zip / AFOLDER.IH < prev    next >
Text File  |  1993-06-12  |  11KB  |  410 lines
  1.  
  2. /*
  3.  * This file was generated by the SOM Compiler.
  4.  * FileName: afolder.ih.
  5.  * Generated using:
  6.  *     SOM Precompiler spc: 1.22
  7.  *     SOM Emitter emitih: 1.59
  8.  */
  9.  
  10. #ifndef afolder_ih
  11. #define afolder_ih
  12.  
  13.  
  14. /*
  15.  * Passthru lines: File: "C.ih", "before"
  16.  */
  17.  
  18. #define INCL_WIN
  19. #define INCL_DOS
  20. #define INCL_GPIBITMAPS
  21. #include <os2.h>
  22.  
  23. #define INCL_WPCLASS
  24. #define INCL_WPFOLDER
  25.  
  26. #include <pmwp.h>
  27.  
  28. #define DebugBox(title, text) \
  29.                                     \
  30.                  WinMessageBox(     \
  31.                     HWND_DESKTOP,   \
  32.                     HWND_DESKTOP,   \
  33.                     (PSZ) text,     \
  34.                     (PSZ) title,    \
  35.                     20,             \
  36.                     MB_OK | MB_INFORMATION | MB_MOVEABLE)
  37.  
  38.  
  39.  
  40. #include "afolder.h"
  41.  
  42. /*
  43.  * Set the scope of methods functions
  44.  */
  45. #ifndef SOM_Scope
  46. #ifdef __cplusplus
  47. #define SOM_Scope extern "C"
  48. #else
  49. #define SOM_Scope extern
  50. #endif
  51. #endif
  52.  
  53. #ifndef SOM_CurrentClass
  54. #define SOM_CurrentClass aFolderCClassData.parentMtab
  55. #endif
  56.  
  57. #define aFolder_MaxNoMethods 0
  58.  
  59. /*
  60.  * Instance data
  61.  */
  62. typedef void aFolderData;
  63.  
  64. /*
  65.  * Trace/Debug macro
  66.  */
  67. #ifndef aFolderMethodDebug
  68. #define aFolderMethodDebug(c,m) SOMMethodDebug(c,m)
  69. #endif
  70.  
  71. /*
  72.  * Begin stuff that only goes in the primary file
  73.  */
  74. #ifdef aFolder_Class_Source
  75.  
  76. /*
  77.  * Current class macros for Instance and Meta classes.
  78.  */
  79. #undef SOMMeta
  80. #define SOMMeta M_aFolderCClassData.parentMtab
  81. #undef SOMInstance
  82. #define SOMInstance aFolderCClassData.parentMtab
  83.  
  84. #ifndef M_aFolder_Class_Source
  85. #define M_aFolder_Class_Source
  86. #endif    /* M_aFolder_Class_Source */
  87.  
  88. /*
  89.  * Generate the Apply Stubs.
  90.  */
  91.  
  92. /*
  93.  * Overridden method: wpOpen
  94.  */
  95. #pragma linkage(afolder_wpOpen, system)
  96. SOM_Scope HWND   SOMLINK afolder_wpOpen(aFolder *somSelf,
  97.         HWND hwndCnr,
  98.         ULONG ulView,
  99.         ULONG param);
  100. #ifndef parent_wpOpen
  101. static char *somMN_wpOpen = "wpOpen";
  102. static somId somId_wpOpen = &somMN_wpOpen;
  103. #define parent_wpOpen(somSelf,hwndCnr,ulView,param) \
  104.     ((SOM_ParentResolveE(WPObject, SOM_CurrentClass, wpOpen)) \
  105.      (somSelf,hwndCnr,ulView,param))
  106. #endif
  107. #define aFolderParent_wpOpen parent_wpOpen
  108.  
  109. /*
  110.  * Overridden method: wpMenuItemSelected
  111.  */
  112. #pragma linkage(afolder_wpMenuItemSelected, system)
  113. SOM_Scope BOOL   SOMLINK afolder_wpMenuItemSelected(aFolder *somSelf,
  114.         HWND hwndFrame,
  115.         ULONG ulMenuId);
  116. #ifndef parent_wpMenuItemSelected
  117. static char *somMN_wpMenuItemSelected = "wpMenuItemSelected";
  118. static somId somId_wpMenuItemSelected = &somMN_wpMenuItemSelected;
  119. #define parent_wpMenuItemSelected(somSelf,hwndFrame,ulMenuId) \
  120.     ((SOM_ParentResolveE(WPObject, SOM_CurrentClass, wpMenuItemSelected)) \
  121.      (somSelf,hwndFrame,ulMenuId))
  122. #endif
  123. #define aFolderParent_wpMenuItemSelected parent_wpMenuItemSelected
  124.  
  125. /*
  126.  * Temporary class data structure used only in class creation
  127.  */
  128. static somClassDataStructure aFoldertempClassData;
  129.  
  130. /*
  131.  * Initialize the class data structure
  132.  */
  133. struct aFolderClassDataStructure aFolderClassData = {(SOMAny *) NULL};
  134.  
  135. /*
  136.  * Define the C class data structure
  137.  */
  138. struct aFolderCClassDataStructure aFolderCClassData = {(somMethodTab *) NULL};
  139.  
  140. /*
  141.  * Routines to create the class object
  142.  */
  143.  
  144. /*
  145.  * Declare the Override Methods table.
  146.  */
  147. static somOverrideMethod_t aFolderOM[] = {
  148.     {    &somId_wpOpen,
  149.          (somMethodProc *) afolder_wpOpen    },
  150.     {    &somId_wpMenuItemSelected,
  151.          (somMethodProc *) afolder_wpMenuItemSelected    },
  152. };
  153.  
  154. static void aFoldersomInitializeClass ()
  155. {
  156.     int i;
  157.     somOverrideMethod_t *omp;
  158.  
  159. /*
  160.  * Override methods.
  161.  */
  162.     for (omp = aFolderOM, i = 0; i < 2; omp++, i++)
  163.         _somOverrideSMethod (aFoldertempClassData.classObject,
  164.             *(omp->methodId), omp->method);
  165.  
  166. }
  167.  
  168. #pragma linkage(aFoldersomCreateClass, system)
  169. static void SOMLINK aFoldersomCreateClass(SOMClass *pClsObj,
  170.                            SOMClass *mClsObj)
  171. {
  172.     aFoldertempClassData.classObject = _somNew (mClsObj);
  173.     _somInitClass (aFoldertempClassData.classObject,
  174.         "aFolder",
  175.         pClsObj,
  176.         0,
  177.         aFolder_MaxNoMethods,
  178.         aFolder_MajorVersion,
  179.         aFolder_MinorVersion);
  180.     aFolderCClassData.instanceDataToken = 
  181.     _somGetInstanceToken(aFoldertempClassData.classObject);
  182.     aFoldersomInitializeClass();
  183.     aFolderCClassData.parentMtab =
  184.     _somGetPClsMtab(aFoldertempClassData.classObject);
  185.     _somSetClassData(aFoldertempClassData.classObject, (somClassDataStructure *)&aFolderClassData);
  186.     _somClassReady(aFoldertempClassData.classObject);
  187.     /* make newly created class object visible */
  188.     aFolderClassData.classObject = aFoldertempClassData.classObject;
  189. }
  190.  
  191. aFolder * SOMLINK aFolderNewClass (integer4 scemajorVersion,
  192.         integer4 sceminorVersion)
  193. {
  194.     SOMClass *pClsObj;
  195.     SOMClass *mClsObj;
  196.  
  197.     /* Check the version numbers */
  198.     if (((scemajorVersion != 0) && 
  199.          (scemajorVersion != aFolder_MajorVersion)) ||
  200.         ((sceminorVersion != 0) && 
  201.          (sceminorVersion > aFolder_MinorVersion))) {
  202.     somPrintf("aFolderNewClass: Error, bad version numbers.\n");
  203.     SOM_Error(SOMERROR_BadVersion);
  204.     }
  205.     /* Don't do anything if class object is already created. */
  206.     if (aFolderClassData.classObject != (SOMAny *) NULL)
  207.     return(aFolderClassData.classObject);
  208.  
  209.     /* Make sure the environment is initialized. */
  210.     if (SOMClassMgrObject == (SOMAny *) NULL) somEnvironmentNew();
  211.     if (SOMClassMgrObject == (SOMAny *) NULL)
  212.     SOM_Error(SOMERROR_CouldNotStartup);
  213.  
  214.     /* Get the parent class object. */
  215.     WPFolderNewClass(1,2);    /* static reference */
  216.     pClsObj = _somFindClass(SOMClassMgrObject,
  217.         SOM_IdFromString("WPFolder"), 1, 2);
  218.     if (pClsObj == (SOMClass *) NULL)
  219.     SOM_Error(SOMERROR_NoParentClass);
  220.  
  221.     /* Explicit metaclass, so get it */ 
  222.     M_aFolderNewClass(0,0);    /* static reference */
  223.     mClsObj = _somFindClass(SOMClassMgrObject,
  224.         SOM_IdFromString("M_aFolder"), 0, 0);
  225.     if (mClsObj == (SOMClass *) NULL)
  226.     SOM_Error(SOMERROR_NoMetaClass);
  227.  
  228.     somConstructClass(aFoldersomCreateClass, pClsObj, mClsObj,
  229.              &aFoldertempClassData);
  230.     return (aFolderClassData.classObject);
  231. }
  232.  
  233. #endif                   /* aFolder_Class_Source */
  234.  
  235. #endif       /* afolder_ih */
  236.  
  237. /*
  238.  * This file was generated by the SOM Compiler.
  239.  * FileName: afolder.ih.
  240.  * Generated using:
  241.  *     SOM Precompiler spc: 1.22
  242.  *     SOM Emitter emitih: 1.59
  243.  */
  244.  
  245. #ifndef afolder_mih
  246. #define afolder_mih
  247.  
  248.  
  249. /*
  250.  * Set the scope of methods functions
  251.  */
  252. #ifndef SOM_Scope
  253. #ifdef __cplusplus
  254. #define SOM_Scope extern "C"
  255. #else
  256. #define SOM_Scope extern
  257. #endif
  258. #endif
  259.  
  260. #ifndef SOM_CurrentClass
  261. #define SOM_CurrentClass M_aFolderCClassData.parentMtab
  262. #endif
  263.  
  264. #define M_aFolder_MaxNoMethods 0
  265.  
  266. /*
  267.  * Instance data
  268.  */
  269. typedef void M_aFolderData;
  270.  
  271. /*
  272.  * Trace/Debug macro
  273.  */
  274. #ifndef M_aFolderMethodDebug
  275. #define M_aFolderMethodDebug(c,m) SOMMethodDebug(c,m)
  276. #endif
  277.  
  278. /*
  279.  * Begin stuff that only goes in the primary file
  280.  */
  281. #ifdef M_aFolder_Class_Source
  282.  
  283. /*
  284.  * Current class macros for Instance and Meta classes.
  285.  */
  286.  
  287. /*
  288.  * Generate the Apply Stubs.
  289.  */
  290.  
  291. /*
  292.  * Overridden method: wpclsInitData
  293.  */
  294. #pragma linkage(afolderM_wpclsInitData, system)
  295. SOM_Scope void   SOMLINK afolderM_wpclsInitData(M_aFolder *somSelf);
  296. #ifndef parent_wpclsInitData
  297. static char *somMN_wpclsInitData = "wpclsInitData";
  298. static somId somId_wpclsInitData = &somMN_wpclsInitData;
  299. #define parent_wpclsInitData(somSelf) \
  300.     ((SOM_ParentResolveE(M_WPObject, SOM_CurrentClass, wpclsInitData)) \
  301.      (somSelf))
  302. #endif
  303. #define M_aFolderParent_wpclsInitData parent_wpclsInitData
  304.  
  305. /*
  306.  * Temporary class data structure used only in class creation
  307.  */
  308. static somClassDataStructure M_aFoldertempClassData;
  309.  
  310. /*
  311.  * Initialize the class data structure
  312.  */
  313. struct M_aFolderClassDataStructure M_aFolderClassData = {(SOMAny *) NULL};
  314.  
  315. /*
  316.  * Define the C class data structure
  317.  */
  318. struct M_aFolderCClassDataStructure M_aFolderCClassData = {(somMethodTab *) NULL};
  319.  
  320. /*
  321.  * Routines to create the class object
  322.  */
  323.  
  324. /*
  325.  * Declare the Override Methods table.
  326.  */
  327. static somOverrideMethod_t M_aFolderOM[] = {
  328.     {    &somId_wpclsInitData,
  329.          (somMethodProc *) afolderM_wpclsInitData    },
  330. };
  331.  
  332. static void M_aFoldersomInitializeClass ()
  333. {
  334.     int i;
  335.     somOverrideMethod_t *omp;
  336.  
  337. /*
  338.  * Override methods.
  339.  */
  340.     for (omp = M_aFolderOM, i = 0; i < 1; omp++, i++)
  341.         _somOverrideSMethod (M_aFoldertempClassData.classObject,
  342.             *(omp->methodId), omp->method);
  343.  
  344. }
  345.  
  346. #pragma linkage(M_aFoldersomCreateClass, system)
  347. static void SOMLINK M_aFoldersomCreateClass(SOMClass *pClsObj,
  348.                            SOMClass *mClsObj)
  349. {
  350.     M_aFoldertempClassData.classObject = _somNew (mClsObj);
  351.     _somInitClass (M_aFoldertempClassData.classObject,
  352.         "M_aFolder",
  353.         pClsObj,
  354.         0,
  355.         M_aFolder_MaxNoMethods,
  356.         M_aFolder_MajorVersion,
  357.         M_aFolder_MinorVersion);
  358.     M_aFolderCClassData.instanceDataToken = 
  359.     _somGetInstanceToken(M_aFoldertempClassData.classObject);
  360.     M_aFoldersomInitializeClass();
  361.     M_aFolderCClassData.parentMtab =
  362.     _somGetPClsMtab(M_aFoldertempClassData.classObject);
  363.     _somSetClassData(M_aFoldertempClassData.classObject, (somClassDataStructure *)&M_aFolderClassData);
  364.     _somClassReady(M_aFoldertempClassData.classObject);
  365.     /* make newly created class object visible */
  366.     M_aFolderClassData.classObject = M_aFoldertempClassData.classObject;
  367. }
  368.  
  369. M_aFolder * SOMLINK M_aFolderNewClass (integer4 scemajorVersion,
  370.         integer4 sceminorVersion)
  371. {
  372.     SOMClass *pClsObj;
  373.     SOMClass *mClsObj;
  374.  
  375.     /* Check the version numbers */
  376.     if (((scemajorVersion != 0) && 
  377.          (scemajorVersion != M_aFolder_MajorVersion)) ||
  378.         ((sceminorVersion != 0) && 
  379.          (sceminorVersion > M_aFolder_MinorVersion))) {
  380.     somPrintf("M_aFolderNewClass: Error, bad version numbers.\n");
  381.     SOM_Error(SOMERROR_BadVersion);
  382.     }
  383.     /* Don't do anything if class object is already created. */
  384.     if (M_aFolderClassData.classObject != (SOMAny *) NULL)
  385.     return(M_aFolderClassData.classObject);
  386.  
  387.     /* Make sure the environment is initialized. */
  388.     if (SOMClassMgrObject == (SOMAny *) NULL) somEnvironmentNew();
  389.     if (SOMClassMgrObject == (SOMAny *) NULL)
  390.     SOM_Error(SOMERROR_CouldNotStartup);
  391.  
  392.     /* Get the parent class object. */
  393.     M_WPFolderNewClass(1,2);    /* static reference */
  394.     pClsObj = _somFindClass(SOMClassMgrObject,
  395.         SOM_IdFromString("M_WPFolder"), 1, 2);
  396.     if (pClsObj == (SOMClass *) NULL)
  397.     SOM_Error(SOMERROR_NoParentClass);
  398.  
  399.     /* Use parent's metaclass */ 
  400.     mClsObj = SOM_GetClass(pClsObj);
  401.  
  402.     somConstructClass(M_aFoldersomCreateClass, pClsObj, mClsObj,
  403.              &M_aFoldertempClassData);
  404.     return (M_aFolderClassData.classObject);
  405. }
  406.  
  407. #endif                   /* M_aFolder_Class_Source */
  408.  
  409. #endif       /* afolder_ih */
  410.