home *** CD-ROM | disk | FTP | other *** search
/ Tricks of the Windows Gam…ming Gurus (2nd Edition) / Disc2.iso / msdn_vcb / samples / vc98 / sdk / sysmgmt / setup / infinst / infinst.c < prev    next >
Encoding:
C/C++ Source or Header  |  1997-10-05  |  14.0 KB  |  469 lines
  1.  
  2. /******************************************************************************\
  3. *       This is a part of the Microsoft Source Code Samples. 
  4. *       Copyright (C) 1995-1997 Microsoft Corporation.
  5. *       All rights reserved. 
  6. *       This source code is only intended as a supplement to 
  7. *       Microsoft Development Tools and/or WinHelp documentation.
  8. *       See these sources for detailed information regarding the 
  9. *       Microsoft samples programs.
  10. \******************************************************************************/
  11.  
  12. //
  13. //    PROGRAM:    InfInst.c
  14. //
  15. //    PURPOSE:    Demonstrates how create a wizard based install
  16. //              using win32 functions in setupapi.dll
  17. //
  18. //    PLATFORMS:    Windows 95 and NT 4.0
  19. //
  20. //    FUNCTIONS:    
  21. //        WinMain() - calls initialization function, processes message loop
  22. //        InitApplication() - Initializes window data nd registers window
  23. //        InitInstance() - saves instance handle and creates main window
  24. //        MainWindProc() - Processes messages
  25. //        RuntimeRegistration() - Add runtime data to registry
  26. //      RegisterString() - adds a string to registry, simple win32 registry api wrapper
  27. //      GetRegString() - gets a string from registry, simple win32 registry api wrapper
  28. //      GetPlatformInfo () - not used but this is an exampleof what you can do in
  29. //             a win32 or win16 setup stub program to get your setup started
  30. //             NOTE: In this sample we are assuming the autorun.inf takes care of this
  31. //
  32. //    CALLS:
  33. //        DoInstallation() - Does the resulting installation options in doinst.c
  34. //
  35. //    SPECIAL INSTRUCTIONS: N/A
  36. //
  37.  
  38. #include <windows.h>    // includes basic windows functionality
  39. #include <string.h>     // includes the string functions
  40. #include <prsht.h>      // includes the property sheet functionality
  41. #include "setupapi.h"   // includes the inf setup api 
  42. #include "resource.h"   // includes the definitions for the resources
  43. #include "instwiz.h"     // includes the application-specific information
  44. #include "infinst.h"     // includes the application-specific information
  45. #include "infdesc.h"
  46.  
  47. INSTALLINFO setupInfo;      // a structure containing the review information
  48. HWND hwndEdit;          // handle to the main MLE
  49. TCHAR lpReview[MAX_BUF]; // Buffer for the review
  50.  
  51. BOOL bCreated = FALSE;  // Keep us minimized once we are created
  52.  
  53. //
  54. //
  55. //   FUNCTION: WinMain(HANDLE, HANDLE, LPSTR, int)
  56. //
  57. //   PURPOSE: Main entry point for the application. 
  58. //
  59. //   COMMENTS:
  60. //    
  61. //    This function calls the initialization functions and processes
  62. //    the main message loop.
  63. // 
  64. int APIENTRY WinMain(
  65.     HINSTANCE hInstance,
  66.     HINSTANCE hPrevInstance,
  67.     LPSTR lpCmdLine,
  68.     int nCmdShow
  69.     )
  70. {
  71.         MSG msg;                       
  72.  
  73.         // save off the current instance
  74.         setupInfo.hInst = hInstance;
  75.  
  76.         // if the initialization fails, return.
  77.         if (!InitApplication(hInstance))
  78.             return (FALSE);     
  79.  
  80.         // Perform initializations that apply to a specific instance 
  81.         if (!InitInstance(hInstance, nCmdShow))
  82.             return (FALSE);
  83.  
  84.        // Acquire and dispatch messages until a WM_QUIT message is received. 
  85.        while (GetMessage(&msg, NULL, 0,0))                
  86.        {
  87.           TranslateMessage(&msg);
  88.           DispatchMessage(&msg); 
  89.        }
  90.        
  91.        return (msg.wParam);  
  92. }
  93.  
  94.  
  95. //
  96. //
  97. //   FUNCTION: InitApplication(HANDLE) 
  98. //
  99. //   PURPOSE: Initializes window data and registers window class 
  100. //
  101. //   COMMENTS:
  102. //
  103. //        This function registers the window class for the main window.    
  104. // 
  105. BOOL InitApplication(HANDLE hInstance)
  106. {
  107.         WNDCLASS  wcSample;
  108.     
  109.         // Fill in window class structure with parameters that describe the       
  110.         // main window.                                                           
  111.  
  112.         wcSample.style = 0;                     
  113.         wcSample.lpfnWndProc = (WNDPROC)MainWndProc; 
  114.         wcSample.cbClsExtra = 0;              
  115.         wcSample.cbWndExtra = 0;              
  116.         wcSample.hInstance = hInstance;       
  117.         wcSample.hIcon = LoadIcon(hInstance, MAKEINTRESOURCE(EXE_ICON));
  118.         wcSample.hCursor = LoadCursor(NULL, IDC_ARROW);
  119.         wcSample.hbrBackground = GetStockObject(WHITE_BRUSH); 
  120.         wcSample.lpszMenuName =  NULL;  
  121.         wcSample.lpszClassName = TEXT("SampleWClass");
  122.  
  123.         return (RegisterClass(&wcSample));
  124.  
  125. }
  126.  
  127.  
  128. //
  129. //
  130. //   FUNCTION: InitInstance(HANDLE, int)
  131. //
  132. //   PURPOSE: Creates the main window.
  133. //
  134. //   COMMENTS: N/A
  135. //    
  136. // 
  137. BOOL InitInstance(
  138.     HANDLE          hInstance,
  139.     int             nCmdShow) 
  140. {
  141.     HWND hWndMain;
  142.  
  143.     hWndMain = CreateWindow(
  144.         TEXT("SampleWClass"),
  145.         TEXT("Install Sample"), 
  146.         WS_OVERLAPPEDWINDOW, 
  147.         CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
  148.         NULL,               
  149.         NULL,               
  150.         hInstance,          
  151.         NULL);
  152.  
  153.     /* If window could not be created, return "failure" */
  154.     if (!hWndMain)
  155.         return (FALSE);
  156.  
  157.     /* Make the window visible; update its client area; and return "success" */
  158.     ShowWindow(hWndMain, SW_MINIMIZE);
  159.     UpdateWindow(hWndMain); 
  160.     return (TRUE);      
  161.  
  162. }
  163.  
  164. //
  165. //   FUNCTION: MainWndProc(HWND, UINT, UINT, LONG)
  166. //
  167. //  PURPOSE:  Processes messages for the main window procedure 
  168. //
  169. //    MESSAGES:
  170. //    
  171. //    WM_CREATE - creates the main MLE for the window
  172. //    WM_COMMAND - processes the menu commands for the application
  173. //    WM_SIZE - sizes the MLE to fill the client area of the window
  174. //    WM_DESTROY - posts a quit message and returns
  175. //
  176. LONG APIENTRY MainWndProc(
  177.     HWND hWnd,                // window handle                   
  178.     UINT message,             // type of message                 
  179.     UINT wParam,              // additional information          
  180.     LONG lParam)              // additional information          
  181. {
  182.  
  183.     switch (message) 
  184.     {
  185.         case WM_CREATE:
  186.             // TODO: put in a Bitmap for a splash window );
  187.             
  188.             GetRegString(MYPRODUCT_KEY, USER_NAME_KEY,  setupInfo.pszUserName);
  189.             GetRegString(MYPRODUCT_KEY, COMPANY_KEY,    setupInfo.pszCompany);
  190.             GetRegString(MYPRODUCT_KEY, PRODUCT_ID_KEY, setupInfo.pszProductIdString);
  191.             GetRegString(MYPRODUCT_KEY, EMAIL_KEY,      setupInfo.pszEmailAddress);
  192.             GetRegString(MYPRODUCT_KEY, TEXT("DestinationPath"),  setupInfo.pszDestPath);
  193.  
  194.             // Start up the install 
  195.             PostMessage(hWnd, WM_COMMAND, ID_INSTALL, 0 );
  196.             return 0;
  197.  
  198.          case WM_WINDOWPOSCHANGING:
  199.              if (bCreated)
  200.              {  
  201.                  LPWINDOWPOS lpwp;
  202.  
  203.                  lpwp = (LPWINDOWPOS) lParam; // points to size and position data 
  204.                  lpwp->flags = SWP_NOMOVE    | SWP_NOOWNERZORDER |
  205.                                SWP_NOSIZE | SWP_NOREDRAW | 
  206.                                SWP_NOREPOSITION;
  207.  
  208.               } 
  209.               else
  210.               { 
  211.                  bCreated = TRUE;
  212.               }
  213.               break;
  214.  
  215.         case WM_COMMAND:
  216.             switch( LOWORD( wParam ))
  217.             {
  218.                 /*******************************************************\
  219.                 *
  220.                 *  Here is where the real work takes place
  221.                 *     Do the wizard to collect the user information
  222.                 *     Do the installation with the setupapis
  223.                 *     Update the registry with runtime user data
  224.                 *     
  225.                 \*******************************************************/
  226.                 case ID_INSTALL:
  227.                     // Do installation
  228.                     DoInstallation(hWnd, &setupInfo);
  229.  
  230.                     //installs done so go away
  231.                     PostMessage(hWnd, WM_DESTROY, 0, 0 );
  232.                     break;
  233.  
  234.                  default:
  235.                     return (DefWindowProc(hWnd, message, wParam, lParam));
  236.  
  237.         }
  238.         break;
  239.  
  240.         case WM_DESTROY:                  /* message: window being destroyed */
  241.             PostQuitMessage(0);
  242.             break;
  243.  
  244.         default:
  245.             return (DefWindowProc(hWnd, message, wParam, lParam));
  246.     }
  247.     return (0);
  248. }
  249.  
  250.  
  251. void RuntimeRegistration(INSTALLINFO *si)
  252. {
  253.     //
  254.     // The setupapi calls have completed
  255.     // now we will finish up by updating the user information
  256.     // and uninstall in the registry
  257.     //
  258.  
  259.     char buf[MAX_PATH];
  260.  
  261.     //
  262.     // Stuff for out product
  263.     // fixed application values are done by the inf
  264.     // We are only doing runtime values here
  265.     //
  266.  
  267.     RegisterString(MYPRODUCT_KEY,
  268.              USER_NAME_KEY,
  269.              si->pszUserName);
  270.  
  271.     RegisterString(MYPRODUCT_KEY,
  272.              COMPANY_KEY,
  273.              si->pszCompany);
  274.     
  275.     RegisterString(MYPRODUCT_KEY,
  276.              PRODUCT_ID_KEY,
  277.              si->pszProductIdString);
  278.     
  279.     RegisterString(MYPRODUCT_KEY,
  280.              EMAIL_KEY,
  281.              si->pszEmailAddress);
  282.     
  283.  
  284.     wsprintf(buf, "%s", si->pszDestPath);
  285.     
  286.     RegisterString(MYPRODUCT_KEY,
  287.                 TEXT("DestinationPath"),
  288.                 buf);
  289.  
  290. /*
  291.     //
  292.     // Setup up Add/Remove Programs Control Panel Applet
  293.     // We need to set Display name and how to uninstall
  294.     //
  295.     // UNINSTALL Info
  296.     //
  297.  
  298.     RegisterString(UNINSTALL_KEY,
  299.                 TEXT("DisplayName"),
  300.                 TEXT("MyProduct Version 1.0"));
  301.  
  302.     wsprintf(buf, "%s\\setup.exe Uninstall", si->pszDestPath);
  303.     
  304.     RegisterString(UNINSTALL_KEY,
  305.                 TEXT("UninstallString"),
  306.                 buf);
  307.  
  308. */    
  309.     return;
  310. }
  311.  
  312.  
  313. BOOL 
  314. RegisterString (
  315.    LPSTR pszKey, 
  316.    LPSTR pszValue, 
  317.    LPSTR pszData
  318.    )
  319. {
  320.  
  321.     HKEY hKey;
  322.     DWORD dwDisposition;
  323.  
  324.     //
  325.     // Create the key, if it exists it will be opened
  326.     //
  327.  
  328.     if (ERROR_SUCCESS != 
  329.         RegCreateKeyEx(
  330.           HKEY_LOCAL_MACHINE,       // handle of an open key 
  331.           pszKey,                  // address of subkey name 
  332.           0,                       // reserved 
  333.           NULL,                    // address of class string 
  334.           REG_OPTION_NON_VOLATILE, // special options flag 
  335.           KEY_ALL_ACCESS,           // desired security access 
  336.           NULL,                       // address of key security structure 
  337.           &hKey,                   // address of buffer for opened handle  
  338.           &dwDisposition))            // address of disposition value buffer 
  339.     {
  340.         return FALSE;
  341.     }
  342.  
  343.     //
  344.     // Write the value and it's data to the key
  345.     //
  346.  
  347.     if (ERROR_SUCCESS != 
  348.         RegSetValueEx(
  349.             hKey,                 // handle of key to set value for  
  350.             pszValue,             // address of value to set 
  351.             0,                     // reserved 
  352.             REG_SZ,                 // flag for value type 
  353.             pszData,             // address of value data 
  354.             strlen(pszData) ))      // size of value data 
  355.     {
  356.         
  357.         RegCloseKey(hKey);
  358.         return FALSE;
  359.     }
  360.  
  361.     //
  362.     // Close the key
  363.     //
  364.     
  365.     RegCloseKey(hKey);
  366.     
  367.     return TRUE;
  368. }
  369.  
  370. BOOL
  371. GetRegString (
  372.   LPSTR pszKey,
  373.   LPSTR pszValue,
  374.   LPSTR pszData
  375.   )
  376. {
  377.  
  378.     HKEY hKey;
  379.     DWORD dwDataSize = MAX_PATH - 1;
  380.     DWORD dwValueType = REG_SZ;
  381.  
  382.     RegOpenKeyEx(
  383.        HKEY_LOCAL_MACHINE,    // handle of open key 
  384.        pszKey,                // address of name of subkey to open 
  385.        0,                    // reserved 
  386.        KEY_QUERY_VALUE,        // security access mask 
  387.        &hKey                 // address of handle of open key 
  388.        );    
  389.  
  390.     RegQueryValueEx(
  391.         hKey,         // handle of key to query 
  392.         pszValue,     // address of name of value to query 
  393.         0,             // reserved 
  394.         &dwValueType,// address of buffer for value type 
  395.         pszData,     // address of data buffer 
  396.         &dwDataSize  // address of data buffer size 
  397.         );
  398.  
  399.     if (pszData[dwDataSize] != '\0')
  400.         pszData[dwDataSize] = '\0';
  401.  
  402.     return TRUE;
  403. }
  404.  
  405. /*
  406.  
  407. //      GetPlatformInfo () - not used but this is an example of what you can do in
  408. //             a win32 or win16 setup stub program to get your setup started
  409. //             NOTE: In this sample we are assuming the autorun.inf takes care of this
  410. //                   for us. See the autorun.inf which shows this
  411. //
  412. //      The core of this could be your entire WinMain in a win16 stub 
  413. //
  414. int GetPlatformInfo(HINSTANCE hInstance)
  415. {
  416.     char szCpu[64], szPath[_MAX_PATH], szExeStr[128];
  417.     char szSystemDir[_MAX_PATH];
  418.     
  419.     GetModuleFileName(hInstance, szPath, _MAX_PATH);
  420.     *(strrchr(szPath, '\\') + 1) = '\0';    // Strip SETUPPROG off path
  421.     GetSystemDirectory(szSystemDir, _MAX_PATH);
  422.  
  423.                                                             
  424.     if (getenv("PROCESSOR_ARCHITECTURE") != NULL)
  425.     {
  426.         lstrcpyn(szCpu, getenv("PROCESSOR_ARCHITECTURE"), 63);
  427.     }
  428.     else
  429.     {       // Not defined, guess x86
  430.         lstrcpy(szCpu, "x86");
  431.     }
  432.  
  433.         if (HIBYTE(LOWORD(GetVersion())) > 11)         // Check if Win95 
  434.     {
  435.         //Win95
  436.             sprintf(szExeStr, "%s\\Bin\\I386\\infinst.exe CmdLineOptions", szPath);
  437.     } 
  438.         // Else pick the NT platform
  439.         else if (!lstrcmp(szCpu, "MIPS"))
  440.     {                           
  441.             sprintf(szExeStr, "%s\\Bin\\MIPS\\infinst.exe CmdLineOptions", szPath);
  442.     }
  443.     else if (!lstrcmp(szCpu, "ALPHA"))
  444.     {
  445.             sprintf(szExeStr, "%s\\Bin\\ALPHA\\infinst.exe CmdLineOptions", szPath);
  446.     }
  447.     else if (!lstrcmp(szCpu, "PPC"))
  448.     {
  449.             sprintf(szExeStr, "%s\\Bin\\PPC\\infinst.exe CmdLineOptions", szPath);
  450.     }                                                 
  451.     else   // x86 NT box
  452.     {
  453.             sprintf(szExeStr, "%s\\Bin\\I386\\infinst.exe CmdLineOptions", szPath);
  454.         }
  455.  
  456.     //    MessageBox ( NULL, szExeStr,szCpu,MB_OK);
  457.  
  458.     //    WinExec(szExeStr, SW_SHOW);
  459.  
  460.     if (wReturn < 32) {
  461.              //Failed
  462.     }
  463.     else {
  464.               //Worked
  465.     }
  466.  
  467.     return(0);
  468. }
  469. */