gmtree.c

vc环境下的pgp源码

			else iIdx = IDX_RSAPUBKEY;
		}
	}
	// DSA/ElGamal
	else {
		if (bSecret) {
			if (bRevoked) iIdx = IDX_DSASECREVKEY;
			else if (bExpired) iIdx = IDX_DSASECEXPKEY;
			else if (bDisabled) iIdx = IDX_DSASECDISKEY;
			else if (bSplit) iIdx = IDX_DSASECSHRKEY;
			else iIdx = IDX_DSASECKEY;
		}
		else {
			if (bRevoked) iIdx = IDX_DSAPUBREVKEY;
			else if (bExpired) iIdx = IDX_DSAPUBEXPKEY;
			else if (bDisabled) iIdx = IDX_DSAPUBDISKEY;
			else iIdx = IDX_DSAPUBKEY;
		}
	}

	if (lpbItalics) *lpbItalics = bRevoked || bExpired || bDisabled;
	return iIdx;
}


//	___________________________________________________
//
//  Reload a single group

static HTLITEM 
sReloadGroup (
		PGROUPMAN	pGM, 
		PGPGroupID	groupid, 
		INT			iIndex,
		BOOL		bReInsert, 
		BOOL		bForceNewAlloc, 
		BOOL		bExpandNew,
		BOOL		bFirstCall, 
		HTLITEM		hTParent, 
		HTLITEM		hTPrev) 
{

	HTLITEM				hTGroup, hTItem, hTItemPrev;
	TL_TREEITEM			tli;
	INT					i, iNumKeys, iNumTotal, idx;
	UINT				u, uState, uVal;
	BOOL				bNew, bItalics;
	PGPGroupInfo		groupinfo;
	PGPGroupItem		groupitem;
	PGPGroupID			groupidThis, groupidParent;
	PGPKeyRef			key;
	PGPError			err;
	CHAR				sz[kPGPMaxUserIDSize];
	CHAR				szID[kPGPMaxKeyIDStringSize];
	static BOOL			bNewKeyExpanded;

	uState = 0;
	bNew = FALSE;
	hTItem = NULL;
	hTItemPrev = TLI_FIRST;

	if (bFirstCall) bNewKeyExpanded = FALSE;

	if (hTParent) {
		groupidParent = groupid;
		PGPGetIndGroupItem (pGM->groupsetMain, groupidParent, 
												iIndex, &groupitem);
		groupidThis = groupitem.u.group.id;
		PGPGetGroupInfo (pGM->groupsetMain, groupidThis, &groupinfo);
		hTGroup = groupitem.userValue;
	}
	else {
		groupidThis = groupid;
		PGPGetGroupInfo (pGM->groupsetMain, groupidThis, &groupinfo);
		hTGroup = groupinfo.userValue;
	}
	if (!hTGroup) bNew = TRUE;

	// determine icon and italics
	idx = IDX_GROUP;

	// insert group item into tree and save pointer to tree item
	if (bNew && bExpandNew) uState |= TLIS_SELECTED;
	if (bForceNewAlloc) hTGroup = NULL;
	if (hTParent) {
		uVal = MAKELONG (iIndex, groupidParent);
		hTGroup = sSetOneGroupItem (pGM, bReInsert, hTGroup, hTParent, 
					groupinfo.name, hTPrev, idx, uState, uVal);
		PGPSetIndGroupItemUserValue (pGM->groupsetMain, groupidParent, 
					iIndex, (PGPUserValue)hTGroup);
	}
	else {
		uVal = MAKELONG (groupidThis, 0);
		hTGroup = sSetOneGroupItem (pGM, bReInsert, hTGroup, hTParent, 
					groupinfo.name, hTPrev, idx, uState, uVal);
		PGPSetGroupUserValue (pGM->groupsetMain, groupidThis, 
											(PGPUserValue)hTGroup);
	}

	// if a reinsertion, then we're done
	if (bReInsert) return hTGroup;

	sSetGroupData (pGM, hTGroup, groupidThis, groupinfo.description);

	// if not at root, then we don't draw items in group
	if (hTParent) return hTGroup;

	// iterate through items in group
	PGPCountGroupItems (pGM->groupsetMain, groupidThis, FALSE, &iNumKeys,
							&iNumTotal);

	for (i=0; i<iNumTotal; i++) {
		PGPGetIndGroupItem (pGM->groupsetMain, groupidThis, i, &groupitem);

		if (groupitem.type == kPGPGroupItem_KeyID) {

			err = PGPGetKeyByKeyID (pGM->keysetMain,
						&groupitem.u.key.keyID, 
						groupitem.u.key.algorithm, &key);

			if (IsntPGPError (err) && PGPRefIsValid (key)) {
				uState = 0;
				hTItem = (HTLITEM)groupitem.userValue;
				if (!hTItem) bNew = TRUE;
	
				// get and set treelist tree data for this key
				PGPGetPrimaryUserIDNameBuffer (key, sizeof(sz), sz, &u);
				if (bForceNewAlloc) hTItem = NULL;
				idx = sDetermineKeyIcon (key, &bItalics);
				if (bItalics) uState |= TLIS_ITALICS;

				uVal = MAKELONG (i, groupidThis);
				hTItem = sSetOneGroupItem (pGM, bReInsert, hTItem, hTGroup, 
								sz, hTItemPrev, idx, uState, uVal);

				PGPSetIndGroupItemUserValue (pGM->groupsetMain,
									groupidThis, i, (PGPUserValue)hTItem);

				sSetKeyData (pGM, hTItem, key, "");
			}
			else {
				hTItem = (HTLITEM)groupitem.userValue;
				if (!hTItem) bNew = TRUE;
	
				// get and set treelist tree data for this key
				if (bForceNewAlloc) hTItem = NULL;
				if (groupitem.u.key.algorithm == kPGPPublicKeyAlgorithm_RSA)
					idx = IDX_RSAPUBDISKEY;
				else
					idx = IDX_DSAPUBDISKEY;

				uState = TLIS_ITALICS;

				LoadString (g_hInst, IDS_UNAVAILABLE, sz, sizeof(sz));
				PGPGetKeyIDString (&groupitem.u.key.keyID, 
									kPGPKeyIDString_Abbreviated, szID);
				lstrcat (sz, szID);

				uVal = MAKELONG (i, groupidThis);
				hTItem = sSetOneGroupItem (pGM, bReInsert, hTItem, hTGroup, 
									sz, hTItemPrev, idx, uState, uVal);

				PGPSetIndGroupItemUserValue (pGM->groupsetMain,
									groupidThis, i, (PGPUserValue)hTItem);

			}
		}

		// this is a group within a group
		else {
			hTItem = sReloadGroup (pGM, groupidThis, i, bReInsert, 
					bForceNewAlloc, bExpandNew, FALSE, hTGroup, hTItemPrev);
		}

		hTItemPrev = hTItem;
	}

	// select and expand key, if appropriate 
	if (bExpandNew && bNew) {
		tli.hItem = hTGroup;
		if (!bNewKeyExpanded) {
			TreeList_Select (pGM->hWndTree, &tli, TRUE);
			TreeList_Expand (pGM->hWndTree, &tli, TLE_EXPANDALL);
			bNewKeyExpanded = TRUE;
		}
		else {
			GMSetFocus (pGM, GMFocusedItem (pGM), TRUE);
			TreeList_Expand (pGM->hWndTree, &tli, TLE_EXPANDALL);
		}
	}

	return hTGroup;
}


//	___________________________________________________
//
//  Scan entire groupset loading in any new data

BOOL 
GMLoadGroupsIntoTree (
		PGROUPMAN	pGM, 
		BOOL		bReInsert, 
		BOOL		bExpandNew, 
		BOOL		bForceRealloc) 
{

	HCURSOR			hCursorOld;
	TL_TREEITEM		tli;
	HTLITEM			hTPrevKey;
	BOOL			bFirst;
	PGPGroupID		groupid;
	INT				i, iNumGroups;

	hTPrevKey = (HTLITEM)TLI_FIRST;
	bFirst = TRUE;

	if (pGM->groupsetMain) {
		hCursorOld = SetCursor (LoadCursor (NULL, IDC_WAIT));
		PGPCountGroupsInSet (pGM->groupsetMain, &iNumGroups);

		for (i=0; i<iNumGroups; i++) {
			PGPGetIndGroupID (pGM->groupsetMain, i, &groupid);
			hTPrevKey = sReloadGroup (pGM, groupid, 0, bReInsert, 
						bForceRealloc, bExpandNew, bFirst, NULL, hTPrevKey);
			bFirst = FALSE;
		}

		SetCursor (hCursorOld);
		if (bExpandNew) {
			tli.hItem = GMFocusedItem (pGM);
			if (tli.hItem) TreeList_EnsureVisible (pGM->hWndTree, &tli);
		}
		return TRUE;
	}

	return FALSE;
}


//	___________________________________________________
//
//  Cleanup group manager

PGPError 
PGPgmDestroyGroupManager (HGROUPMAN hGM) 
{

	PGROUPMAN		pGM					= (PGROUPMAN)hGM;

	if (!hGM) return kPGPError_BadParams;

	RevokeDragDrop (pGM->hWndTree);
	GMReleaseDropTarget (pGM->pDropTarget);  
	CoLockObjectExternal ((IUnknown*)pGM->pDropTarget, FALSE, TRUE);

	PGPclCloseGroupFile (pGM->pGroupFile);

	GMSetColumnPreferences (pGM);

	SendMessage (pGM->hWndTree, WM_CLOSE, 0, 0);
	ImageList_Destroy (pGM->hIml);

	return kPGPError_NoErr;
}

//	___________________________________________________
//
//  Map dragover screen coordinates to window coords

BOOL
GMSelectGroup (PGROUPMAN pGM, POINTL ptl)
{
	POINT	pt;

	pt.x = ptl.x;
	pt.y = ptl.y;
	MapWindowPoints (NULL, pGM->hWndTree, &pt, 1);

	return (TreeList_DragOver (pGM->hWndTree, MAKELONG (pt.x, pt.y)));
}

//	___________________________________________________
//
//  Load keyset into treelist

PGPError 
PGPgmLoadGroups (HGROUPMAN hGroupMan)
{
	PGROUPMAN		pGM			= (PGROUPMAN)hGroupMan;

	if (!pGM) return kPGPError_BadParams;

	if (pGM->groupsetMain) {
		GMSetFocus (pGM, NULL, FALSE);
		TreeList_DeleteTree (pGM->hWndTree, TRUE);
		PGPclCloseGroupFile (pGM->pGroupFile);
		pGM->groupsetMain = NULL;
	}

	if (PGPRefIsValid (pGM->keysetMain)) {
		PGPclOpenGroupFile (pGM->context, &(pGM->pGroupFile));
		pGM->groupsetMain = pGM->pGroupFile->groupset;

		GMAddColumns (pGM);

		GMSortGroupSet (pGM);
		GMLoadGroupsIntoTree (pGM, FALSE, FALSE, TRUE);
		GMEnableDropTarget (pGM->pDropTarget, TRUE);
	}

	InvalidateRect (pGM->hWndTree, NULL, TRUE);
	UpdateWindow (pGM->hWndTree);

	return kPGPError_NoErr;
}


//	___________________________________________________
//
//  Load keyset into treelist

PGPError PGPgmExport 
PGPgmReLoadGroups (HGROUPMAN hGroupMan) 
{
	PGROUPMAN pGM = (PGROUPMAN)hGroupMan;
	if (!pGM) return kPGPError_BadParams;
	if (!pGM->groupsetMain) return kPGPError_BadParams;

	GMSortGroupSet (pGM);
	GMLoadGroupsIntoTree (pGM, FALSE, TRUE, FALSE);

	InvalidateRect (pGM->hWndTree, NULL, TRUE);
	UpdateWindow (pGM->hWndTree);

	return kPGPError_NoErr;
}

//	___________________________________________________
//
//	get PGPkeys path from registry and substitute Help file name 

VOID 
GMGetHelpFilePath (PGROUPMAN pGM) 
{
	CHAR	sz[MAX_PATH];

	PGPclGetPGPPath (pGM->szHelpFile, sizeof(pGM->szHelpFile));
	LoadString (g_hInst, IDS_HELPFILENAME, sz, sizeof(sz));
	lstrcat (pGM->szHelpFile, sz);
}

//	___________________________________________________
//
//  Set configuration

PGPError PGPgmExport 
PGPgmConfigure (
		HGROUPMAN	hGroupMan, 
		LPGMCONFIG	pGMConfig) 
{
	PGROUPMAN pGM = (PGROUPMAN)hGroupMan;
	if (!pGM) return kPGPError_BadParams;

	if (pGM) {
		if (pGMConfig->lpszHelpFile)
			lstrcpy (pGM->szHelpFile, pGMConfig->lpszHelpFile);
		else 
			GMGetHelpFilePath (pGM);

		pGM->hKM = pGMConfig->hKM;
		pGM->keysetMain = pGMConfig->keysetMain;
		pGM->ulOptionFlags = pGMConfig->ulOptionFlags;
		pGM->hWndStatusBar = pGMConfig->hWndStatusBar;

		if (pGM->ulOptionFlags & GMF_MARGASINVALID) 
			pGM->iValidityThreshold = GM_VALIDITY_COMPLETE;
		else
			pGM->iValidityThreshold = GM_VALIDITY_MARGINAL;

		return kPGPError_NoErr;
	}

	else return kPGPError_BadParams;

}