cnewdiskwizard.cpp

PGP8.0源码 请认真阅读您的文件包然后写出其具体功能

	if (mChoseDrive)
		OnDriveCheck();
	else
		OnDirCheck();

	if (UWinVersion::IsWin2000Compatible())
	{
		if (USecurity::IsRemoteSession())
		{
			mDriveRadio.EnableWindow(FALSE);
			mDriveCombo.EnableWindow(FALSE);

			mChoseDrive = FALSE;
			OnDirCheck();
		}

		mDirEdit.SetWindowText(mMountPoint);
	}
	else
	{
		mDirRadio.EnableWindow(FALSE);
		mDirEdit.EnableWindow(FALSE);
		mBrowseButton.EnableWindow(FALSE);
	}
}

void 
CNewDiskOptionsDialog::OnBrowseButton()
{
	using namespace UCommonStrings;

	try
	{
		UMountPoint::AskChooseMountPoint(Handle(), 
			Get(kCreateOptionsMsgBoxTitle), mMountPoint);

		mMountPoint.EndInSlash();
		mDirEdit.SetWindowText(mMountPoint);
	}
	catch (CComboError& error)
	{
		if (error.pgpErr != kPGPError_UserAbort)
			throw;
	}
}

void 
CNewDiskOptionsDialog::OnDirCheck()
{
	mDriveRadio.SetCheck(BST_UNCHECKED);
	mDirRadio.SetCheck(BST_CHECKED);

	mDriveCombo.EnableWindow(FALSE);
	mDirEdit.EnableWindow(TRUE);
	mBrowseButton.EnableWindow(TRUE);

	mDirEdit.SetFocus();
	mDirEdit.SetSel(0, -1);
}

void 
CNewDiskOptionsDialog::OnDriveCheck()
{
	mDriveRadio.SetCheck(BST_CHECKED);
	mDirRadio.SetCheck(BST_UNCHECKED);

	mDriveCombo.EnableWindow(TRUE);
	mDirEdit.EnableWindow(FALSE);
	mBrowseButton.EnableWindow(FALSE);

	mDriveCombo.SetFocus();
}

void 
CNewDiskOptionsDialog::OnOk()
{
	mAlgorithm = mAlgoCombo.Get();
	mFileSys = mFileSysCombo.Get();
	mDrive = mDriveCombo.Get();

	mDirEdit.GetWindowText(mMountPoint);

	mChoseDrive = (mDriveRadio.GetCheck() == BST_CHECKED);
	mMountStartup = (mStartupCheck.GetCheck() == BST_CHECKED);

	if (!mChoseDrive && 
		UMountPoint::FixWarnRoot(mMountPoint, TRUE, FALSE, Handle(), 
		UCommonStrings::Get(UCommonStrings::kSinglePassMsgBoxTitle)))
	{
		mDirEdit.SetFocus();
		mDirEdit.SetSel(0, -1);
	}
	else
	{
		CDialog::OnOk();
	}
}

BOOL 
CNewDiskOptionsDialog::OnCommand(
	PGPUInt16	notifyCode, 
	PGPUInt16	itemId, 
	HWND		ctrl)
{
	switch (notifyCode)
	{
	case BN_CLICKED:
		switch (itemId)
		{
		case IDC_DRIVE_RADIO:
				OnDriveCheck();
				break;

			case IDC_DIR_RADIO:
				OnDirCheck();
				break;

			case IDC_BROWSE_BUTTON:
				OnBrowseButton();
				return TRUE;
		}
		break;
	}

	return CDialog::OnCommand(notifyCode, itemId, ctrl);
}

void 
CNewDiskOptionsDialog::OnContextMenu(HWND menuWnd, CPoint coords)
{
	CHelpShower::ShowContextMenu(menuWnd, NewDiskWizOptionsDlgHelpIDs);
}

void 
CNewDiskOptionsDialog::OnHelp(HELPINFO *pInfo)
{
	CHelpShower::ShowForControl(static_cast<HWND>(pInfo->hItemHandle), 
		NewDiskWizOptionsDlgHelpIDs);
}

BOOL 
CNewDiskOptionsDialog::OnInitDialog(HWND focusCtrl)
{
	CDialog::OnInitDialog(focusCtrl);

	mAlgoCombo.Subclass(GetDlgItem(IDC_ALGORITHM_COMBO));
	mBrowseButton.Subclass(GetDlgItem(IDC_BROWSE_BUTTON));
	mDriveCombo.Subclass(GetDlgItem(IDC_DRIVE_COMBO));
	mFileSysCombo.Subclass(GetDlgItem(IDC_FILESYSTEM_COMBO));
	mDriveRadio.Subclass(GetDlgItem(IDC_DRIVE_RADIO));
	mDirRadio.Subclass(GetDlgItem(IDC_DIR_RADIO));
	mDirEdit.Subclass(GetDlgItem(IDC_DIR_EDIT));
	mStartupCheck.Subclass(GetDlgItem(IDC_STARTUP_CHECK));

	InitControls();

	Center();
	SetForegroundWindow();

	return FALSE;
}


// Class CNewDiskWizADKPage member functions

BOOL 
CNewDiskWizADKPage::OnInitDialog(HWND focusCtrl)
{
	CPGPdiskPage::OnInitDialog(focusCtrl);
	mADKEdit.Subclass(GetDlgItem(IDC_ADK_EDIT));

	return FALSE;
}

PGPInt32 
CNewDiskWizADKPage::OnPsnSetActive()
{
	PGPInt32	result	= CPGPdiskPage::OnPsnSetActive();

	if (result != 0)
		return result;

	if (!mPInfo->pContext->IsThereADK())
		return -1;

	CString	userID;

	mPInfo->pContext->GetADKUserID(userID);
	mADKEdit.SetWindowText(userID);

	SetWizButtons(PSWIZB_BACK | PSWIZB_NEXT);

	return 0;
}


// Class CNewDiskWizCreationPage member functions

PGPBoolean 
CNewDiskWizCreationPage::CreateStatusCallbackAux(
	PGPBoolean	areFormatting, 
	PGPUInt32	percent)
{
	mCurTaskBar.SetPosWTimeout(percent, 1000);

	if (areFormatting)
		mAllTaskBar.SetPosWTimeout(50 + percent/2, 1000);
	else
		mAllTaskBar.SetPosWTimeout(percent/2, 1000);

	mCancelMutex.Enter();
	mCancelMutex.Leave();

	return !mShouldCancel;
}

PGPBoolean 
CNewDiskWizCreationPage::CreateStatusCallback(
	PGPBoolean	areFormatting, 
	PGPUInt32	percent, 
	void		*userVal)
{
	CNewDiskWizCreationPage	*pPage	= static_cast<CNewDiskWizCreationPage *>(
		userVal);
	pgpAssertAddrValid(pPage, CNewDiskWizCreationPage);

	return pPage->CreateStatusCallbackAux(areFormatting, percent);
}

void 
CNewDiskWizCreationPage::CreateCallbackAux()
{
	try
	{
		// Create and mount the PGPdisk file.
		CPGPdiskDiskSet	diskSet(*mPInfo->pContext);
		CPGPdiskDisk	newDisk;

		if (mPInfo->userChosePub)
		{
			diskSet.CreateDisk(mPInfo->path, mPInfo->blocks, 
				mPInfo->algorithm, mPInfo->pubKey[0], mPInfo->root, 
				CreateStatusCallback, this, newDisk);
		}
		else
		{
			CSecureArray<char>	passphrase;
			mPInfo->securePass.Extract(passphrase);

			diskSet.CreateDisk(mPInfo->path, mPInfo->blocks, 
				mPInfo->algorithm, passphrase.Get(), mPInfo->userName, 
				mPInfo->root, CreateStatusCallback, this, newDisk);
		}

		mPInfo->fileCreated = TRUE;

		// check in-between for cancel also
		if (mShouldCancel)
			THROW_PGPERROR(kPGPError_UserAbort);

		// format the PGPdisk volume
		PostMessage(WM_CREATE_HALFWAYDONE);

		CPGPdiskFormatter	formatter;

		formatter.Format(*mPInfo->pContext, mPInfo->root, mFileName, 
			mPInfo->fileSys, CreateStatusCallback, this);

		PostMessage(WM_CREATE_DONE);
	}
	catch (CComboError& error)
	{
		mPInfo->error = error;
		PostMessage(WM_CREATE_DONE);
	}
}

void 
_cdecl 
CNewDiskWizCreationPage::CreateCallback(void *userVal)
{
	CNewDiskWizCreationPage	*pPage	= static_cast<CNewDiskWizCreationPage *>(
		userVal);
	pgpAssertAddrValid(pPage, CNewDiskWizCreationPage);

	pPage->CreateCallbackAux();
}

void 
CNewDiskWizCreationPage::InitImages()
{
	// initialize image list
	CDC	dc;
	dc.AttachFromWindow(NULL, TRUE);	// DC for desktop

	PGPUInt32	numBits	= dc.GetDeviceCaps(BITSPIXEL) * 
		dc.GetDeviceCaps(PLANES);

	if (numBits <= 8)
	{
		mImages.Create(CIcon::kSmallIconWidth, CIcon::kSmallIconHeight, 
			ILC_COLOR | ILC_MASK, ImageIDs::kNumImageBitmaps, 0);

		CBitmap	images(UModuleInstance::Get(), 
			MAKEINTRESOURCE(IDB_IMAGES4BIT));
		mImages.AddMasked(images, ImageIDs::kMaskColor);
	}
	else
	{
		mImages.Create(CIcon::kSmallIconWidth, CIcon::kSmallIconHeight, 
			ILC_COLOR24 | ILC_MASK, ImageIDs::kNumImageBitmaps, 0);

		CBitmap	images(UModuleInstance::Get(), 
			MAKEINTRESOURCE(IDB_IMAGES24BIT));
		mImages.AddMasked(images, ImageIDs::kMaskColor);
	}

	// load icons
	mDoingIcon.Attach(
		mImages.GetIcon(ImageIDs::kDoingIcon, ILD_TRANSPARENT), TRUE);
	mDoneIcon.Attach(
		mImages.GetIcon(ImageIDs::kDoneIcon, ILD_TRANSPARENT), TRUE);
	mFailedIcon.Attach(
		mImages.GetIcon(ImageIDs::kFailedIcon, ILD_TRANSPARENT), TRUE);
}

void 
CNewDiskWizCreationPage::OnCreateDone()
{
	using namespace UCommonStrings;
	mCreateThread.KillThread();

	if (mShouldCancel || mPInfo->error.IsError())
	{
		// kill the infant PGPdisk if it still lives
		CPGPdiskDiskSet		diskSet(*mPInfo->pContext);
		CPGPdiskDiskIter	diskIter(diskSet);
		CPGPdiskDisk		disk;

		if (diskIter.SearchOnPath(mPInfo->path, disk))
			diskSet.Unmount(disk);

		// update the UI to reflect the error status
		SetWizButtons(0);

		if (mPInfo->error.IsError() && 
			(mPInfo->error.pgpErr != kPGPError_UserAbort))
		{
			ReportError(kTellDiskCreateFailed, kNewDiskMsgBoxTitle, 
				mPInfo->error);

			mCurTaskBar.ShowWindow(SW_HIDE);
			mAllTaskBar.SetPos(100);

			mCurTaskText.SetWindowText(Get(kNewDiskProgFailedText));
		}
		else
		{
			mCurTaskText.SetWindowText(Get(kNewDiskProgCanceledText));
		}

		mTaskIcon1.SetIcon(mFailedIcon);
		mTaskIcon2.SetIcon(mFailedIcon);
	}
	else
	{
		SetWizButtons(PSWIZB_NEXT);

		mCurTaskText.SetWindowText(Get(kNewDiskProgDoneText));
		mTaskIcon2.SetIcon(mDoneIcon);
		mAllTaskBar.SetPos(100);
		mCurTaskBar.ShowWindow(SW_HIDE);
	}
}

void 
CNewDiskWizCreationPage::OnCreateHalfwayDone()
{
	using namespace UCommonStrings;

	mCurTaskText.FitFormattedTextToWindow(Get(kNewDiskProgFormattingText), 
		mFileName);

	mTaskIcon1.SetIcon(mDoneIcon);
	mTaskIcon2.SetIcon(mDoingIcon);
}

BOOL 
CNewDiskWizCreationPage::OnInitDialog(HWND focusCtrl)
{
	CPGPdiskPage::OnInitDialog(focusCtrl);

	mTaskIcon1.Subclass(GetDlgItem(IDC_TASKICON1));
	mTaskIcon2.Subclass(GetDlgItem(IDC_TASKICON2));

	mAllTaskBar.Subclass(GetDlgItem(IDC_ALLTASK_BAR));
	mCurTaskBar.Subclass(GetDlgItem(IDC_CURTASK_BAR));
	mCurTaskText.Subclass(GetDlgItem(IDC_CURTASK_TEXT));

	InitImages();

	return FALSE;
}

PGPBoolean 
CNewDiskWizCreationPage::OnPsnQueryCancel()
{
	using namespace UCommonStrings;

	if (!mCreateThread.IsRunning())
		return FALSE;	// nothing's happening, we're set
	else if (mShouldCancel)
		return TRUE;	// cancel in progress, hold tight

	// Pause the creation thread.
	mCancelMutex.Enter();

	// Ask the user for cancel permission.
	CMessageBox	messageBox;

	CMessageBox::Button	result	= messageBox.Display(
		Get(kAskIfCancelCreation), Get(kNewDiskMsgBoxTitle), Handle(), 
		CMessageBox::kQuestionTone, CMessageBox::kYesNoStyle, 
		CMessageBox::kNoButton);

	mShouldCancel = (result == CMessageBox::kYesButton);
	mCancelMutex.Leave();

	if (mShouldCancel && mCreateThread.IsRunning())
	{
		mCurTaskText.SetWindowText(Get(kNewDiskProgFailingText));
		mCurTaskBar.ShowWindow(SW_HIDE);
		mAllTaskBar.SetPos(100);
	}

	return TRUE;
}

PGPInt32 
CNewDiskWizCreationPage::OnPsnSetActive()
{
	using namespace UCommonStrings;

	PGPInt32	result	= CPGPdiskPage::OnPsnSetActive();

	if (result != 0)
		return result;

	SetWizButtons(0);

	// Get key information.
	PGPBoolean	userChoseRO;	// not relevant here

	mPInfo->pNewUserPages->GetChoices(mPInfo->userChosePub, mPInfo->pubKey, 
		mPInfo->uNumPubKeys,mPInfo->userName, mPInfo->securePass, userChoseRO);

	// Prepare controls.
	mAllTaskBar.SetRange(0, 100);
	mAllTaskBar.SetPos(0);

	mCurTaskBar.SetRange(0, 100);
	mCurTaskBar.SetPos(0);

	mPInfo->path.GetFileNamePart(mFileName);
	mFileName.RemoveExtension();

	mCurTaskText.FitFormattedTextToWindow(Get(kNewDiskProgEncryptingText), 
		mFileName);
	
	mTaskIcon1.SetIcon(mDoingIcon);

	// Start creation.
	mCreateThread.StartThread();

	try
	{
		mShouldCancel = FALSE;
		mCreateThread.PerformAsyncCallback(CreateCallback, this);
	}
	catch (CComboError&)
	{
		mCreateThread.KillThread();
		throw;
	}

	return 0;
}

PGPInt32 
CNewDiskWizCreationPage::OnPsnWizNext()
{
	PGPInt32	result	= CPGPdiskPage::OnPsnWizNext();

	if (result != 0)
		return result;

	try
	{
		if (mPInfo->mountAtStartup)
			UEditMount::MarkDiskForStartup(*mPInfo->pContext, mPInfo->path);
		else
			UEditMount::UnmarkDiskForStartup(*mPInfo->pContext, mPInfo->path);
	}
	catch (CComboError&)
	{
		using namespace UCommonStrings;

		CMessageBox	messageBox;
		messageBox.Display(Get(kTellCantMarkDiskFor), 
			Get(kNewDiskMsgBoxTitle), Handle(), CMessageBox::kWarningTone);
	}

	return 0;
}

PGPBoolean 
CNewDiskWizCreationPage::PreProcess(const CMessage& msg, LRESULT& result)
{
	switch (msg.Message())
	{
	case WM_CREATE_DONE:
		OnCreateDone();
		result = 0;
		return TRUE;

	case WM_CREATE_HALFWAYDONE:
		OnCreateHalfwayDone();
		result = 0;
		return TRUE;

	default:
		return FALSE;
	}
}