pkmsgprc.c

vc环境下的pgp源码

			if (PGPKeySetRefIsValid (ppks->KeySetDisp))
			{
				PGPFreeKeySet (ppks->KeySetDisp);
				ppks->KeySetDisp = NULL;
			}
			if (lParam)
				ppks->KeySetMain = (PGPKeySetRef)lParam;
			PGPkmLoadKeySet (ppks->hKM, 
								ppks->KeySetDisp, ppks->KeySetMain);
		}
		break;

	case KM_M_CREATEDONE :
		ppks = (PGPKEYSSTRUCT*)GetWindowLong (hWnd, GWL_USERDATA);
		ShowWindow (hWnd, SW_SHOW);
		EnableWindow (hWnd, TRUE);
		SetForegroundWindow (hWnd);
		if (ppks->bGroupsFocused) SetFocus (ppks->hWndTreeListGroups);
		else SetFocus (ppks->hWndTreeList);
		if (wParam & KCD_NEWKEY) {
			PGPPrefRef PrefRef;
			PGPclOpenClientPrefs (
					PGPGetContextMemoryMgr (g_Context), 
					&PrefRef);
			PGPSetPrefBoolean (PrefRef, kPGPPrefFirstKeyGenerated, 
											(Boolean)TRUE);
			PGPclCloseClientPrefs (PrefRef, TRUE);
			bKeyHasBeenGenerated = TRUE;
			PKCommitKeyRingChanges (ppks->KeySetMain, TRUE);
			PGPkmReLoadKeySet (ppks->hKM, TRUE);
			if (wParam & KCD_NEWDEFKEY) 
				PGPkmPerformAction (ppks->hKM, KM_SETASDEFAULT);
			PGPkmSelectKey (ppks->hKM, (PGPKeyRef)lParam, TRUE);
		}
		InvalidateRect (hWnd, NULL, FALSE);
		return TRUE;

	case KM_M_REQUESTSDKACCESS :
		ppks = (PGPKEYSSTRUCT*)GetWindowLong (hWnd, GWL_USERDATA);
		PGPkmSynchronizeThreadAccessToSDK (ppks->hKM);
		break;

	case KM_M_KEYPROPACTION :
		ppks = (PGPKEYSSTRUCT*)GetWindowLong (hWnd, GWL_USERDATA);
		PGPkmProcessKeyPropMessage (ppks->hKM, wParam, lParam);
		break;

	case KM_M_RESIZE :
		ppks = (PGPKEYSSTRUCT*)GetWindowLong (hWnd, GWL_USERDATA);
		GetClientRect (hWnd, &rc);
		if (ppks->hWndToolBar) {
			SetWindowPos (ppks->hWndToolBar, NULL, 
					0, 0, 
					(rc.right-rc.left), 
					ppks->iToolHeight, 
					SWP_NOMOVE|SWP_NOZORDER);
		}
		if (ppks->hWndTreeList) {
			SetWindowPos (ppks->hWndTreeList, NULL, 
					0, ppks->iToolHeight, 
					(rc.right-rc.left), 
					ppks->iKeysHeight, 
					SWP_NOZORDER);
		}
		if (ppks->hWndTreeListGroups) {
			SetWindowPos (ppks->hWndTreeListGroups, NULL, 
					0, 
					(rc.bottom-rc.top)-ppks->iGroupsHeight-STATUSBARHEIGHT,
					(rc.right-rc.left),
					ppks->iGroupsHeight,
					SWP_NOZORDER);
		}
		UpdateWindow (hWnd);
		break;

	case WM_COMMAND:
		ppks = (PGPKEYSSTRUCT*)GetWindowLong (hWnd, GWL_USERDATA);

		switch (LOWORD(wParam)) {
		case IDM_FILEEXIT:
			SendMessage (hWnd, WM_CLOSE, 0, 0);
			break;

		case IDM_SENDSHARES :
			PGPclSendShares (g_Context, g_TLSContext, hWnd, ppks->KeySetMain);
			break;

		case IDM_HELPABOUT :
			PKHelpAbout (hWnd);
			break;

		case IDM_HELPTOPICS :
			WinHelp (hWnd, g_szHelpFile, HELP_FINDER, 0);
			break;

		case IDM_PREFERENCES :
			PKPGPPreferences (ppks, hWnd, PGPCL_GENERALPREFS);
			break;

		case IDM_CERTIFYKEY :
			PGPkmPerformAction (ppks->hKM, KM_CERTIFY); 
			break;

		case IDM_DISABLEKEY :
			if (!ppks->bMainWindow && !ppks->bLocalKeySet &&
				(ppks->uKeySelectionFlags == PGPKM_KEYFLAG))
				PGPkmPerformAction (ppks->hKM, KM_DISABLEONSERVER); 
			else 
				PGPkmPerformAction (ppks->hKM, KM_DISABLE); 
			break;

		case IDM_ENABLEKEY :
			PGPkmPerformAction (ppks->hKM, KM_ENABLE); 
			break;

		case IDM_DELETEKEY :
			if (ppks->bGroupsFocused) 
				PGPgmPerformAction (ppks->hGM, GM_DELETE); 
			else
				PGPkmPerformAction (ppks->hKM, KM_DELETE); 
			break;

		case IDM_DELETESERVER :
			PGPkmPerformAction (ppks->hKM, KM_DELETEFROMSERVER); 
			break;

		case IDM_CREATEKEY :
			if (g_bKeyGenEnabled) {
				PKCreateKey (hWnd, ppks->KeySetMain);
			}
			break;

		case IDM_SETASDEFAULT :
			if (PGPkmIsActionEnabled (ppks->hKM, KM_SETASPRIMARY))
				PGPkmPerformAction (ppks->hKM, KM_SETASPRIMARY); 
			else
				PGPkmPerformAction (ppks->hKM, KM_SETASDEFAULT); 
			break;

		case IDM_PROPERTIES :
			if (ppks->bGroupsFocused) {
				PGPgmPerformAction (ppks->hGM, GM_LOCATEKEYS);
				PGPkmPerformAction (ppks->hKM, KM_PROPERTIES); 
			}
			else 
				PGPkmPerformAction (ppks->hKM, KM_PROPERTIES); 
			break;
				
		case IDM_GROUPPROPERTIES :
			PGPgmPerformAction (ppks->hGM, GM_PROPERTIES);
			break;
		
		case IDM_IMPORTKEYS :
			PGPkmPerformAction (ppks->hKM, KM_IMPORT); 
			break;

		case IDM_IMPORTGROUPS :
			PGPgmPerformAction (ppks->hGM, GM_IMPORTGROUPS); 
			break;
		
		case IDM_EXPORTKEYS :
			PGPkmPerformAction (ppks->hKM, KM_EXPORT); 
			break;

		case IDM_GETFROMSERVER :
			if (ppks->bGroupsFocused)
				PGPgmPerformAction (ppks->hGM, GM_GETFROMSERVER);
			else
				PGPkmPerformAction (ppks->hKM, KM_GETFROMSERVER);
			break;

		case IDM_RETRIEVECERTIFICATE :
			PGPkmPerformAction (ppks->hKM, KM_RETRIEVECERTIFICATE);
			break;

		case IDM_ADDTOMAIN :
			PGPkmPerformAction (ppks->hKM, KM_ADDTOMAIN);
			break;

		case IDM_EXPANDSEL :
			if (ppks->bGroupsFocused) {
				if (PGPgmIsActionEnabled (ppks->hGM, GM_EXPANDSEL))
					PGPgmPerformAction (ppks->hGM, GM_EXPANDSEL); 
				else
					PGPgmPerformAction (ppks->hGM, GM_EXPANDALL); 
			}
			else {
				if (PGPkmIsActionEnabled (ppks->hKM, KM_EXPANDSEL))
					PGPkmPerformAction (ppks->hKM, KM_EXPANDSEL); 
				else
					PGPkmPerformAction (ppks->hKM, KM_EXPANDALL); 
			}
			break;

		case IDM_COLLAPSESEL :
			if (ppks->bGroupsFocused) {
				if (PGPgmIsActionEnabled (ppks->hGM, GM_COLLAPSESEL))
					PGPgmPerformAction (ppks->hGM, GM_COLLAPSESEL); 
				else
					PGPgmPerformAction (ppks->hGM, GM_COLLAPSEALL); 
			}
			else {
				if (PGPkmIsActionEnabled (ppks->hKM, KM_COLLAPSESEL))
					PGPkmPerformAction (ppks->hKM, KM_COLLAPSESEL); 
				else
					PGPkmPerformAction (ppks->hKM, KM_COLLAPSEALL); 
			}
			break;

		case IDM_SELECTALL :
			if (ppks->bGroupsFocused) 
				PGPgmPerformAction (ppks->hGM, GM_SELECTALL); 
			else
				PGPkmPerformAction (ppks->hKM, KM_SELECTALL); 
			PKSetToolbarButtonStates (ppks);
			break;

		case IDM_REVOKEKEY :
			PGPkmPerformAction (ppks->hKM, KM_REVOKE); 
			break;

		case IDM_COPYKEY :
			PGPkmPerformAction (ppks->hKM, KM_COPY); 
			break;

		case IDM_PASTEKEY :
			if (ppks->bGroupsFocused) 
				PGPgmPerformAction (ppks->hGM, GM_PASTE); 
			else 
				PGPkmPerformAction (ppks->hKM, KM_PASTE); 
			break;

		case IDM_ADDUSERID :
			PGPkmPerformAction (ppks->hKM, KM_ADDUSERID); 
			break;

		case IDM_ADDPHOTOID :
			PGPkmPerformAction (ppks->hKM, KM_ADDPHOTOID); 
			break;

		case IDM_ADDREVOKER :
			PGPkmPerformAction (ppks->hKM, KM_ADDREVOKER); 
			break;

		case IDM_ADDCERTIFICATE :
			PGPkmPerformAction (ppks->hKM, KM_ADDCERTIFICATE); 
			break;

		case IDM_SPLITKEY :
			PGPkmPerformAction (ppks->hKM, KM_SPLITKEY); 
			break;

		case IDM_REVERIFY :
			PGPkmPerformAction (ppks->hKM, KM_REVERIFYSIGS);
			break;

		case IDM_VIEWVALIDITY :
			ulColumns ^= KM_VALIDITY;
			PGPkmSelectColumns (ppks->hKM, ulColumns, TRUE);
			break;

		case IDM_VIEWSIZE :
			ulColumns ^= KM_SIZE;
			PGPkmSelectColumns (ppks->hKM, ulColumns, TRUE);
			break;

		case IDM_VIEWDESC :
			ulColumns ^= KM_DESCRIPTION;
			PGPkmSelectColumns (ppks->hKM, ulColumns, TRUE);
			break;

		case IDM_VIEWKEYID :
			ulColumns ^= KM_KEYID;
			PGPkmSelectColumns (ppks->hKM, ulColumns, TRUE);
			break;

		case IDM_VIEWTRUST :
			ulColumns ^= KM_TRUST;
			PGPkmSelectColumns (ppks->hKM, ulColumns, TRUE);
			break;

		case IDM_VIEWCREATION :
			ulColumns ^= KM_CREATION;
			PGPkmSelectColumns (ppks->hKM, ulColumns, TRUE);
			break;

		case IDM_VIEWEXPIRATION :
			ulColumns ^= KM_EXPIRATION;
			PGPkmSelectColumns (ppks->hKM, ulColumns, TRUE);
			break;

		case IDM_VIEWADK :
			ulColumns ^= KM_ADK;
			PGPkmSelectColumns (ppks->hKM, ulColumns, TRUE);
			break;

		case IDM_VIEWTOOLBAR :
			if (ppks->iToolHeight == 0) 
				ppks->iToolHeight = DEFAULTTOOLHEIGHT;
			else 
				ppks->iToolHeight = 0;
			GetClientRect (hWnd, &rc);
			ppks->iKeysHeight = 
					(rc.bottom-rc.top)-ppks->iToolHeight-STATUSBARHEIGHT;
			if (ppks->iGroupsHeight)
				ppks->iKeysHeight -= (ppks->iGroupsHeight + GRABBARHEIGHT);
			PostMessage (hWnd, KM_M_RESIZE, 0, 0);
			break;

		case IDM_FINDKEY :
			PGPgmPerformAction (ppks->hGM, GM_LOCATEKEYS);
			ppks->bGroupsFocused = FALSE;
			SetFocus (ppks->hWndTreeList);
			break;

		case IDM_UPDATEINTRODUCERS :
			if (PKAutoUpdateIntroducers (hWnd, ppks->KeySetMain, FALSE))
				PGPkmReLoadKeySet (ppks->hKM, TRUE);
			break;

		case IDM_UPDATEREVOCATIONS :
			PKUpdateCARevocations (hWnd, ppks->hKM, ppks->KeySetMain);
			break;

		case IDM_UPDATEGROUPLISTS :
			PGPgmPerformAction (ppks->hGM, GM_UPDATEALLGROUPS); 
			break;

		case IDM_SENDGROUPLISTS :
			PGPgmPerformAction (ppks->hGM, GM_SENDALLGROUPS); 
			break;

		case IDM_NEWGROUP :
			PGPgmNewGroup (ppks->hGM);
			break;

		case IDM_VIEWGROUPS :
			if (ppks->bGroupsVisible) {
				ppks->bGroupsVisible = FALSE;
				CheckMenuItem (ppks->hMenuKeyMan, IDM_VIEWGROUPS, 
															MF_UNCHECKED);
				ppks->iGroupsHeight = 0;
				GetClientRect (hWnd, &rc);
				ppks->iKeysHeight = 
					(rc.bottom-rc.top)-ppks->iToolHeight-STATUSBARHEIGHT;
				PostMessage (hWnd, KM_M_RESIZE, 0, 0);
			}
			else {
				ppks->bGroupsVisible = TRUE;
				PGPgmReLoadGroups (ppks->hGM);
				CheckMenuItem (ppks->hMenuKeyMan, IDM_VIEWGROUPS, MF_CHECKED);
				GetClientRect (hWnd, &rc);
				ppks->iGroupsHeight = 
					(rc.bottom-rc.top) * ppks->iGroupsPercent;
				ppks->iGroupsHeight /= 100;
				ppks->iKeysHeight = 
					(rc.bottom-rc.top)-ppks->iToolHeight-STATUSBARHEIGHT-
					ppks->iGroupsHeight-GRABBARHEIGHT;
				PostMessage (hWnd, KM_M_RESIZE, 0, 0);
			}
			break;

		case IDM_SEARCH :
			{
				RECT	rc;
				INT		iHeight, iWidth;
				CHAR	sz[64];
				ULONG	ulColumns;

				// if main window has not finished initializing, then ignore
				if (!ppks->KeySetMain)
					break;

				// if search window already exists, move to front
				if (hwndOpenSearch) {
					ShowWindow (hwndOpenSearch, SW_RESTORE);
					SetForegroundWindow (hwndOpenSearch);
					break;
				}

				// save column info of main window
				PGPkmGetSelectedColumns (ppks->hKM, &ulColumns);
				PGPkmSelectColumns (ppks->hKM, ulColumns, FALSE);

				// create new search window
				LoadString (g_hInst, IDS_SEARCHTITLE, sz, sizeof(sz));
				GetWindowRect (hWnd, &rc);
				iWidth = rc.right - rc.left;
				if (iWidth < MINSEARCHWINDOWWIDTH)
					iWidth = MINSEARCHWINDOWWIDTH;
				iHeight = ((rc.bottom-rc.top)*3)>>2;
				if (iHeight < MINSEARCHWINDOWHEIGHT) 
					iHeight = MINSEARCHWINDOWHEIGHT;
				if (rc.left+60+iWidth > GetSystemMetrics (SM_CXSCREEN))
					rc.left = GetSystemMetrics (SM_CXSCREEN) - iWidth - 60;
				CreateWindow (WINCLASSNAME, sz, 
					WS_OVERLAPPEDWINDOW|WS_VISIBLE, rc.left+60, 
					rc.top+60, iWidth,
					iHeight, NULL, NULL, g_hInst, 
					(LPVOID)(ppks->KeySetMain));
			}
			break;

		case IDM_DOMAINKEYSERVER :
			SendMessage (hWnd, WM_COMMAND, IDM_DOMAINKEYSERVERX, 0);
			break;

		case IDM_DOMAINKEYSERVERX :
			ZeroMemory (&ppks->kmConfig.keyserver, sizeof(PGPKeyServerEntry));
			ppks->kmConfig.ulMask = PGPKM_KEYSERVER;
			PGPkmConfigure (ppks->hKM, &(ppks->kmConfig));
			PGPkmPerformAction (ppks->hKM, KM_SENDTOSERVER);
			break;

		case IDM_TOOLBARSENDTOSERVER :
			PKGetSendToServerButtonRect (ppks->hWndToolBar, &rc);
			MapWindowPoints (ppks->hWndMain, NULL, (LPPOINT)&rc, 2);
			PKToolbarKeyserverMenu (hWnd, &rc);
			break;

		default :
			if (LOWORD (wParam) > IDM_DOMAINKEYSERVERX) {
				PKGetServerFromID (LOWORD (wParam),
									&ppks->kmConfig.keyserver);
				ppks->kmConfig.ulMask = PGPKM_KEYSERVER;
				PGPkmConfigure (ppks->hKM, &(ppks->kmConfig));
				PGPkmPerformAction (ppks->hKM, KM_SENDTOSERVER);
			}
			break;
		}
		break;

	default :
		// check for mousewheel message
		if (uMsg == g_uMouseWheelMessage) {
			WORD iDelta;

			ppks = (PGPKEYSSTRUCT*)GetWindowLong (hWnd, GWL_USERDATA);
			iDelta = (WORD)wParam;
			
			if (ppks->bGroupsFocused)
				SendMessage (ppks->hWndTreeListGroups, 
								WM_MOUSEWHEEL, MAKEWPARAM (0, iDelta), 0);
			else
				SendMessage (ppks->hWndTreeList, 
								WM_MOUSEWHEEL, MAKEWPARAM (0, iDelta), 0);
			return FALSE;
		}

		// check for prefs broadcast message
		else if (uMsg == g_uReloadPrefsMessage) {
			ppks = (PGPKEYSSTRUCT*)GetWindowLong (hWnd, GWL_USERDATA);
			PKReloadPGPPreferences (ppks);
		}

		// check for keyring broadcast message
		else if (uMsg == g_uReloadKeyringMessage) {
			ppks = (PGPKEYSSTRUCT*)GetWindowLong (hWnd, GWL_USERDATA);
			if (ppks->kmConfig.ulOptionFlags & KMF_ENABLERELOADS) {
				if (ppks->bMainWindow) {
					if ((DWORD)lParam != GetCurrentProcessId ()) {
						if (!bIgnoreReloads)
							PostMessage (hWnd, KM_M_RELOADKEYRINGS, 0, 0);
					}
					else {
						if (LOWORD (wParam) != LOWORD (hWnd)) {
							if (HIWORD (wParam))
								PGPkmReLoadKeySet (ppks->hKM, TRUE);
							else 
								PGPkmLoadKeySet (ppks->hKM, ppks->KeySetMain, 
													ppks->KeySetMain);
						}
						if (ppks->bGroupsVisible)
							PGPgmReLoadGroups (ppks->hGM);
					}
				}
				else {
					if (((DWORD)lParam != GetCurrentProcessId ()) ||
						(LOWORD (wParam) != LOWORD (hWnd))) 
					{
						if (ppks->KeySetDisp)
						{
							PGPFreeKeySet (ppks->KeySetDisp);
							ppks->KeySetDisp = NULL;
						}
						PGPkmLoadKeySet (ppks->hKM, ppks->KeySetDisp, 
													ppks->KeySetMain);
						SendMessage (ppks->hWndSearchControl, 
							SEARCH_SET_CURRENT_SEARCH, 0, 0);
					}
				}
			}
			return TRUE;
		}

		// check for keyserver prefs broadcast message
		else if (uMsg == g_uReloadKeyserverPrefsMessage) {
			ppks = (PGPKEYSSTRUCT*)GetWindowLong (hWnd, GWL_USERDATA);
			if (!ppks->bMainWindow) {
				NMHDR nmhdr;

				nmhdr.hwndFrom = hWnd;
				nmhdr.idFrom = 0;
				nmhdr.code = REFRESH_KEYSERVER_LIST;

				SendMessage (ppks->hWndSearchControl, 
					WM_NOTIFY, 
					0, 
					(LPARAM)&nmhdr);
			}
			return TRUE;
		}

		// check for purge passphrase cache broadcast message
		else if (uMsg == g_uPurgePassphraseCacheMessage) {
			PGPclPurgeCachedPassphrase (wParam);
			return TRUE;
		}

		else return (DefWindowProc (hWnd, uMsg, wParam, lParam));
	}
	return FALSE;
}