home *** CD-ROM | disk | FTP | other *** search
/ PC PowerPlay 22 / PCPP #22.iso / Quake2 / q2source_12_11 / utils3 / qe4 / mru.c < prev    next >
Encoding:
C/C++ Source or Header  |  1997-06-23  |  18.6 KB  |  650 lines
  1. //*************************************************************
  2. //  File name: mru.c
  3. //
  4. //  Description:
  5. //
  6. //      Routines for MRU support
  7. //
  8. //  Development Team:
  9. //
  10. //      Gilles Vollant (100144.2636@compuserve.com) 
  11. //
  12. //*************************************************************
  13.  
  14. #include <windows.h>
  15. #include <windowsx.h>
  16. #include <string.h>
  17.  
  18. #include "mru.h"
  19. // CreateMruMenu  : MRUMENU constructor
  20. // wNbLruShowInit : nb of item showed in menu
  21. // wNbLruMenuInit : nb of item stored in memory
  22. // wMaxSizeLruItemInit : size max. of filename
  23.  
  24.  
  25. //*************************************************************
  26. //
  27. //  CreateMruMenu()
  28. //
  29. //  Purpose:
  30. //
  31. //              Allocate and Initialize an MRU and return a pointer on it
  32. //
  33. //
  34. //  Parameters:
  35. //
  36. //      WORD wNbLruShowInit -      Maximum number of item displayed on menu
  37. //      WORD wNbLruMenuInit -      Maximum number of item stored in memory
  38. //      WORD wMaxSizeLruItemInit - Maximum size of an item (ie size of pathname)
  39. //      WORD wIdMruInit -          ID of the first item in the menu (default:IDMRU)
  40. //
  41. //
  42. //  Return: (LPMRUMENU)
  43. //
  44. //      Pointer on a MRUMENU structure, used by other function
  45. //
  46. //
  47. //  Comments:
  48. //      wNbLruShowInit <= wNbLruMenuInit
  49. //
  50. //
  51. //  History:    Date       Author       Comment
  52. //              09/24/94   G. Vollant   Created
  53. //
  54. //*************************************************************
  55.  
  56. LPMRUMENU CreateMruMenu (WORD wNbLruShowInit,
  57.             WORD wNbLruMenuInit,WORD wMaxSizeLruItemInit,WORD wIdMruInit)
  58. {
  59. LPMRUMENU lpMruMenu;
  60.   lpMruMenu = (LPMRUMENU)GlobalAllocPtr(GHND,sizeof(MRUMENU));
  61.  
  62.   lpMruMenu->wNbItemFill = 0;                   
  63.   lpMruMenu->wNbLruMenu = wNbLruMenuInit;             
  64.   lpMruMenu->wNbLruShow = wNbLruShowInit;
  65.   lpMruMenu->wIdMru = wIdMruInit;
  66.   lpMruMenu->wMaxSizeLruItem = wMaxSizeLruItemInit;
  67.   lpMruMenu->lpMRU = (LPSTR)GlobalAllocPtr(GHND,
  68.                       lpMruMenu->wNbLruMenu*(UINT)lpMruMenu->wMaxSizeLruItem);
  69.   if (lpMruMenu->lpMRU == NULL)
  70.      {
  71.        GlobalFreePtr(lpMruMenu);
  72.        lpMruMenu =  NULL;
  73.      }
  74.   return lpMruMenu;
  75. }
  76.  
  77. //*************************************************************
  78. //
  79. //  CreateMruMenuDefault()
  80. //
  81. //  Purpose:
  82. //
  83. //              Allocate and Initialize an MRU and return a pointer on it
  84. //              Use default parameter
  85. //
  86. //
  87. //  Parameters:
  88. //
  89. //
  90. //  Return: (LPMRUMENU)
  91. //
  92. //      Pointer on a MRUMENU structure, used by other function
  93. //
  94. //
  95. //  Comments:
  96. //
  97. //
  98. //  History:    Date       Author       Comment
  99. //              09/24/94   G. Vollant   Created
  100. //
  101. //*************************************************************
  102.  
  103. LPMRUMENU CreateMruMenuDefault()
  104. {
  105.   return CreateMruMenu (NBMRUMENUSHOW,NBMRUMENU,MAXSIZEMRUITEM,IDMRU);
  106. }
  107.  
  108.  
  109. //*************************************************************
  110. //
  111. //  DeleteMruMenu()
  112. //
  113. //  Purpose:
  114. //              Destructor :
  115. //              Clean and free a MRUMENU structure
  116. //
  117. //  Parameters:
  118. //
  119. //      LPMRUMENU lpMruMenu -      pointer on MRUMENU, allocated
  120. //             by CreateMruMenu() or CreateMruMenuDefault()
  121. //
  122. //
  123. //  Return: void
  124. //
  125. //
  126. //  Comments:
  127. //
  128. //
  129. //  History:    Date       Author       Comment
  130. //              09/24/94   G. Vollant   Created
  131. //
  132. //*************************************************************
  133. void DeleteMruMenu(LPMRUMENU lpMruMenu)
  134. {
  135.   GlobalFreePtr(lpMruMenu->lpMRU);
  136.   GlobalFreePtr(lpMruMenu);
  137. }
  138.  
  139. //*************************************************************
  140. //
  141. //  SetNbLruShow()
  142. //
  143. //  Purpose:
  144. //              Change the maximum number of item displayed on menu
  145. //
  146. //  Parameters:
  147. //      LPMRUMENU lpMruMenu -      pointer on MRUMENU
  148. //      WORD wNbLruShowInit -      Maximum number of item displayed on menu
  149. //
  150. //
  151. //  Return: void
  152. //
  153. //
  154. //  Comments:
  155. //
  156. //
  157. //  History:    Date       Author       Comment
  158. //              09/24/94   G. Vollant   Created
  159. //
  160. //*************************************************************
  161. void SetNbLruShow   (LPMRUMENU lpMruMenu,WORD wNbLruShowInit)
  162. {
  163.   lpMruMenu->wNbLruShow = min(wNbLruShowInit,lpMruMenu->wNbLruMenu);
  164. }
  165.  
  166. //*************************************************************
  167. //
  168. //  SetMenuItem()
  169. //
  170. //  Purpose:
  171. //              Set the filename of an item 
  172. //
  173. //  Parameters:
  174. //      LPMRUMENU lpMruMenu -      pointer on MRUMENU
  175. //      WORD wItem -               Number of Item to set, zero based
  176. //      LPSTR lpItem -             String, contain the filename of the item
  177. //
  178. //
  179. //  Return: (BOOL)
  180. //      TRUE  - Function run successfully
  181. //      FALSE - Function don't run successfully
  182. //
  183. //
  184. //  Comments:
  185. //      used when load .INI or reg database
  186. //
  187. //  History:    Date       Author       Comment
  188. //              09/24/94   G. Vollant   Created
  189. //
  190. //*************************************************************
  191. BOOL SetMenuItem    (LPMRUMENU lpMruMenu,WORD wItem,LPSTR lpItem)
  192. {                                      
  193.   if (wItem >= NBMRUMENU) 
  194.     return FALSE;
  195.   _fstrncpy((lpMruMenu->lpMRU) + 
  196.             ((lpMruMenu->wMaxSizeLruItem) * (UINT)wItem),
  197.             lpItem,lpMruMenu->wMaxSizeLruItem-1);
  198.   lpMruMenu->wNbItemFill = max(lpMruMenu->wNbItemFill,wItem+1);
  199.   return TRUE;
  200. }
  201.  
  202. //*************************************************************
  203. //
  204. //  GetMenuItem()
  205. //
  206. //  Purpose:
  207. //              Get the filename of an item 
  208. //
  209. //  Parameters:
  210. //      LPMRUMENU lpMruMenu -      pointer on MRUMENU
  211. //      WORD wItem -               Number of Item to set, zero based
  212. //      BOOL fIDMBased -           TRUE :  wItem is based on ID menu item
  213. //                                 FALSE : wItem is zero-based
  214. //      LPSTR lpItem -             String where the filename of the item will be
  215. //                                   stored by GetMenuItem()
  216. //      UINT  uiSize -             Size of the lpItem buffer
  217. //
  218. //
  219. //  Return: (BOOL)
  220. //      TRUE  - Function run successfully
  221. //      FALSE - Function don't run successfully
  222. //
  223. //
  224. //  Comments:
  225. //      Used for saving in .INI or reg database, or when user select
  226. //        an MRU in File menu
  227. //
  228. //  History:    Date       Author       Comment
  229. //              09/24/94   G. Vollant   Created
  230. //
  231. //*************************************************************
  232. BOOL GetMenuItem    (LPMRUMENU lpMruMenu,WORD wItem,
  233.                      BOOL fIDMBased,LPSTR lpItem,UINT uiSize)
  234. {
  235.   if (fIDMBased) 
  236.     wItem -= (lpMruMenu->wIdMru + 1);
  237.   if (wItem >= lpMruMenu->wNbItemFill) 
  238.     return FALSE;
  239.   _fstrncpy(lpItem,(lpMruMenu->lpMRU) + 
  240.                 ((lpMruMenu->wMaxSizeLruItem) * (UINT)(wItem)),uiSize);
  241.   *(lpItem+uiSize-1) = '\0';
  242.   return TRUE;
  243. }
  244.  
  245. //*************************************************************
  246. //
  247. //  AddNewItem()
  248. //
  249. //  Purpose:
  250. //              Add an item at the begin of the list
  251. //
  252. //  Parameters:
  253. //      LPMRUMENU lpMruMenu -      pointer on MRUMENU
  254. //      LPSTR lpItem -             String contain the filename to add
  255. //
  256. //  Return: (BOOL)
  257. //      TRUE  - Function run successfully
  258. //      FALSE - Function don't run successfully
  259. //
  260. //
  261. //  Comments:
  262. //      Used when used open a file (using File Open common
  263. //        dialog, Drag and drop or MRU)
  264. //
  265. //  History:    Date       Author       Comment
  266. //              09/24/94   G. Vollant   Created
  267. //
  268. //*************************************************************
  269. void AddNewItem     (LPMRUMENU lpMruMenu,LPSTR lpItem)
  270. {
  271. WORD i,j;
  272.   for (i=0;i<lpMruMenu->wNbItemFill;i++)
  273.     if (lstrcmpi(lpItem,(lpMruMenu->lpMRU) + 
  274.         ((lpMruMenu->wMaxSizeLruItem) * (UINT)i)) == 0)
  275.       {         
  276.         // Shift the other items
  277.         for (j=i;j>0;j--)
  278.          lstrcpy((lpMruMenu->lpMRU) + (lpMruMenu->wMaxSizeLruItem * (UINT)j),
  279.                  (lpMruMenu->lpMRU) + (lpMruMenu->wMaxSizeLruItem * (UINT)(j-1)));
  280.         _fstrncpy(lpMruMenu->lpMRU,lpItem,lpMruMenu->wMaxSizeLruItem-1);  
  281.         return ;
  282.       }
  283.   lpMruMenu->wNbItemFill = min(lpMruMenu->wNbItemFill+1,lpMruMenu->wNbLruMenu);
  284.   for (i=lpMruMenu->wNbItemFill-1;i>0;i--)
  285.      lstrcpy(lpMruMenu->lpMRU + (lpMruMenu->wMaxSizeLruItem * (UINT)i),
  286.              lpMruMenu->lpMRU + (lpMruMenu->wMaxSizeLruItem * (UINT)(i-1)));
  287.   _fstrncpy(lpMruMenu->lpMRU,lpItem,lpMruMenu->wMaxSizeLruItem-1);  
  288. }
  289.  
  290. //*************************************************************
  291. //
  292. //  DelMenuItem()
  293. //
  294. //  Purpose:
  295. //              Delete an item
  296. //
  297. //  Parameters:
  298. //      LPMRUMENU lpMruMenu -      pointer on MRUMENU
  299. //      WORD wItem -               Number of Item to set, zero based
  300. //      BOOL fIDMBased -           TRUE :  wItem is based on ID menu item
  301. //                                 FALSE : wItem is zero-based
  302. //
  303. //  Return: (BOOL)
  304. //      TRUE  - Function run successfully
  305. //      FALSE - Function don't run successfully
  306. //
  307. //
  308. //  Comments:
  309. //      Used when used open a file, using MRU, and when an error
  310. //         occured (by example, when file was deleted)
  311. //
  312. //  History:    Date       Author       Comment
  313. //              09/24/94   G. Vollant   Created
  314. //
  315. //*************************************************************
  316. BOOL DelMenuItem(LPMRUMENU lpMruMenu,WORD wItem,BOOL fIDMBased)
  317. { 
  318. WORD i;
  319.   if (fIDMBased) 
  320.     wItem -= (lpMruMenu->wIdMru + 1);
  321.   if (lpMruMenu->wNbItemFill <= wItem) 
  322.     return FALSE;
  323.   lpMruMenu->wNbItemFill--;
  324.   for (i=wItem;i<lpMruMenu->wNbItemFill;i++)
  325.      lstrcpy(lpMruMenu->lpMRU + (lpMruMenu->wMaxSizeLruItem * (UINT)i),
  326.              lpMruMenu->lpMRU + (lpMruMenu->wMaxSizeLruItem * (UINT)(i+1)));
  327.   return TRUE;
  328. }
  329.                            
  330. //*************************************************************
  331. //
  332. //  PlaceMenuMRUItem()
  333. //
  334. //  Purpose:
  335. //              Add MRU at the end of a menu
  336. //
  337. //  Parameters:
  338. //      LPMRUMENU lpMruMenu -      pointer on MRUMENU
  339. //      HMENU hMenu -              Handle of menu where MRU must be added
  340. //      UINT uiItem -              Item of menu entry where MRU must be added
  341. //
  342. //  Return: void
  343. //
  344. //
  345. //  Comments:
  346. //      Used MRU is modified, for refresh the File menu
  347. //
  348. //  History:    Date       Author       Comment
  349. //              09/24/94   G. Vollant   Created
  350. //
  351. //*************************************************************
  352. void PlaceMenuMRUItem(LPMRUMENU lpMruMenu,HMENU hMenu,UINT uiItem)
  353. {
  354. int  i;   
  355. WORD wNbShow;
  356.   if (hMenu == NULL) 
  357.     return;
  358.   // remove old MRU in menu
  359.   for (i=0;i<=(int)(lpMruMenu->wNbLruMenu);i++)
  360.     RemoveMenu(hMenu,i+lpMruMenu->wIdMru,MF_BYCOMMAND);
  361.  
  362.   if (lpMruMenu->wNbItemFill == 0) 
  363.     return;
  364.  
  365.   // If they are item, insert a separator before the files
  366.   InsertMenu(hMenu,uiItem,MF_SEPARATOR,lpMruMenu->wIdMru,NULL);
  367.  
  368.   wNbShow = min(lpMruMenu->wNbItemFill,lpMruMenu->wNbLruShow);
  369.   for (i=(int)wNbShow-1;i>=0;i--)
  370.   {
  371.   LPSTR lpTxt;
  372.     if (lpTxt = (LPSTR)GlobalAllocPtr(GHND,lpMruMenu->wMaxSizeLruItem + 20))
  373.       {
  374.         wsprintf(lpTxt,"&%lu %s",
  375.                  (DWORD)(i+1),lpMruMenu->lpMRU + (lpMruMenu->wMaxSizeLruItem*(UINT)i));
  376.         InsertMenu(hMenu,(((WORD)i)!=(wNbShow-1)) ? (lpMruMenu->wIdMru+i+2) : lpMruMenu->wIdMru,
  377.                    MF_STRING,lpMruMenu->wIdMru+i+1,lpTxt);   
  378.         GlobalFreePtr(lpTxt);
  379.       }
  380.   }
  381.  
  382. }
  383.  
  384. ///////////////////////////////////////////
  385.  
  386.  
  387.  
  388. //*************************************************************
  389. //
  390. //  SaveMruInIni()
  391. //
  392. //  Purpose:
  393. //              Save MRU in a private .INI
  394. //
  395. //  Parameters:
  396. //      LPMRUMENU lpMruMenu -      pointer on MRUMENU
  397. //      LPSTR lpszSection  -       Points to a null-terminated string containing
  398. //                                      the name of the section 
  399. //      LPSTR lpszFile -           Points to a null-terminated string that names 
  400. //                                      the initialization file. 
  401. //
  402. //  Return: (BOOL)
  403. //      TRUE  - Function run successfully
  404. //      FALSE - Function don't run successfully
  405. //
  406. //
  407. //  Comments:
  408. //      See WritePrivateProfileString API for more info on lpszSection and lpszFile
  409. //
  410. //  History:    Date       Author       Comment
  411. //              09/24/94   G. Vollant   Created
  412. //
  413. //*************************************************************
  414. BOOL SaveMruInIni(LPMRUMENU lpMruMenu,LPSTR lpszSection,LPSTR lpszFile)
  415. {
  416. LPSTR lpTxt;
  417. WORD i;
  418.  
  419.   lpTxt = (LPSTR)GlobalAllocPtr(GHND,lpMruMenu->wMaxSizeLruItem + 20);
  420.   if (lpTxt == NULL) 
  421.     return FALSE;
  422.  
  423.   for (i=0;i<lpMruMenu->wNbLruMenu;i++)
  424.     {
  425.     char szEntry[16];
  426.       wsprintf(szEntry,"File%lu",(DWORD)i+1);
  427.       if (!GetMenuItem(lpMruMenu,i,FALSE,lpTxt,lpMruMenu->wMaxSizeLruItem + 10))
  428.         *lpTxt = '\0';
  429.       WritePrivateProfileString(lpszSection,szEntry,lpTxt,lpszFile);
  430.     }
  431.   GlobalFreePtr(lpTxt);
  432.   WritePrivateProfileString(NULL,NULL,NULL,lpszFile); // flush cache 
  433.   return TRUE;
  434. }
  435.  
  436.  
  437. //*************************************************************
  438. //
  439. //  LoadMruInIni()
  440. //
  441. //  Purpose:
  442. //              Load MRU from a private .INI
  443. //
  444. //  Parameters:
  445. //      LPMRUMENU lpMruMenu -      pointer on MRUMENU
  446. //      LPSTR lpszSection  -       Points to a null-terminated string containing
  447. //                                      the name of the section 
  448. //      LPSTR lpszFile -           Points to a null-terminated string that names 
  449. //                                      the initialization file. 
  450. //
  451. //  Return: (BOOL)
  452. //      TRUE  - Function run successfully
  453. //      FALSE - Function don't run successfully
  454. //
  455. //
  456. //  Comments:
  457. //      See GetPrivateProfileString API for more info on lpszSection and lpszFile
  458. //
  459. //  History:    Date       Author       Comment
  460. //              09/24/94   G. Vollant   Created
  461. //
  462. //*************************************************************
  463. BOOL LoadMruInIni(LPMRUMENU lpMruMenu,LPSTR lpszSection,LPSTR lpszFile)
  464. {
  465. LPSTR lpTxt;
  466. WORD i;
  467.   lpTxt = (LPSTR)GlobalAllocPtr(GHND,lpMruMenu->wMaxSizeLruItem + 20);
  468.   if (lpTxt == NULL) 
  469.     return FALSE;
  470.  
  471.   for (i=0;i<lpMruMenu->wNbLruMenu;i++)
  472.     {
  473.     char szEntry[16];
  474.       
  475.       wsprintf(szEntry,"File%lu",(DWORD)i+1);
  476.       GetPrivateProfileString(lpszSection,szEntry,"",lpTxt,
  477.                               lpMruMenu->wMaxSizeLruItem + 10,lpszFile);
  478.       if (*lpTxt == '\0')
  479.         break;
  480.       SetMenuItem(lpMruMenu,i,lpTxt);
  481.     }
  482.   GlobalFreePtr(lpTxt);
  483.   return TRUE;
  484. }
  485.  
  486. #ifdef WIN32
  487.  
  488. BOOL IsWin395OrHigher(void)
  489. {
  490.   WORD wVer;
  491.  
  492.   wVer = LOWORD(GetVersion());
  493.   wVer = (((WORD)LOBYTE(wVer)) << 8) | (WORD)HIBYTE(wVer);
  494.  
  495.   return (wVer >= 0x035F);              // 5F = 95 dec
  496. }
  497.  
  498.  
  499. //*************************************************************
  500. //
  501. //  SaveMruInReg()
  502. //
  503. //  Purpose:
  504. //              Save MRU in the registry
  505. //
  506. //  Parameters:
  507. //      LPMRUMENU lpMruMenu -      pointer on MRUMENU
  508. //      LPSTR lpszKey  -           Points to a null-terminated string 
  509. //                                      specifying  the name of a key that 
  510. //                                      this function opens or creates.
  511. //
  512. //  Return: (BOOL)
  513. //      TRUE  - Function run successfully
  514. //      FALSE - Function don't run successfully
  515. //
  516. //
  517. //  Comments:
  518. //      Win32 function designed for Windows NT and Windows 95
  519. //      See RegCreateKeyEx API for more info on lpszKey
  520. //
  521. //  History:    Date       Author       Comment
  522. //              09/24/94   G. Vollant   Created
  523. //
  524. //*************************************************************
  525. BOOL SaveMruInReg(LPMRUMENU lpMruMenu,LPSTR lpszKey)
  526. {
  527. LPSTR lpTxt;
  528. WORD i;
  529. HKEY hCurKey;
  530. DWORD dwDisp;
  531.  
  532.   lpTxt = (LPSTR)GlobalAllocPtr(GHND,lpMruMenu->wMaxSizeLruItem + 20);
  533.   if (lpTxt == NULL) 
  534.     return FALSE;
  535.  
  536.   RegCreateKeyEx(HKEY_CURRENT_USER,lpszKey,0,NULL,
  537.                   REG_OPTION_NON_VOLATILE,KEY_ALL_ACCESS,NULL,&hCurKey,&dwDisp);
  538.  
  539.   for (i=0;i<lpMruMenu->wNbLruMenu;i++)
  540.     {
  541.     char szEntry[16];
  542.       wsprintf(szEntry,"File%lu",(DWORD)i+1);
  543.       if (!GetMenuItem(lpMruMenu,i,FALSE,lpTxt,lpMruMenu->wMaxSizeLruItem + 10))
  544.         *lpTxt = '\0';
  545.       RegSetValueEx(hCurKey,szEntry,0,REG_SZ,lpTxt,lstrlen(lpTxt));
  546.     }
  547.   RegCloseKey(hCurKey);
  548.   GlobalFreePtr(lpTxt);
  549.   return TRUE;
  550. }
  551.  
  552. //*************************************************************
  553. //
  554. //  LoadMruInReg()
  555. //
  556. //  Purpose:
  557. //              Load MRU from the registry
  558. //
  559. //  Parameters:
  560. //      LPMRUMENU lpMruMenu -      pointer on MRUMENU
  561. //      LPSTR lpszKey  -           Points to a null-terminated string 
  562. //                                      specifying  the name of a key that 
  563. //                                      this function opens or creates.
  564. //
  565. //  Return: (BOOL)
  566. //      TRUE  - Function run successfully
  567. //      FALSE - Function don't run successfully
  568. //
  569. //
  570. //  Comments:
  571. //      Win32 function designed for Windows NT and Windows 95
  572. //      See RegOpenKeyEx API for more info on lpszKey
  573. //
  574. //  History:    Date       Author       Comment
  575. //              09/24/94   G. Vollant   Created
  576. //
  577. //*************************************************************
  578. BOOL LoadMruInReg(LPMRUMENU lpMruMenu,LPSTR lpszKey)
  579. {
  580. LPSTR lpTxt;
  581. WORD i;
  582. HKEY hCurKey;
  583. DWORD dwType;
  584.   lpTxt = (LPSTR)GlobalAllocPtr(GHND,lpMruMenu->wMaxSizeLruItem + 20);
  585.   if (lpTxt == NULL) 
  586.     return FALSE;
  587.  
  588.   RegOpenKeyEx(HKEY_CURRENT_USER,lpszKey,0,KEY_READ,&hCurKey);
  589.  
  590.  
  591.   for (i=0;i<lpMruMenu->wNbLruMenu;i++)
  592.     {
  593.     char szEntry[16];
  594.     DWORD dwSizeBuf;  
  595.       wsprintf(szEntry,"File%lu",(DWORD)i+1);
  596.       *lpTxt = '\0';
  597.       dwSizeBuf = lpMruMenu->wMaxSizeLruItem + 10;
  598.       RegQueryValueEx(hCurKey,szEntry,NULL,&dwType,(LPBYTE)lpTxt,&dwSizeBuf);
  599.       *(lpTxt+dwSizeBuf)='\0';
  600.       if (*lpTxt == '\0')
  601.         break;
  602.       SetMenuItem(lpMruMenu,i,lpTxt);
  603.     }
  604.   RegCloseKey(hCurKey);
  605.   GlobalFreePtr(lpTxt);
  606.   return TRUE;
  607. }
  608.  
  609.  
  610. //*************************************************************
  611. //
  612. //  GetWin32Kind()
  613. //
  614. //  Purpose:
  615. //              Get the Win32 platform
  616. //
  617. //  Parameters:
  618. //
  619. //  Return: (WIN32KIND)
  620. //      WINNT -           Run under Windows NT
  621. //      WIN32S -          Run under Windows 3.1x + Win32s
  622. //      WIN95ORGREATHER - Run under Windows 95
  623. //
  624. //
  625. //  Comments:
  626. //      Win32 function designed for Windows NT and Windows 95
  627. //      See RegOpenKeyEx API for more info on lpszKey
  628. //
  629. //  History:    Date       Author       Comment
  630. //              09/24/94   G. Vollant   Created
  631. //
  632. //*************************************************************
  633. WIN32KIND GetWin32Kind()
  634. {
  635. BOOL IsWin395OrHigher(void);
  636.  
  637.   WORD wVer;
  638.  
  639.   if ((GetVersion() & 0x80000000) == 0)
  640.     return WINNT;
  641.   wVer = LOWORD(GetVersion());
  642.   wVer = (((WORD)LOBYTE(wVer)) << 8) | (WORD)HIBYTE(wVer);
  643.  
  644.   if (wVer >= 0x035F)
  645.     return WIN95ORGREATHER;
  646.   else
  647.     return WIN32S;
  648. }
  649. #endif
  650.