clprefs.c

vc环境下的pgp源码

			hParent = GetParent (hDlg);
			GetWindowRect (hParent, &rc);
			SetWindowPos (hParent, NULL,
				(GetSystemMetrics(SM_CXSCREEN) - (rc.right - rc.left)) / 2,
				(GetSystemMetrics(SM_CYSCREEN) - (rc.bottom - rc.top)) / 3,
				0, 0, SWP_NOSIZE | SWP_NOZORDER);
			bNeedsCentering = FALSE;
		}
	
		pgpCopyMemory (&sDefaultHotKeys, &hotkeys, sizeof(hotkeys));
		err = PGPGetPrefData (PrefRefClient, kPGPPrefHotKeyData, &size, &phks);

		if ((IsntPGPError (err)) &&
			(size == sizeof (hotkeys)))
				pgpCopyMemory (phks, &hotkeys, size);

		// initialize purge passphrase hotkey
		sSetHotKeyControl (GetDlgItem (hDlg, IDC_PURGEHOTKEY), 
				hotkeys.hotkeyPurgePassphraseCache);

		if (hotkeys.hotkeyPurgePassphraseCache & kPGPHotKeyEnabled) 
			CheckDlgButton (hDlg, IDC_ENABLEPURGECACHE, BST_CHECKED);
		else 
			CheckDlgButton (hDlg, IDC_ENABLEPURGECACHE, BST_UNCHECKED);

		// initialize encrypt hotkey
		sSetHotKeyControl (GetDlgItem (hDlg, IDC_ENCRYPTHOTKEY), 
				hotkeys.hotkeyEncrypt);

		if (hotkeys.hotkeyEncrypt & kPGPHotKeyEnabled) 
			CheckDlgButton (hDlg, IDC_ENABLEENCRYPT, BST_CHECKED);
		else 
			CheckDlgButton (hDlg, IDC_ENABLEENCRYPT, BST_UNCHECKED);

		// initialize sign hotkey
		sSetHotKeyControl (GetDlgItem (hDlg, IDC_SIGNHOTKEY), 
				hotkeys.hotkeySign);

		if (hotkeys.hotkeySign & kPGPHotKeyEnabled) 
			CheckDlgButton (hDlg, IDC_ENABLESIGN, BST_CHECKED);
		else 
			CheckDlgButton (hDlg, IDC_ENABLESIGN, BST_UNCHECKED);

		// initialize encrypt & sign hotkey
		sSetHotKeyControl (GetDlgItem (hDlg, IDC_ENCRYPTSIGNHOTKEY), 
				hotkeys.hotkeyEncryptSign);

		if (hotkeys.hotkeyEncryptSign & kPGPHotKeyEnabled) 
			CheckDlgButton (hDlg, IDC_ENABLEENCRYPTSIGN, BST_CHECKED);
		else 
			CheckDlgButton (hDlg, IDC_ENABLEENCRYPTSIGN, BST_UNCHECKED);

		// initialize purge passphrase
		sSetHotKeyControl (GetDlgItem (hDlg, IDC_DECRYPTHOTKEY), 
				hotkeys.hotkeyDecrypt);

		if (hotkeys.hotkeyDecrypt & kPGPHotKeyEnabled) 
			CheckDlgButton (hDlg, IDC_ENABLEDECRYPT, BST_CHECKED);
		else 
			CheckDlgButton (hDlg, IDC_ENABLEDECRYPT, BST_UNCHECKED);

		if (IsntNull (phks))
			PGPDisposePrefData (PrefRefClient, phks);

		return TRUE;
	}

    case WM_HELP: 
        WinHelp (((LPHELPINFO) lParam)->hItemHandle, g_szHelpFile, 
            HELP_WM_HELP, (DWORD) (LPSTR) aHotkeyIds); 
        break; 
 
    case WM_CONTEXTMENU: 
        WinHelp ((HWND) wParam, g_szHelpFile, HELP_CONTEXTMENU, 
            (DWORD) (LPVOID) aHotkeyIds); 
        break; 

	case WM_COMMAND :
		switch (LOWORD (wParam)) {
		case IDC_ENABLEPURGECACHE :
			EnableWindow (GetDlgItem (hDlg, IDC_PURGEHOTKEY), 
				(IsDlgButtonChecked (
						hDlg, IDC_ENABLEPURGECACHE) == BST_CHECKED));
			break;

		case IDC_ENABLEENCRYPT :
			EnableWindow (GetDlgItem (hDlg, IDC_ENCRYPTHOTKEY), 
				(IsDlgButtonChecked (
						hDlg, IDC_ENABLEENCRYPT) == BST_CHECKED));
			break;

		case IDC_ENABLESIGN :
			EnableWindow (GetDlgItem (hDlg, IDC_SIGNHOTKEY), 
				(IsDlgButtonChecked (
						hDlg, IDC_ENABLESIGN) == BST_CHECKED));
			break;

		case IDC_ENABLEENCRYPTSIGN :
			EnableWindow (GetDlgItem (hDlg, IDC_ENCRYPTSIGNHOTKEY), 
				(IsDlgButtonChecked (
						hDlg, IDC_ENABLEENCRYPTSIGN) == BST_CHECKED));
			break;

		case IDC_ENABLEDECRYPT :
			EnableWindow (GetDlgItem (hDlg, IDC_DECRYPTHOTKEY), 
				(IsDlgButtonChecked (
						hDlg, IDC_ENABLEDECRYPT) == BST_CHECKED));
			break;
		}
		break;

	case WM_NOTIFY :
		switch (((NMHDR FAR *) lParam)->code) {
		case PSN_SETACTIVE :
			if (hWndFocus)
			{
				SetFocus (hWndFocus);
				hWndFocus = NULL;
			}
			break;

		case PSN_HELP :
			WinHelp (hDlg, g_szHelpFile, HELP_CONTEXT, 
				IDH_PGPCLPREF_HOTKEYDIALOG); 
			break;

		case PSN_APPLY :
		{
			PGPHotKeys	hotkeys;

			// save purge passphrase hotkey
			hotkeys.hotkeyPurgePassphraseCache =
				sGetHotKeyControl (GetDlgItem (hDlg, IDC_PURGEHOTKEY));

			if (IsDlgButtonChecked (
					hDlg, IDC_ENABLEPURGECACHE) == BST_CHECKED)
			{
				hotkeys.hotkeyPurgePassphraseCache |= kPGPHotKeyEnabled;
			}

			// save encrypt hotkey
			hotkeys.hotkeyEncrypt =
				sGetHotKeyControl (GetDlgItem (hDlg, IDC_ENCRYPTHOTKEY));

			if (IsDlgButtonChecked (
					hDlg, IDC_ENABLEENCRYPT) == BST_CHECKED)
			{
				hotkeys.hotkeyEncrypt |= kPGPHotKeyEnabled;
			}

			// save sign hotkey
			hotkeys.hotkeySign =
				sGetHotKeyControl (GetDlgItem (hDlg, IDC_SIGNHOTKEY));

			if (IsDlgButtonChecked (
					hDlg, IDC_ENABLESIGN) == BST_CHECKED)
			{
				hotkeys.hotkeySign |= kPGPHotKeyEnabled;
			}

			// save encrypt & sign hotkey
			hotkeys.hotkeyEncryptSign =
				sGetHotKeyControl (GetDlgItem (hDlg, IDC_ENCRYPTSIGNHOTKEY));

			if (IsDlgButtonChecked (
					hDlg, IDC_ENABLEENCRYPTSIGN) == BST_CHECKED)
			{
				hotkeys.hotkeyEncryptSign |= kPGPHotKeyEnabled;
			}

			// save decrypt hotkey
			hotkeys.hotkeyDecrypt =
				sGetHotKeyControl (GetDlgItem (hDlg, IDC_DECRYPTHOTKEY));

			if (IsDlgButtonChecked (
					hDlg, IDC_ENABLEDECRYPT) == BST_CHECKED)
			{
				hotkeys.hotkeyDecrypt |= kPGPHotKeyEnabled;
			}

			// write prefs
			PGPclErrorBox (hDlg, PGPSetPrefData (PrefRefClient,
						kPGPPrefHotKeyData, sizeof(hotkeys), &hotkeys));

			returnErr = kPGPError_NoErr;

			// allow closure
            SetWindowLong (hDlg, DWL_MSGRESULT, PSNRET_NOERROR);
            return TRUE;
		}

		case PSN_KILLACTIVE :
		{
			PGPHotKeys	hotkeys;

			// get purge passphrase hotkey
			hotkeys.hotkeyPurgePassphraseCache =
				sGetHotKeyControl (GetDlgItem (hDlg, IDC_PURGEHOTKEY));

			if (IsDlgButtonChecked (
					hDlg, IDC_ENABLEPURGECACHE) == BST_CHECKED)
			{
				if (sIsHotKeyInUse (hotkeys.hotkeyPurgePassphraseCache))
				{
					PGPclMessageBox (hDlg, IDS_CAPTION, 
							IDS_PURGEHOTKEYINUSE, MB_ICONSTOP|MB_OK);
					SetFocus (GetDlgItem (hDlg, IDC_PURGEHOTKEY));
					SetWindowLong (hDlg, DWL_MSGRESULT, TRUE);
					return TRUE;
				}
				hotkeys.hotkeyPurgePassphraseCache |= kPGPHotKeyEnabled;
			}

			// get encrypt hotkey
			hotkeys.hotkeyEncrypt =
				sGetHotKeyControl (GetDlgItem (hDlg, IDC_ENCRYPTHOTKEY));

			if (IsDlgButtonChecked (
					hDlg, IDC_ENABLEENCRYPT) == BST_CHECKED)
			{
				if (sIsHotKeyInUse (hotkeys.hotkeyEncrypt))
				{
					PGPclMessageBox (hDlg, IDS_CAPTION, 
							IDS_ENCRYPTHOTKEYINUSE, MB_ICONSTOP|MB_OK);
					hWndFocus = GetDlgItem (hDlg, IDC_ENCRYPTHOTKEY);
					SetFocus (GetDlgItem (hDlg, IDC_ENCRYPTHOTKEY));
					SetWindowLong (hDlg, DWL_MSGRESULT, TRUE);
					return TRUE;
				}
				hotkeys.hotkeyEncrypt |= kPGPHotKeyEnabled;
			}

			// get sign hotkey
			hotkeys.hotkeySign =
				sGetHotKeyControl (GetDlgItem (hDlg, IDC_SIGNHOTKEY));

			if (IsDlgButtonChecked (
					hDlg, IDC_ENABLESIGN) == BST_CHECKED)
			{
				if (sIsHotKeyInUse (hotkeys.hotkeySign))
				{
					PGPclMessageBox (hDlg, IDS_CAPTION, 
							IDS_SIGNHOTKEYINUSE, MB_ICONSTOP|MB_OK);
					SetFocus (GetDlgItem (hDlg, IDC_SIGNHOTKEY));
					SetWindowLong (hDlg, DWL_MSGRESULT, TRUE);
					return TRUE;
				}
				hotkeys.hotkeySign |= kPGPHotKeyEnabled;
			}

			// get encrypt & sign hotkey
			hotkeys.hotkeyEncryptSign =
				sGetHotKeyControl (GetDlgItem (hDlg, IDC_ENCRYPTSIGNHOTKEY));

			if (IsDlgButtonChecked (
					hDlg, IDC_ENABLEENCRYPTSIGN) == BST_CHECKED)
			{
				if (sIsHotKeyInUse (hotkeys.hotkeyEncryptSign))
				{
					PGPclMessageBox (hDlg, IDS_CAPTION, 
							IDS_ENCRYPTSIGNHOTKEYINUSE, MB_ICONSTOP|MB_OK);
					SetFocus (GetDlgItem (hDlg, IDC_ENCRYPTSIGNHOTKEY));
					SetWindowLong (hDlg, DWL_MSGRESULT, TRUE);
					return TRUE;
				}
				hotkeys.hotkeyEncryptSign |= kPGPHotKeyEnabled;
			}

			// get decrypt hotkey
			hotkeys.hotkeyDecrypt =
				sGetHotKeyControl (GetDlgItem (hDlg, IDC_DECRYPTHOTKEY));

			if (IsDlgButtonChecked (
					hDlg, IDC_ENABLEDECRYPT) == BST_CHECKED)
			{
				if (sIsHotKeyInUse (hotkeys.hotkeyDecrypt))
				{
					PGPclMessageBox (hDlg, IDS_CAPTION, 
							IDS_DECRYPTHOTKEYINUSE, MB_ICONSTOP|MB_OK);
					SetFocus (GetDlgItem (hDlg, IDC_DECRYPTHOTKEY));
					SetWindowLong (hDlg, DWL_MSGRESULT, TRUE);
					return TRUE;
				}
				hotkeys.hotkeyDecrypt |= kPGPHotKeyEnabled;
			}

			// check for overlapping hotkeys
			if (sDoHotKeysOverlap (&hotkeys))
			{
				PGPclMessageBox (hDlg, IDS_CAPTION, IDS_OVERLAPPINGHOTKEYS,
						MB_ICONSTOP|MB_OK);
				SetWindowLong (hDlg, DWL_MSGRESULT, TRUE);
				return TRUE;
			}

			// allow closure
            SetWindowLong (hDlg, DWL_MSGRESULT, FALSE);
            return TRUE;
		}

		case PSN_RESET :
			returnErr = kPGPError_UserAbort;
            SetWindowLong (hDlg, DWL_MSGRESULT, FALSE);
			break;
		}
	}

	return FALSE;

}

//	_____________________________________________________
//
//  Initialize preferred algorithm combo box on basis of
//	enabled algorithms

static VOID
sInitPreferredAlgComboBox (HWND hDlg, UINT uInit) {

	INT		iIdx, iPrevAlg;
	CHAR	sz[32];
	UINT	uIndex;

	if (uInit) iPrevAlg = uInit;
	else {
		iIdx = SendDlgItemMessage (hDlg, IDC_PREFERREDALG, 
									CB_GETCURSEL, 0, 0);	
		if (iIdx != CB_ERR) 
			iPrevAlg = SendDlgItemMessage (hDlg, IDC_PREFERREDALG, 
									CB_GETITEMDATA, iIdx, 0);
		else 
			iPrevAlg = kPGPCipherAlgorithm_None;
	}
	SendDlgItemMessage (hDlg, IDC_PREFERREDALG, CB_RESETCONTENT, 0, 0);

	iIdx = -1;

	// put item into combobox for each enabled algorithm
	if (IsDlgButtonChecked (hDlg, IDC_ENABLECAST) == BST_CHECKED) {
		LoadString (g_hInst, IDS_CAST, sz, sizeof(sz));
		uIndex = SendDlgItemMessage (hDlg, IDC_PREFERREDALG, 
								CB_ADDSTRING, 0, (LPARAM)sz);
		if (uIndex != CB_ERR)
			SendDlgItemMessage (hDlg, IDC_PREFERREDALG, CB_SETITEMDATA, 
				uIndex, (LPARAM)kPGPCipherAlgorithm_CAST5);
		if (iPrevAlg == kPGPCipherAlgorithm_CAST5) iIdx = uIndex;
	}

	if (IsDlgButtonChecked (hDlg, IDC_ENABLEIDEA) == BST_CHECKED) {
		LoadString (g_hInst, IDS_IDEA, sz, sizeof(sz));
		uIndex = SendDlgItemMessage (hDlg, IDC_PREFERREDALG, 
								CB_ADDSTRING, 0, (LPARAM)sz);
		if (uIndex != CB_ERR)
			SendDlgItemMessage (hDlg, IDC_PREFERREDALG, CB_SETITEMDATA, 
				uIndex, (LPARAM)kPGPCipherAlgorithm_IDEA);
		if (iPrevAlg == kPGPCipherAlgorithm_IDEA) iIdx = uIndex;
	}

	if (IsDlgButtonChecked (hDlg, IDC_ENABLE3DES) == BST_CHECKED) {
		LoadString (g_hInst, IDS_3DES, sz, sizeof(sz));
		uIndex = SendDlgItemMessage (hDlg, IDC_PREFERREDALG, 
								CB_ADDSTRING, 0, (LPARAM)sz);
		if (uIndex != CB_ERR)
			SendDlgItemMessage (hDlg, IDC_PREFERREDALG, CB_SETITEMDATA, 
				uIndex, (LPARAM)kPGPCipherAlgorithm_3DES);
		if (iPrevAlg == kPGPCipherAlgorithm_3DES) iIdx = uIndex;
	}

#if ENABLE_TWOFISH
	if (IsDlgButtonChecked (hDlg, IDC_ENABLETWOFISH) == BST_CHECKED) {
		LoadString (g_hInst, IDS_TWOFISH, sz, sizeof(sz));
		uIndex = SendDlgItemMessage (hDlg, IDC_PREFERREDALG, 
								CB_ADDSTRING, 0, (LPARAM)sz);
		if (uIndex != CB_ERR)
			SendDlgItemMessage (hDlg, IDC_PREFERREDALG, CB_SETITEMDATA, 
				uIndex, (LPARAM)kPGPCipherAlgorithm_Twofish256);
		if (iPrevAlg == kPGPCipherAlgorithm_Twofish256) iIdx = uIndex;
	}
#endif //ENABLE_TWOFISH

	if (iIdx < 0) iIdx = 0;
	SendDlgItemMessage (hDlg, IDC_PREFERREDALG, CB_SETCURSEL, iIdx, 0);

}

//	_____________________________________________________
//
//  Message processing function for property sheet dialog

static LRESULT WINAPI 
sAdvancedPropDlgProc (
		HWND	hDlg, 
		UINT	uMsg, 
		WPARAM	wParam, 
		LPARAM	lParam) 
{
	PGPBoolean			b;
	UINT				u, uNumAlgs;
	INT					iIdx;
	PGPCipherAlgorithm*	pAlgs;
	PGPError			err;
	PGPSize				size;

	switch (uMsg) {

	case WM_INITDIALOG:
		if (bNeedsCentering) 
		{
			HWND	hParent;
			RECT	rc;

			hParent = GetParent (hDlg);
			GetWindowRect (hParent, &rc);
			SetWindowPos (hParent, NULL,
				(GetSystemMetrics(SM_CXSCREEN) - (rc.right - rc.left)) / 2,
				(GetSystemMetrics(SM_CYSCREEN) - (rc.bottom - rc.top)) / 3,
				0, 0, SWP_NOSIZE | SWP_NOZORDER);
			bNeedsCentering = FALSE;
		}

		// enable checkboxes of those ciphers supported by SDK
		err = 
			PGPclCheckSDKSupportForCipherAlg (kPGPCipherAlgorithm_CAST5);
		if (IsntPGPError (err))
			EnableWindow (GetDlgItem (hDlg, IDC_ENABLECAST), TRUE);
		err = 
			PGPclCheckSDKSupportForCipherAlg (kPGPCipherAlgorithm_3DES);
		if (IsntPGPError (err))
			EnableWindow (GetDlgItem (hDlg, IDC_ENABLE3DES), TRUE);
		err = 
			PGPclCheckSDKSupportForCipherAlg (kPGPCipherAlgorithm_IDEA);
		if (IsntPGPError (err))
			EnableWindow (GetDlgItem (hDlg, IDC_ENABLEIDEA), TRUE);
#if ENABLE_TWOFISH
		err = 
			PGPclCheckSDKSupportForCipherAlg (kPGPCipherAlgorithm_Twofish256);
		if (IsntPGPError (err))
			EnableWindow (GetDlgItem (hDlg, IDC_ENABLETWOFISH), TRUE);
#endif //ENABLE_TWOFISH
		
		// check boxes of enabled algorithms
		PGPGetPrefData (PrefRefClient, kPGPPrefAllowedAlgorithmsList,
							  &size, &pAlgs);
		uNumAlgs = size / sizeof(PGPCipherAlgorithm);

		for (u=0; u<uNumAlgs; u++) {
			err = PGPclCheckSDKSupportForCipherAlg (pAlgs[u]);
			if (IsntPGPError (err)) {
				switch (pAlgs[u]) {
				case kPGPCipherAlgorithm_CAST5 :
					CheckDlgButton (hDlg, IDC_ENABLECAST, BST_CHECKED);
					break;

				case kPGPCipherAlgorithm_3DES :
					CheckDlgButton (hDlg, IDC_ENABLE3DES, BST_CHECKED);
					break;

				case kPGPCipherAlgorithm_IDEA :
					CheckDlgButton (hDlg, IDC_ENABLEIDEA, BST_CHE