wizard.c

ReactOS是一些高手根据Windows XP的内核编写出的类XP。内核实现机理和API函数调用几乎相同。甚至可以兼容XP的程序。喜欢研究系统内核的人可以看一看。

              case PSN_SETACTIVE:
                /* Disable the Back and Next buttons */
                PropSheet_SetWizButtons(GetParent(hwndDlg), 0);

                StartComponentRegistration(hwndDlg, &MaxProgress);

                SendDlgItemMessage(hwndDlg, IDC_PROCESSPROGRESS, PBM_SETRANGE,
                                   0, MAKELPARAM(0, MaxProgress));
                SendDlgItemMessage(hwndDlg, IDC_PROCESSPROGRESS, PBM_SETPOS,
                                   0, 0);
                break;

              case PSN_WIZNEXT:
                break;

              case PSN_WIZBACK:
                SetupData->UnattendSetup = FALSE;
                break;

              default:
                break;
            }
        }
        break;

      case PM_REGISTRATION_NOTIFY:
        {
          WCHAR Activity[64];
          RegistrationNotify = (PREGISTRATIONNOTIFY) lParam;
          if (0 != LoadStringW(hDllInstance, RegistrationNotify->ActivityID,
                               Activity,
                               sizeof(Activity) / sizeof(Activity[0])))
            {
              SendDlgItemMessageW(hwndDlg, IDC_ACTIVITY, WM_SETTEXT,
                                  0, (LPARAM) Activity);
            }
          SendDlgItemMessageW(hwndDlg, IDC_ITEM, WM_SETTEXT, 0,
                              (LPARAM)(NULL == RegistrationNotify->CurrentItem ?
                                       L"" : RegistrationNotify->CurrentItem));
          SendDlgItemMessage(hwndDlg, IDC_PROCESSPROGRESS, PBM_SETPOS,
                             RegistrationNotify->Progress, 0);
          if (NULL != RegistrationNotify->ErrorMessage)
            {
              if (0 == LoadStringW(hDllInstance, IDS_REACTOS_SETUP,
                                   Title, sizeof(Title) / sizeof(Title[0])))
                {
                  wcscpy(Title, L"ReactOS Setup");
                }
              MessageBoxW(hwndDlg, RegistrationNotify->ErrorMessage,
                          Title, MB_ICONERROR | MB_OK);

            }

          if (wParam)
            {
#ifdef VMWINST
              if(!SetupData->UnattendSetup && !SetupData->DisableVmwInst)
                RunVMWInstall(GetParent(hwndDlg));
#endif

              /* Enable the Back and Next buttons */
              PropSheet_SetWizButtons(GetParent(hwndDlg), PSWIZB_NEXT);
              PropSheet_PressButton(GetParent(hwndDlg), PSBTN_NEXT);
            }
         }
         return TRUE;

      default:
        break;
    }

  return FALSE;
}


static VOID
SetupIsActive( DWORD dw )
{
  HKEY hKey = 0;
  if (RegOpenKeyEx( HKEY_LOCAL_MACHINE, _T("SYSTEM\\Setup"), 0, KEY_WRITE, &hKey ) == ERROR_SUCCESS) {
    RegSetValueEx( hKey, _T("SystemSetupInProgress"), 0, REG_DWORD, (CONST BYTE *)&dw, sizeof(dw) );
    RegCloseKey( hKey );
  }
}


static INT_PTR CALLBACK
FinishDlgProc(HWND hwndDlg,
              UINT uMsg,
              WPARAM wParam,
              LPARAM lParam)
{

  switch (uMsg)
    {
      case WM_INITDIALOG:
        {
          PSETUPDATA SetupData;

          /* Get pointer to the global setup data */
          SetupData = (PSETUPDATA)((LPPROPSHEETPAGE)lParam)->lParam;

          /* Set title font */
          SendDlgItemMessage(hwndDlg,
                             IDC_FINISHTITLE,
                             WM_SETFONT,
                             (WPARAM)SetupData->hTitleFont,
                             (LPARAM)TRUE);
        }
        break;

      case WM_DESTROY:
         SetupIsActive(0);
         return TRUE;

      case WM_TIMER:
         {
           INT Position;
           HWND hWndProgress;

           hWndProgress = GetDlgItem(hwndDlg, IDC_RESTART_PROGRESS);
           Position = SendMessage(hWndProgress, PBM_GETPOS, 0, 0);
           if (Position == 300)
           {
             KillTimer(hwndDlg, 1);
             PropSheet_PressButton(GetParent(hwndDlg), PSBTN_FINISH);
           }
           else
           {
             SendMessage(hWndProgress, PBM_SETPOS, Position + 1, 0);
           }
         }
         return TRUE;

      case WM_NOTIFY:
        {
          LPNMHDR lpnm = (LPNMHDR)lParam;

          switch (lpnm->code)
            {
              case PSN_SETACTIVE:
                /* Enable the correct buttons on for the active page */
                PropSheet_SetWizButtons(GetParent(hwndDlg), PSWIZB_BACK | PSWIZB_FINISH);
                
                SendDlgItemMessage(hwndDlg, IDC_RESTART_PROGRESS, PBM_SETRANGE, 0,
                                   MAKELPARAM(0, 300));
                SendDlgItemMessage(hwndDlg, IDC_RESTART_PROGRESS, PBM_SETPOS, 0, 0);
                SetTimer(hwndDlg, 1, 50, NULL);
                break;

              case PSN_WIZBACK:
                /* Handle a Back button click, if necessary */
                KillTimer(hwndDlg, 1);

                /* Skip the progress page */
                SetWindowLong(hwndDlg, DWL_MSGRESULT, IDD_DATETIMEPAGE);
                SetupData.UnattendSetup = FALSE;
                return TRUE;

              case PSN_WIZFINISH:
                /* Handle a Finish button click, if necessary */
                break;

              default:
                break;
            }
        }
        break;

      default:
        break;
    }

  return FALSE;
}
BOOL
ProcessUnattendInf(HINF hUnattendedInf)
{
  INFCONTEXT InfContext;
  TCHAR szName[256];
  TCHAR szValue[MAX_PATH];
  DWORD LineLength;

  if (!SetupFindFirstLine(hUnattendedInf,
              _T("Unattend"),
              _T("UnattendSetupEnabled"),
              &InfContext))
    {
      DPRINT1("Error: Cant find UnattendSetupEnabled Key! %d\n", GetLastError());
      return FALSE;
    }
    
   if (!SetupGetStringField(&InfContext,
               1,
               szValue,
               sizeof(szValue) / sizeof(TCHAR),
               &LineLength))
    {
      DPRINT1("Error: SetupGetStringField failed with %d\n", GetLastError());
      return FALSE;
    }
    
  if (_tcscmp(szValue, _T("yes")) != 0)
    {
      DPRINT("Unattend setup was disabled by UnattendSetupEnabled key.\n");
      return FALSE;
    }    
      
  if (!SetupFindFirstLine(hUnattendedInf,
              _T("Unattend"),
              NULL,
              &InfContext))
    {
      DPRINT1("Error: SetupFindFirstLine failed %d\n", GetLastError());
      return FALSE;
    }
    
      
  do
  {	
    if (!SetupGetStringField(&InfContext,
                 0,
                 szName,
                 sizeof(szName) / sizeof(TCHAR),
                 &LineLength))
      {
        DPRINT1("Error: SetupGetStringField failed with %d\n", GetLastError());
        return FALSE;
      }

    if (!SetupGetStringField(&InfContext,
                 1,
                 szValue,
                 sizeof(szValue) / sizeof(TCHAR),
                 &LineLength))
      {
        DPRINT1("Error: SetupGetStringField failed with %d\n", GetLastError());
        return FALSE;
      }
    DPRINT1("Name %S Value %S\n",szName, szValue);
    if (!_tcscmp(szName, _T("FullName")))
      {
        if ((sizeof(SetupData.OwnerName) / sizeof(TCHAR)) > LineLength)
          {
            _tcscpy(SetupData.OwnerName, szValue);
          }
      }
    else if (!_tcscmp(szName, _T("OrgName")))
      {
        if ((sizeof(SetupData.OwnerOrganization) / sizeof(TCHAR)) > LineLength)
          {
            _tcscpy(SetupData.OwnerOrganization, szValue);
          }
      }
    else if (!_tcscmp(szName, _T("ComputerName")))
      {
        if ((sizeof(SetupData.ComputerName) / sizeof(TCHAR)) > LineLength)
        {
          _tcscpy(SetupData.ComputerName, szValue);
        }
    }
    else if (!_tcscmp(szName, _T("AdminPassword")))
      {
        if ((sizeof(SetupData.AdminPassword) / sizeof(TCHAR)) > LineLength)
          {
            _tcscpy(SetupData.AdminPassword, szValue);
          }
      }
    else if (!_tcscmp(szName, _T("TimeZoneIndex")))
      {
        SetupData.TimeZoneIndex = _ttoi(szValue);
      }
    else if (_tcscmp(szName, _T("DisableAutoDaylightTimeSet")))
      {
        SetupData.DisableAutoDaylightTimeSet = _ttoi(szValue);
      }
    else if (_tcscmp(szName, _T("DisableVmwInst")))
      {
        if(_tcscmp(szValue, _T("yes"))) SetupData.DisableVmwInst = 1;
        else SetupData.DisableVmwInst = 0;
      }
  }
  while (SetupFindNextLine(&InfContext, &InfContext));


  if (SetupFindFirstLine(hUnattendedInf,
                         _T("GuiRunOnce"),
                         NULL,
                         &InfContext))
    {
      HKEY hKey;
      int i;

      if (RegOpenKeyEx(HKEY_LOCAL_MACHINE,
                        _T("SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\RunOnce"),
                        0,
                        KEY_SET_VALUE,
                        &hKey) != ERROR_SUCCESS)
        {
          DPRINT1("Error: failed to open HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\RunOnce\n");
          return TRUE;
        }

      i = 0;

      do
      {
        if(SetupGetStringField(&InfContext, 
                               0,
                               szValue,
                               sizeof(szValue) / sizeof(TCHAR),
                               NULL))
          {
            TCHAR szPath[MAX_PATH];
            _stprintf(szName, _T("%d"), i);
            DPRINT("szName %S szValue %S\n", szName, szValue);

           if (ExpandEnvironmentStrings(szValue, szPath, MAX_PATH))
             {
               DPRINT("value %S\n", szPath);
               if (RegSetValueEx(hKey,
                                 szName, 
                                 0,
                                 REG_SZ,
                                 (const BYTE*)szPath,
                                 _tcslen(szPath) * sizeof(TCHAR)) == ERROR_SUCCESS)
                 {
                   i++;
                 }
             }
          }
      }while(SetupFindNextLine(&InfContext, &InfContext));

    RegCloseKey(hKey);
  }
  return TRUE;
}


VOID
InstallWizard(VOID)
{
  PROPSHEETHEADER psh;
  HPROPSHEETPAGE ahpsp[8];
  PROPSHEETPAGE psp = {0};
  UINT nPages = 0;
  HINF hUnattendedInf;

  /* Clear setup data */
  ZeroMemory(&SetupData, sizeof(SETUPDATA));
   
  hUnattendedInf = SetupOpenInfFileW(L"unattend.inf",
                           NULL,
                           INF_STYLE_OLDNT,
                           NULL);
  
  if (hUnattendedInf != INVALID_HANDLE_VALUE)
  {
    SetupData.UnattendSetup = ProcessUnattendInf(hUnattendedInf);
    SetupCloseInfFile(hUnattendedInf);
  }

  /* Create the Welcome page */
  psp.dwSize = sizeof(PROPSHEETPAGE);
  psp.dwFlags = PSP_DEFAULT | PSP_HIDEHEADER;
  psp.hInstance = hDllInstance;
  psp.lParam = (LPARAM)&SetupData;
  psp.pfnDlgProc = WelcomeDlgProc;
  psp.pszTemplate = MAKEINTRESOURCE(IDD_WELCOMEPAGE);
  ahpsp[nPages++] = CreatePropertySheetPage(&psp);

  /* Create the Acknowledgements page */
  psp.dwFlags = PSP_DEFAULT | PSP_USEHEADERTITLE | PSP_USEHEADERSUBTITLE;
  psp.pszHeaderTitle = MAKEINTRESOURCE(IDS_ACKTITLE);
  psp.pszHeaderSubTitle = MAKEINTRESOURCE(IDS_ACKSUBTITLE);
  psp.pszTemplate = MAKEINTRESOURCE(IDD_ACKPAGE);
  psp.pfnDlgProc = AckPageDlgProc;
  ahpsp[nPages++] = CreatePropertySheetPage(&psp);

  /* Create the Owner page */
  psp.dwFlags = PSP_DEFAULT | PSP_USEHEADERTITLE | PSP_USEHEADERSUBTITLE;
  psp.pszHeaderTitle = MAKEINTRESOURCE(IDS_OWNERTITLE);
  psp.pszHeaderSubTitle = MAKEINTRESOURCE(IDS_OWNERSUBTITLE);
  psp.pszTemplate = MAKEINTRESOURCE(IDD_OWNERPAGE);
  psp.pfnDlgProc = OwnerPageDlgProc;
  ahpsp[nPages++] = CreatePropertySheetPage(&psp);

  /* Create the Computer page */
  psp.dwFlags = PSP_DEFAULT | PSP_USEHEADERTITLE | PSP_USEHEADERSUBTITLE;
  psp.pszHeaderTitle = MAKEINTRESOURCE(IDS_COMPUTERTITLE);
  psp.pszHeaderSubTitle = MAKEINTRESOURCE(IDS_COMPUTERSUBTITLE);
  psp.pfnDlgProc = ComputerPageDlgProc;
  psp.pszTemplate = MAKEINTRESOURCE(IDD_COMPUTERPAGE);
  ahpsp[nPages++] = CreatePropertySheetPage(&psp);


  /* Create the Locale page */
  psp.dwFlags = PSP_DEFAULT | PSP_USEHEADERTITLE | PSP_USEHEADERSUBTITLE;
  psp.pszHeaderTitle = MAKEINTRESOURCE(IDS_LOCALETITLE);
  psp.pszHeaderSubTitle = MAKEINTRESOURCE(IDS_LOCALESUBTITLE);
  psp.pfnDlgProc = LocalePageDlgProc;
  psp.pszTemplate = MAKEINTRESOURCE(IDD_LOCALEPAGE);
  ahpsp[nPages++] = CreatePropertySheetPage(&psp);


  /* Create the DateTime page */
  psp.dwFlags = PSP_DEFAULT | PSP_USEHEADERTITLE | PSP_USEHEADERSUBTITLE;
  psp.pszHeaderTitle = MAKEINTRESOURCE(IDS_DATETIMETITLE);
  psp.pszHeaderSubTitle = MAKEINTRESOURCE(IDS_DATETIMESUBTITLE);
  psp.pfnDlgProc = DateTimePageDlgProc;
  psp.pszTemplate = MAKEINTRESOURCE(IDD_DATETIMEPAGE);
  ahpsp[nPages++] = CreatePropertySheetPage(&psp);


  /* Create the Process page */
  psp.dwFlags = PSP_DEFAULT | PSP_USEHEADERTITLE | PSP_USEHEADERSUBTITLE;
  psp.pszHeaderTitle = MAKEINTRESOURCE(IDS_PROCESSTITLE);
  psp.pszHeaderSubTitle = MAKEINTRESOURCE(IDS_PROCESSSUBTITLE);
  psp.pfnDlgProc = ProcessPageDlgProc;
  psp.pszTemplate = MAKEINTRESOURCE(IDD_PROCESSPAGE);
  ahpsp[nPages++] = CreatePropertySheetPage(&psp);


  /* Create the Finish page */
  psp.dwFlags = PSP_DEFAULT | PSP_HIDEHEADER;
  psp.pfnDlgProc = FinishDlgProc;
  psp.pszTemplate = MAKEINTRESOURCE(IDD_FINISHPAGE);
  ahpsp[nPages++] = CreatePropertySheetPage(&psp);

  /* Create the property sheet */
  psh.dwSize = sizeof(PROPSHEETHEADER);
  psh.dwFlags = PSH_WIZARD97 | PSH_WATERMARK | PSH_HEADER;
  psh.hInstance = hDllInstance;
  psh.hwndParent = NULL;
  psh.nPages = nPages;
  psh.nStartPage = 0;
  psh.phpage = ahpsp;
  psh.pszbmWatermark = MAKEINTRESOURCE(IDB_WATERMARK);
  psh.pszbmHeader = MAKEINTRESOURCE(IDB_HEADER);

  /* Create title font */
  SetupData.hTitleFont = CreateTitleFont();

  /* Display the wizard */
  PropertySheet(&psh);

  DeleteObject(SetupData.hTitleFont);
}

/* EOF */