klcolumn.c

来自「PGP8.0源码 请认真阅读您的文件包然后写出其具体功能」· C语言 代码 · 共 321 行

/*____________________________________________________________________________
	Copyright (C) 2002 PGP Corporation
	All rights reserved.
		
	KLColumn.c - manage column selection
	
	$Id: KLColumn.c,v 1.11 2002/10/31 04:13:35 pbj Exp $
____________________________________________________________________________*/
#include "pgpPFLConfig.h"

// project header files
#include "PGPclx.h"
#include "PGPklx.h"

// typedefs
typedef struct {
	WORD wColumnField[NUMBERFIELDS];
	WORD wFieldWidth[NUMBERFIELDS];
	LONG lSortField;
} COLUMNPREFSSTRUCT, *PCOLUMNPREFSSTRUCT;

// constant definitions
#define DEFAULTCOLWIDTHNAME		240
#define DEFAULTCOLWIDTHVALID	50
#define DEFAULTCOLWIDTHTRUST	50
#define DEFAULTCOLWIDTHSIZE		70
#define DEFAULTCOLWIDTHDESC		200
#define MINWIDTH				10
#define MAXWIDTH				1000

#define KLI_NAME				0
#define KLI_VALIDITY			1
#define KLI_SIZE				2
#define KLI_DESCRIPTION			3
#define KLI_KEYID				4
#define KLI_TRUST				5
#define KLI_CREATION			6
#define KLI_EXPIRATION			7
#define KLI_ADK					8
#define NUMBERFIELDS			9

// external global variables
extern HINSTANCE g_hInst;

//	___________________________________________
//
//	Get widths of control columns from client prefs file
VOID 
KLGetColumnPreferences (PKEYLIST pKL)
{
	PGPError			err;
	PGPSize				size;
	PCOLUMNPREFSSTRUCT	pcps;
	INT					i;
	WORD				wField, wWidth;
	PGPPrefRef			prefref;

	if(PGPlnEnterprise())
	{
		pKL->wColumnField[0]				= KLI_NAME;
		pKL->wColumnField[1]				= KLI_VALIDITY;
		pKL->wColumnField[2]				= KLI_SIZE;
		pKL->wColumnField[3]				= KLI_DESCRIPTION;
		pKL->wColumnField[4]				= 0;
		pKL->wColumnField[5]				= 0;
		pKL->wColumnField[6]				= 0;
		pKL->wColumnField[7]				= 0;
		pKL->wColumnField[8]				= 0;

		pKL->wFieldWidth[KLI_NAME]			= DEFAULTCOLWIDTHNAME;
		pKL->wFieldWidth[KLI_VALIDITY]		= DEFAULTCOLWIDTHVALID;
		pKL->wFieldWidth[KLI_SIZE]			= DEFAULTCOLWIDTHSIZE;
		pKL->wFieldWidth[KLI_DESCRIPTION]	= DEFAULTCOLWIDTHDESC;
		pKL->wFieldWidth[KLI_KEYID]			= 0;
		pKL->wFieldWidth[KLI_TRUST]			= 0;
		pKL->wFieldWidth[KLI_CREATION]		= 0;
		pKL->wFieldWidth[KLI_EXPIRATION]	= 0;
		pKL->wFieldWidth[KLI_ADK]			= 0;
	}
	else
	{
		pKL->wColumnField[0]				= KLI_NAME;
		pKL->wColumnField[1]				= KLI_VALIDITY;
		pKL->wColumnField[2]				= KLI_TRUST;
		pKL->wColumnField[3]				= KLI_SIZE;
		pKL->wColumnField[4]				= KLI_DESCRIPTION;
		pKL->wColumnField[5]				= 0;
		pKL->wColumnField[6]				= 0;
		pKL->wColumnField[7]				= 0;
		pKL->wColumnField[8]				= 0;

		pKL->wFieldWidth[KLI_NAME]			= DEFAULTCOLWIDTHNAME;
		pKL->wFieldWidth[KLI_VALIDITY]		= DEFAULTCOLWIDTHVALID;
		pKL->wFieldWidth[KLI_SIZE]			= DEFAULTCOLWIDTHSIZE;
		pKL->wFieldWidth[KLI_DESCRIPTION]	= DEFAULTCOLWIDTHDESC;
		pKL->wFieldWidth[KLI_KEYID]			= 0;
		pKL->wFieldWidth[KLI_TRUST]			= DEFAULTCOLWIDTHTRUST;
		pKL->wFieldWidth[KLI_CREATION]		= 0;
		pKL->wFieldWidth[KLI_EXPIRATION]	= 0;
		pKL->wFieldWidth[KLI_ADK]			= 0;
	}

	pKL->lKeyListSortField				= kPGPKeyOrdering_UserID;

	err = PGPclPeekClientLibPrefRefs (&prefref, NULL);

	if (IsntPGPError (err))
	{
		err = PGPGetPrefData (prefref, 
				kPGPPrefPGPkeysWinColumnData, &size, &pcps);

		if (IsntPGPError (err)) 
		{
			if (size == sizeof(COLUMNPREFSSTRUCT)) 
			{
				for (i=0; i<NUMBERFIELDS; i++) 
				{
					wField = pcps->wColumnField[i];
					if ((wField >= 0) && (wField < NUMBERFIELDS))
						pKL->wColumnField[i] = wField;
					wWidth = pcps->wFieldWidth[i];
					if ((wWidth >= MINWIDTH) && (wWidth <= MAXWIDTH))
						pKL->wFieldWidth[i] = wWidth;
				}
				pKL->lKeyListSortField = pcps->lSortField;
			}
			PGPFreeData (pcps);
		}
	}
}

//	___________________________________________
// 
//	Put column information into client prefs file

VOID 
KLSetColumnPreferences (PKEYLIST pKL) 
{
	COLUMNPREFSSTRUCT	cps;
	INT					i, iField;
	PGPPrefRef			prefref;

	for (i=0; i<NUMBERFIELDS; i++) 
	{
		cps.wColumnField[i] = pKL->wColumnField[i];

		iField = pKL->wColumnField[i];
		if ((i == 0) || (iField != 0)) 
		{	
			pKL->wFieldWidth[iField] = 
					LOWORD (TreeList_GetColumnWidth (pKL->hwndTree, i));
			cps.wFieldWidth[iField] = pKL->wFieldWidth[iField];
		}
	}

	cps.lSortField = pKL->lKeyListSortField;

	if (IsntPGPError (PGPclPeekClientLibPrefRefs (&prefref, NULL)))
	{
		PGPSetPrefData (prefref, 
			kPGPPrefPGPkeysWinColumnData, sizeof(cps), &cps);
	}
}


//	_________________________
//
//	Retrieve flags indicating which columns are displayed

VOID 
KLGetSelectedColumns (
		PKEYLIST	pKL, 
		ULONG*		pulColumnFlags) 
{
	INT		iCol, iField;

	if (!pulColumnFlags) return;

	*pulColumnFlags = 0;

	for (iCol=1; iCol<NUMBERFIELDS; iCol++) 
	{
		iField = pKL->wColumnField[iCol];
		switch (iField) {
		case KLI_VALIDITY :
			*pulColumnFlags |= kPGPclKeyList_ValidityColumn;
			break;
		case KLI_SIZE :
			*pulColumnFlags |= kPGPclKeyList_SizeColumn;
			break;
		case KLI_DESCRIPTION :
			*pulColumnFlags |= kPGPclKeyList_DescriptionColumn;
			break;
		case KLI_KEYID :
			*pulColumnFlags |= kPGPclKeyList_KeyIDColumn;
			break;
		case KLI_TRUST :
			*pulColumnFlags |= kPGPclKeyList_TrustColumn;
			break;
		case KLI_CREATION :
			*pulColumnFlags |= kPGPclKeyList_CreationColumn;
			break;
		case KLI_EXPIRATION :
			*pulColumnFlags |= kPGPclKeyList_ExpirationColumn;
			break;
		case KLI_ADK :
			*pulColumnFlags |= kPGPclKeyList_ADKColumn;
			break;
		}
	}
	return;
}


//	_________________________
//
//	Remove columns to display

static VOID 
sRemoveColumn (
		PKEYLIST	pKL, 
		INT			iField) 
{
	INT i, j;

	for (i=1; i<NUMBERFIELDS; i++) 
	{
		if (pKL->wColumnField[i] == iField) 
		{
			for (j=i+1; j<NUMBERFIELDS; j++) 
			{
				pKL->wColumnField[j-1] = pKL->wColumnField[j];
			}
			pKL->wColumnField[NUMBERFIELDS-1] = 0;
			return;
		}
	}
}

			
//	_________________________
//
//	Add columns to display

static VOID 
sAddColumn (
		PKEYLIST	pKL, 
		INT			iField) 
{
	INT i, iNumCol;
	
	iNumCol = 1;
	for (i=0; i<NUMBERFIELDS; i++) 
	{
		if (pKL->wColumnField[i]) iNumCol++;
	}

	for (i=0; i<iNumCol; i++) 
	{
		if (pKL->wColumnField[i] == iField) return;
	}

	pKL->wColumnField[iNumCol] = iField;
	if ((pKL->wFieldWidth[iField] > 1000) ||
		(pKL->wFieldWidth[iField] <= 0)) 
	{
		pKL->wFieldWidth[iField] = 60;
	}
}


//	_________________________
//
//	Select columns to display

VOID 
KLSelectColumns (
		PKEYLIST	pKL, 
		ULONG		ulColumnFlags) 
{
	if (ulColumnFlags & kPGPclKeyList_ValidityColumn) 
		sAddColumn (pKL, KLI_VALIDITY);
	else 
		sRemoveColumn (pKL, KLI_VALIDITY);

	if (ulColumnFlags & kPGPclKeyList_SizeColumn) 
		sAddColumn (pKL, KLI_SIZE);
	else 
		sRemoveColumn (pKL, KLI_SIZE);

	if (ulColumnFlags & kPGPclKeyList_DescriptionColumn) 
		sAddColumn (pKL, KLI_DESCRIPTION);
	else 
		sRemoveColumn (pKL, KLI_DESCRIPTION);

	if (ulColumnFlags & kPGPclKeyList_KeyIDColumn) 
		sAddColumn (pKL, KLI_KEYID);
	else 
		sRemoveColumn (pKL, KLI_KEYID);

	if (ulColumnFlags & kPGPclKeyList_TrustColumn) 
		sAddColumn (pKL, KLI_TRUST);
	else 
		sRemoveColumn (pKL, KLI_TRUST);

	if (ulColumnFlags & kPGPclKeyList_CreationColumn) 
		sAddColumn (pKL, KLI_CREATION);
	else 
		sRemoveColumn (pKL, KLI_CREATION);

	if (ulColumnFlags & kPGPclKeyList_ExpirationColumn) 
		sAddColumn (pKL, KLI_EXPIRATION);
	else 
		sRemoveColumn (pKL, KLI_EXPIRATION);

	if (ulColumnFlags & kPGPclKeyList_ADKColumn) 
		sAddColumn (pKL, KLI_ADK);
	else 
		sRemoveColumn (pKL, KLI_ADK);
}