cpublickeysview.cpp

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

/*____________________________________________________________________________
		Copyright (C) 2002 PGP Corporation
        All rights reserved.

        $Id: CPublicKeysView.cpp,v 1.7 2002/09/24 19:58:28 wjb Exp $
____________________________________________________________________________*/

#include "pgpClassesConfig.h"
#include <stdio.h>

#include "UString.h"

#include "UModuleInstance.h"
#include "CBitmap.h"
#include "CBrush.h"
#include "CDC.h"
#include "CFont.h"
#include "CIcon.h"
#include "CImageList.h"
#include "CMenu.h"
#include "CPen.h"
#include "CRect.h"

#include "CPGPContext.h"
#include "CPGPdiskEngine.h"
#include "CPGPKey.h"
#include "UCommonStrings.h"

#include "CPublicKeysView.h"
#include "ImageIDs.h"

#include "pgpUnicode.h"

#include "Resource.h"

_USING_PGP

_UNNAMED_BEGIN

// Constants

const float	kUserIDColRatio		= 0.60F;
const float	kValidityColRatio	= 0.16F;
const float	kSizeColRatio		= 0.24F;

_UNNAMED_END


// Types

struct CPublicKeysView::PKViewDrawElements
{
	COLORREF	barColor;
	CBrush		stdBarBrush;
	CBrush		spcBarBrush;
	CPen		gSelTextPen;
	CPen		gUnselTextPen;
	CPen		hilightPen;
	CPen		shadowPen;
	CPen		buttonPen;

	CBrush		barBGBrush;
	CBrush		highBrush;
	CBrush		backBrush;
	CFont		hFont;
	CFont		hItalic;
	CFont		hStrikeOut;

	CImageList	image;
};


// Class CPublicKeysView member functions

CPublicKeysView::CPublicKeysView() : 

	mPContext(NULL), mPDE(NULL), mUserIDColIndex(0), mValidityColIndex(0), 
		mSizeColIndex(0)
{
}

CPublicKeysView::CPublicKeysView(HWND hWnd) : 
	CListView(hWnd), mPContext(NULL), mPDE(NULL)
{
}

PGPInt32 
CPublicKeysView::FindKeyIDIndex(const CPGPKeyID& keyID) const
{
	PubKeyItem	*pItem	= mItemList.Head();

	while (IsntNull(pItem))
	{
		if (keyID.IsEqual(pItem->keyID))
			return GetIndexOfItem(pItem);

		pItem = mItemList.Next(pItem);
	}

	return -1;
}

void 
CPublicKeysView::GetSelectedItems(
	CArray<PubKeyItem>&	items, 
	PGPUInt32&			numItems) const
{
	numItems = GetSelectedCount();
	items.Resize(numItems);

	PGPUInt32	itemCount	= GetItemCount();
	PGPUInt32	arrayIndex	= 0;

	for (PGPInt32 i = itemCount - 1; i >= 0; i--)
	{
		PubKeyItem	*pItem	= GetItemAtIndex(i);

		if (GetItemState(i, LVIS_SELECTED))
			items[arrayIndex++] = *pItem;
	}
}

void 
CPublicKeysView::SelectIndex(PGPInt32 i)
{
	SetItemState(i, LVIS_FOCUSED | LVIS_SELECTED, 
		LVIS_FOCUSED | LVIS_SELECTED);
	RedrawItems(i, i);
}

void 
CPublicKeysView::SelectAllItems()
{
	PGPInt32	count	= GetItemCount();

	for (PGPInt32 i = 0; i < count; i++)
	{
		if (i == 0)
		{
			SetItemState(i, LVIS_FOCUSED | LVIS_SELECTED, 
				LVIS_FOCUSED | LVIS_SELECTED);
		}
		else
		{
			SetItemState(i, LVIS_SELECTED, LVIS_SELECTED);
		}
	}

	RedrawItems(0, count - 1);
}

void 
CPublicKeysView::AddKey(const CPGPKey& key, const CPGPKey &subKey)
{
	auto_ptr<PubKeyItem>	pItem(new PubKeyItem);

	pItem->isOnlyKeyIDValid = FALSE;
	pItem->key = key;
	pItem->subKey = subKey;

	CPGPKeyID	keyID;
	key.GetKeyID(keyID);

	pItem->keyID	= keyID;
	pItem->readOnly	= FALSE;
	pItem->locked	= FALSE;

	AddKeyItem(pItem.get());
	pItem.release();
}

void 
CPublicKeysView::AddKey(
	const CPGPKeyID&		keyID, 
	PGPBoolean				readOnly, 
	PGPBoolean				locked)
{
	auto_ptr<PubKeyItem>	pItem(new PubKeyItem);

	pItem->isOnlyKeyIDValid = TRUE;
	pItem->keyID = keyID;

	pItem->readOnly = readOnly;
	pItem->locked = locked;

	AddKeyItem(pItem.get());
	pItem.release();
}

void 
CPublicKeysView::RemoveKeyAtIndex(PGPInt32 i)
{
	PubKeyItem	*pItem	= GetItemAtIndex(i);

	DeleteItem(i);
	delete mItemList.Remove(pItem);
}

void 
CPublicKeysView::SetActiveColumns(PGPUInt32 columns)
{
	mActiveColumns = columns;

	UpdateColumns();
	InvalidateRect(NULL, TRUE);
}

void 
CPublicKeysView::SortOnColumn(PGPUInt32 column)
{
	if (mLastSortColumn == column)
		mSortAscending = !mSortAscending;
	else
		mSortAscending = TRUE;

	mLastSortColumn = column;
	SortItems(PubKeyViewCompareProc, reinterpret_cast<LPARAM>(this));
}

void 
CPublicKeysView::Initialize(
	const CPGPdiskContext	*pContext, 
	PGPBoolean				singleSelect, 
	PGPBoolean				marginalInvalid, 
	PGPBoolean				displayMarginal)
{
	pgpAssertAddrValid(pContext, CPGPdiskContext);

	Clear();
	CreateDrawElements();

	mPContext = pContext;

	mSingleSelect		= singleSelect;
	mMarginalInvalid	= marginalInvalid;
	mDisplayMarginal	= displayMarginal;

	mSortAscending = FALSE;
	mLastSortColumn = 0;

	if (singleSelect)
		SetStyle(GetStyle() | LVS_SINGLESEL);

	SetActiveColumns(kUserIDColFlag | kValidityColFlag | kSizeColFlag);
	GenerateMeasureItem();
}

void 
CPublicKeysView::Clear()
{
	DeleteAllItems();
	mItemList.EmptyWithDelete();

	if (IsntNull(mPDE))
		DeleteDrawElements();
}

PGPUInt32 
CPublicKeysView::ConvertFromPGPValidity(PGPUInt32 uPGPValidity) const
{
	switch (uPGPValidity)
	{
	case kPGPValidity_Unknown:
	case kPGPValidity_Invalid:
		return 0;
	case kPGPValidity_Marginal:
		return 1;
	case kPGPValidity_Complete:
		return 2;
	}

	return 0;
}

PGPUInt32 
CPublicKeysView::ConvertFromPGPTrust(PGPUInt32 uPGPTrust) const
{
	switch (uPGPTrust & kPGPKeyTrust_Mask)
	{
	case kPGPKeyTrust_Undefined:
	case kPGPKeyTrust_Unknown:
	case kPGPKeyTrust_Never:
		return 0;
	case kPGPKeyTrust_Marginal:
		return 1;
	case kPGPKeyTrust_Complete:
		return 2;
	case kPGPKeyTrust_Ultimate:
		return 3;
	}

	return 0;
}

void 
CPublicKeysView::GetUnknownUserIDString(
	const CPGPKeyID&	keyID, 
	CString&			userID) const
{
	CString	keyIDStr;
	keyID.GetKeyIDString(kPGPKeyIDString_Abbreviated, keyIDStr);

	userID.Format(UCommonStrings::Get(
		UCommonStrings::kUnknownUserString), keyIDStr.Get());
}

int 
CPublicKeysView::PubKeyViewCompareProcAux(
	const PubKeyItem	*pKey1, 
	const PubKeyItem	*pKey2)
{
	pgpAssertAddrValid(pKey1, PubKeyItem);
	pgpAssertAddrValid(pKey2, PubKeyItem);

	if (mLastSortColumn == mUserIDColIndex)
	{
		if (mSortAscending)
			return PGPCompareUserIDStrings(pKey1->userID, pKey2->userID);
		else
			return PGPCompareUserIDStrings(pKey2->userID, pKey1->userID);
	}
	else if (mLastSortColumn == mValidityColIndex)
	{
		if (mSortAscending)
			return pKey2->validity - pKey1->validity;
		else
			return pKey1->validity - pKey2->validity;
	}
	else if (mLastSortColumn == mSizeColIndex)
	{
		if (mSortAscending)
			return (atoi(pKey2->sizeStr) - atoi(pKey1->sizeStr));
		else
			return (atoi(pKey1->sizeStr) - atoi(pKey2->sizeStr));
	}

	return 0;
}

int 
CALLBACK 
CPublicKeysView::PubKeyViewCompareProc(
	LPARAM	lParam1, 
	LPARAM	lParam2, 
	LPARAM	lParamSort)
{
	CPublicKeysView	*pView	= reinterpret_cast<CPublicKeysView *>(lParamSort);
	pgpAssertAddrValid(pView, CPublicKeysView);

	return pView->PubKeyViewCompareProcAux(
		reinterpret_cast<PubKeyItem *>(lParam1), 
		reinterpret_cast<PubKeyItem *>(lParam2));
}

void 
CPublicKeysView::DrawBar(
	CDC&			itemDC, 
	const CRect&	ptrBarRect, 
	PGPInt32		dataValue, 
	PGPInt32		maxValue, 
	PGPBoolean		isSelected) const
{
	CPen	oldPen;
	CRect	rect(ptrBarRect);

	if (isSelected)
	{
		itemDC.FillRect(rect, mPDE->highBrush);
		oldPen = itemDC.SelectObject(mPDE->gUnselTextPen.Get());
	}
	else
	{
		itemDC.FillRect(rect, mPDE->backBrush);
		oldPen = itemDC.SelectObject(mPDE->gSelTextPen.Get());
	}

	rect.Top()		+= 5;
	rect.Left()		+= 5;
	rect.Bottom()	-= 5;
	rect.Right()	-= 5;

	if (rect.Right() <= rect.Left())
		return;

	CBrush	oldBrush(itemDC.SelectObject(mPDE->barBGBrush.Get()));
	itemDC.SelectObject(mPDE->buttonPen.Get());

	itemDC.Rectangle(rect.Left() - 1, rect.Top() - 1, rect.Right() + 2, 
		rect.Bottom() + 2);

	itemDC.SelectObject(mPDE->shadowPen.Get());
	itemDC.MoveToEx(rect.Left(), rect.Bottom(), NULL);
	itemDC.LineTo(rect.Left(), rect.Top());
	itemDC.LineTo(rect.Right(), rect.Top());

	itemDC.SelectObject(mPDE->hilightPen.Get());
	itemDC.LineTo(rect.Right(), rect.Bottom());
	itemDC.LineTo(rect.Left(), rect.Bottom());

	CBrush	barBrush;

	if (maxValue != 0)
	{
		if (dataValue > maxValue)
		{
			barBrush.Attach(mPDE->spcBarBrush);
		}
		else
		{
			barBrush.Attach(mPDE->stdBarBrush);

			rect.Right() = rect.Left() + static_cast<PGPInt32>(
				(static_cast<float>(dataValue) / maxValue) * rect.Width());
		}
	}
	else
	{
		rect.Left() = rect.Right();
	}

	rect.Top()++;
	rect.Left()++;

	if (rect.Right() > rect.Left())
	{
		COLORREF	oldBkColor	= itemDC.SetBkColor(mPDE->barColor);
		itemDC.FillRect(rect, barBrush);

		rect.Top()--;
		rect.Left()--;

		// Highlight pen already selected.
		itemDC.MoveToEx(rect.Right(), rect.Top(), NULL);
		itemDC.LineTo(rect.Left(), rect.Top());
		itemDC.LineTo(rect.Left(), rect.Bottom());

		itemDC.SelectObject(mPDE->shadowPen.Get());
		itemDC.LineTo(rect.Right(), rect.Bottom());
		itemDC.LineTo(rect.Right(), rect.Top());

		itemDC.SetBkColor(oldBkColor);
	}

	itemDC.SelectObject(oldBrush.Get());
	itemDC.SelectObject(oldPen.Get());
}

void 
CPublicKeysView::DrawNoviceButton(
	CDC&			itemDC, 
	const CRect&	ptrBarRect, 
	PGPInt32		dataValue, 
	PGPInt32		maxValue, 
	PGPBoolean		isSelected) const
{
	if (isSelected)
		itemDC.FillRect(ptrBarRect, mPDE->highBrush);
	else
		itemDC.FillRect(ptrBarRect, mPDE->backBrush);

	if (ptrBarRect.Width() >= CIcon::kSmallIconWidth)
	{
		PGPUInt32	noviceIcon	= ImageIDs::kInvalid;

		if (dataValue > 2)
			noviceIcon = ImageIDs::kAxiomatic;

		if (dataValue == 2)
			noviceIcon = ImageIDs::kValid;

		if (!mMarginalInvalid && (dataValue == 1))
			noviceIcon = ImageIDs::kValid;

		mPDE->image.Draw(noviceIcon, itemDC, 
			ptrBarRect.Left() + 
			(ptrBarRect.Width() - CIcon::kSmallIconWidth)/2, 
			ptrBarRect.Top() + 
			(ptrBarRect.Height() - CIcon::kSmallIconWidth)/2, 
			ILD_TRANSPARENT);
	}
}

void 
CPublicKeysView::DrawTrueFalseButton(
	CDC&			itemDC, 
	const CRect&	ptrBarRect, 
	PGPBoolean		trueFalse, 
	PGPBoolean		isSelected) const
{
	if (isSelected)
		itemDC.FillRect(ptrBarRect, mPDE->highBrush);
	else
		itemDC.FillRect(ptrBarRect, mPDE->backBrush);

	if (ptrBarRect.Width() >= CIcon::kSmallIconWidth)
	{
		PGPUInt32	noviceIcon;

		if (trueFalse)
			noviceIcon = ImageIDs::kValid;
		else
			noviceIcon = ImageIDs::kInvalid;

		mPDE->image.Draw(noviceIcon, itemDC, 
			ptrBarRect.Left() + 
				(ptrBarRect.Width() - CIcon::kSmallIconWidth)/2, 
			ptrBarRect.Top() + 
				(ptrBarRect.Height() - CIcon::kSmallIconWidth)/2, 
			ILD_TRANSPARENT);
	}
}



//	_______________________________________________
//
//  Truncate text string

static BOOL sTruncateText (
		HDC		hdc, 
		WCHAR*	wsz, 
		int		xmax) 
{
	BOOL bShowToolTip	= FALSE;
	SIZE s;
	int l, w;

	// truncate at <newline>, if present
	l = 0;
	while (wsz[l])
	{
		if (wsz[l] == '\n')
		{
			wsz[l] = 0;
			bShowToolTip = TRUE;
			break;
		}
		l++;
	}

	GetTextExtentPoint32W (hdc, wsz, lstrlenW (wsz), &s);
	w = s.cx + 4;

	l = lstrlenW (wsz);
	if (l < 3)