cdiskusersview.cpp

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

			CRect	tempRect(itemRect);
			tempRect.Left() = tempRect.Right() - CIcon::kSmallIconWidth;

			// Enough space. Draw Lock.
			if (tempRect.Left() > itemRect.Left())
			{
				if ((pDIS->itemState & ODS_SELECTED) && isFocused)
					itemDC.FillRect(tempRect, mPDE->highBrush);
				else
					itemDC.FillRect(tempRect, mPDE->backBrush);
			}

			mPDE->image.Draw(ImageIDs::kClosedLock, itemDC, tempRect.Left(), 
				tempRect.Top(), ILD_TRANSPARENT);

			// Make space for lock from text.
			itemRect.Right() -= CIcon::kSmallIconWidth;
		}

		DrawItemColumn(itemDC, pItem->userName, itemRect);

		// Set rectangle back to original
		itemRect = origRect;
		itemDC.SelectObject(oldFont.Get());

		itemRect.Left() = itemRect.Right();
	}

	if (mActiveColumns & kReadOnlyColFlag)
	{
		itemRect.Right() += GetColumnWidth(mReadOnlyColIndex);

		DrawTrueFalseButton(itemDC, itemRect, pItem->user.IsReadOnly(), 
			((pDIS->itemState & ODS_SELECTED) && isFocused));

		itemRect.Left() = itemRect.Right();
	}

	if (mActiveColumns & kKindColFlag)
	{
		itemRect.Right() += GetColumnWidth(mKindColIndex);

		CFont	oldFont(itemDC.SelectObject(mPDE->hFont.Get()));
			DrawItemColumn(itemDC, pItem->kindText, itemRect);

		itemDC.SelectObject(oldFont.Get());
		itemRect.Left() = itemRect.Right();
	}
}

void 
CDiskUsersView::DrawUserItem(LPDRAWITEMSTRUCT pDIS) const
{
	PGPBoolean	isFocused	= TRUE;

	if (GetFocus() != Handle())
		isFocused = FALSE;

	CDC			dc(pDIS->hDC);
	PGPUInt32	uiFlags	= ILD_TRANSPARENT;

	// Check to see if this item is selected
	if ((pDIS->itemState & ODS_SELECTED) && isFocused)
	{
		// Set the text background and foreground colors
		dc.SetTextColor(GetSysColor(COLOR_HIGHLIGHTTEXT));
		dc.SetBkColor(GetSysColor(COLOR_HIGHLIGHT));

		// Also add the ILD_BLEND50 so the images come out selected
		uiFlags |= ILD_BLEND50;
	}
	else
	{
		// Set the text background and foreground colors to the 
		// standard window colors

		dc.SetTextColor(GetSysColor(COLOR_WINDOWTEXT));
		dc.SetBkColor(GetSysColor(COLOR_WINDOW));
	}

	DrawUserItemAux(pDIS, isFocused);

	pDIS->rcItem.left += CIcon::kSmallIconWidth;

	if (!isFocused)
		return;

	// If we changed the colors for the selected item, undo it
	if (pDIS->itemState & ODS_SELECTED)
	{
		// Set the text background and foreground colors
		dc.SetTextColor(GetSysColor(COLOR_WINDOWTEXT));
		dc.SetBkColor(GetSysColor(COLOR_WINDOW));
	}

	// If the item is focused, now draw a focus rect around the entire row
//	if (pDIS->itemState & ODS_FOCUS)
//		dc.DrawFocusRect(pDIS->rcItem);
}

CDiskUsersView::DiskUserItem * 
CDiskUsersView::GetItemAtIndex(PGPInt32 i) const
{
	LVITEM	lvi;

	lvi.mask		= LVIF_PARAM;
	lvi.iItem		= i;							 
	lvi.iSubItem	= 0;

	GetItem(&lvi);
	return reinterpret_cast<DiskUserItem *>(lvi.lParam);
}

PGPdiskUserRef 
CDiskUsersView::GetUserAtIndex(PGPInt32 i) const
{
	return GetItemAtIndex(i)->user;
}

PGPInt32 
CDiskUsersView::GetIndexOfItem(const DiskUserItem *pItem) const
{
	LVFINDINFO	lvfi;
	pgpClearMemory(&lvfi, sizeof(lvfi));

	lvfi.flags	= LVFI_PARAM;
	lvfi.lParam	= reinterpret_cast<LPARAM>(pItem);

	return FindItem(-1, &lvfi);
}

PGPInt32 
CDiskUsersView::GetIndexOfEqualUser(const CPGPdiskUser& diskUser) const
{
	PGPUInt32	itemCount	= GetItemCount();

	for (PGPUInt32 i = 0; i < itemCount; i++)
	{
		CPGPdiskUser	curUser(GetUserAtIndex(i));

		if (diskUser.IsEqualUser(curUser))
			return i;
	}

	return -1;
}

void 
CDiskUsersView::CalcItemDisplayData(
	DiskUserItem	*pItem, 
	PGPBoolean	redraw) const
{
	using namespace UCommonStrings;
	pgpAssertAddrValid(pItem, DiskUserItem);

	pItem->user.GetUserName(pItem->userName);
	pItem->isPubAndNotInRing = FALSE;

	if (pItem->user.HasPublicKey())
	{
		pItem->icon = ImageIDs::kDiskPubKeyUser;

		// Make note if the associated public key is not in keyring.
		CPGPKeyID	keyID;
		pItem->user.GetPGPKeyID(keyID);

		PGPPublicKeyAlgorithm	algorithm	= keyID.Algorithm();

		try
		{
			CPGPdiskContext	context(pItem->user.Context());
			CPGPKey	pgpKey(context.PGPKeyDB(), keyID);
		}
		catch (CComboError&)
		{
			pItem->isPubAndNotInRing = TRUE;
		}

		if (algorithm == kPGPPublicKeyAlgorithm_RSA)
			pItem->kindText = Get(kDiskUserViewPubKeyRSAText);
		else
			pItem->kindText = Get(kDiskUserViewPubKeyDHText);
	}
	else
	{
		pItem->icon = ImageIDs::kDiskPassphraseUser;
		pItem->kindText = Get(kDiskUserViewSymKeyText);
	}

	if (pItem->isPubAndNotInRing)
		pItem->icon = ImageIDs::kInvalidUserId;

	if (redraw)
	{
		PGPInt32	index	= GetIndexOfItem(pItem);
		RedrawItems(index, index);
	}
}

void 
CDiskUsersView::AddUser(const CPGPdiskUser& diskUser)
{
	pgpAssert(GetIndexOfEqualUser(diskUser) == -1);

	// Add key to disk user set.
	mPDiskUsers->Add(diskUser);

	// Find key ref of new user in disk key set.
	CPGPdiskUserIter	diskUserIter(*mPDiskUsers);

	CPGPdiskUser	equalUser;
	diskUserIter.FindEqualUser(diskUser, equalUser);

	// Create display item using that key ref.
	auto_ptr<DiskUserItem>	pItem(new DiskUserItem);

	pItem->user.Attach(equalUser);
	CalcItemDisplayData(pItem.get());

	// Add the list item.
	LV_ITEM  lvItem;
	pgpClearMemory(&lvItem, sizeof(lvItem));

	lvItem.mask 	= LVIF_PARAM | LVIF_IMAGE | LVIF_TEXT;
	lvItem.lParam	= reinterpret_cast<LPARAM>(pItem.get());
	lvItem.iImage	= 0;
	lvItem.pszText	= const_cast<char *>(pItem->userName.Get());
	lvItem.iSubItem	= 0;
	lvItem.iItem	= GetItemCount();

	InsertItem(&lvItem);
	mItemList.AddTail(pItem.release());
}

void 
CDiskUsersView::RemoveUser(const CPGPdiskUser& diskUser)
{
	PGPInt32	index	= GetIndexOfEqualUser(diskUser);
	pgpAssert(index != -1);

	DiskUserItem	*pItem	= GetItemAtIndex(index);
	mPDiskUsers->Remove(pItem->user);

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

void 
CDiskUsersView::UpdateUser(const CPGPdiskUser& updatedUser, PGPBoolean redraw)
{
	PGPInt32	index	= GetIndexOfEqualUser(updatedUser);
	pgpAssert(index != -1);

	DiskUserItem	*pItem	= GetItemAtIndex(index);

	mPDiskUsers->Remove(updatedUser);
	mPDiskUsers->Add(updatedUser);

	CPGPdiskUserIter	diskUsersIter(*mPDiskUsers);

	CPGPdiskUser	EqualUser;
	diskUsersIter.FindEqualUser(updatedUser, EqualUser);

	pItem->user.Attach(EqualUser);
	CalcItemDisplayData(pItem, redraw);
}

void 
CDiskUsersView::CreateDrawElements()
{
	pgpAssert(IsNull(mPDE));

	auto_ptr<DKViewDrawElements>	pDE(new DKViewDrawElements);

	pDE->stdBarBrush.CreateSolid(GetSysColor(COLOR_3DSHADOW));
	pDE->spcBarBrush.CreateHatch(HS_BDIAGONAL, 
		GetSysColor(COLOR_WINDOW));
	pDE->gSelTextPen.Create(PS_SOLID, 0, GetSysColor(COLOR_WINDOWTEXT));
	pDE->gUnselTextPen.Create(PS_SOLID, 0, GetSysColor(COLOR_WINDOW));

	pDE->barColor = GetSysColor(COLOR_3DSHADOW);

	pDE->buttonPen.Create(PS_SOLID, 0, GetSysColor(COLOR_3DSHADOW));
	pDE->hilightPen.Create(PS_SOLID, 0, GetSysColor(COLOR_3DHILIGHT));
	pDE->barBGBrush.CreateSolid(GetSysColor(COLOR_3DFACE));
	pDE->highBrush.CreateSolid(GetSysColor(COLOR_HIGHLIGHT));
	pDE->backBrush.CreateSolid(GetSysColor(COLOR_WINDOW));

	LOGFONT lf;
	SystemParametersInfo(SPI_GETICONTITLELOGFONT, sizeof(LOGFONT), &lf, 0);

	pDE->hFont.CreateIndirect(lf);

	lf.lfWeight = 700;
	pDE->hBold.CreateIndirect(lf);

	lf.lfStrikeOut = TRUE;
	pDE->hBoldStrikeOut.CreateIndirect(lf);

	lf.lfWeight = 400;
	lf.lfItalic = !lf.lfItalic;
	lf.lfStrikeOut = FALSE;
	pDE->hItalic.CreateIndirect(lf);

	lf.lfStrikeOut = TRUE;
	pDE->hItalicStrikeOut.CreateIndirect(lf);

	lf.lfItalic = !lf.lfItalic;
	pDE->hStrikeOut.CreateIndirect(lf);

	// Initialize image list.
	CDC	dc;
	dc.AttachFromWindow(NULL, TRUE);	// DC for desktop

	PGPUInt32	numBits	= dc.GetDeviceCaps(BITSPIXEL) * 
		dc.GetDeviceCaps(PLANES);

	if (numBits <= 8)
	{
		pDE->image.Create(CIcon::kSmallIconWidth, CIcon::kSmallIconHeight, 
			ILC_COLOR | ILC_MASK, ImageIDs::kNumPubKeyBitmaps, 0);

		CBitmap	images(UModuleInstance::Get(), 
			MAKEINTRESOURCE(IDB_PKIMAGES4BIT));
		pDE->image.AddMasked(images, ImageIDs::kMaskColor);
	}
	else
	{
		pDE->image.Create(CIcon::kSmallIconWidth, CIcon::kSmallIconHeight, 
			ILC_COLOR24 | ILC_MASK, ImageIDs::kNumPubKeyBitmaps, 0);

		CBitmap	images(UModuleInstance::Get(), 
			MAKEINTRESOURCE(IDB_PKIMAGES24BIT));
		pDE->image.AddMasked(images, ImageIDs::kMaskColor);
	}

	mPDE = pDE.release();
}

void 
CDiskUsersView::DeleteDrawElements()
{
	pgpAssert(IsntNull(mPDE));

    delete mPDE;
	mPDE = NULL;
}

void 
CDiskUsersView::UpdateColumns()
{
	using namespace UCommonStrings;

	DeleteColumn(mKindColIndex);
	DeleteColumn(mReadOnlyColIndex);
	DeleteColumn(mUserNameColIndex);

	CRect	listRect;
	GetClientRect(listRect);

	LV_COLUMN	lvCol;
	pgpClearMemory(&lvCol, sizeof(lvCol));

	lvCol.mask	= LVCF_WIDTH | LVCF_FMT | LVCF_SUBITEM | LVCF_TEXT;

	PGPUInt32	i			= 0;
	PGPInt32	listWidth	= listRect.Width();

	if (mActiveColumns & kUserNameColFlag)
	{
		lvCol.fmt		= LVCFMT_LEFT;
		lvCol.pszText	= const_cast<char *>(Get(kDiskUserViewUserNameCol));
		lvCol.cx		= static_cast<PGPInt32>(kUserNameColRatio*listWidth);

		mUserNameColIndex = InsertColumn(i++, &lvCol);
	}

	if (mActiveColumns & kReadOnlyColFlag)
	{
		lvCol.fmt		= LVCFMT_CENTER;
		lvCol.pszText	= const_cast<char *>(Get(kDiskUserViewReadOnlyCol));
		lvCol.cx		= static_cast<PGPInt32>(kReadOnlyColRatio*listWidth);

		mReadOnlyColIndex = InsertColumn(i++, &lvCol);
	}

	if (mActiveColumns & kKindColFlag)
	{
		lvCol.fmt		= LVCFMT_LEFT;
		lvCol.pszText	= const_cast<char *>(Get(kDiskUserViewKindCol));
		lvCol.cx		= static_cast<PGPInt32>(kKindColRatio*listWidth);

		mKindColIndex = InsertColumn(i++, &lvCol);
	}
}

void 
CDiskUsersView::GenerateMeasureItem() const
{
	// Fool the system into sending us a new WM_MEASUREITEM.
	CRect	rect;
	GetWindowRect(rect);

	WINDOWPOS	wp;

	wp.hwnd		= Handle();
	wp.cx		= rect.Width();
	wp.cy		= rect.Height();
	wp.flags	= SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOOWNERZORDER | 
		SWP_NOZORDER;

	SendMessage(WM_WINDOWPOSCHANGED, 0, reinterpret_cast<LPARAM>(&wp));
}

void 
CDiskUsersView::OnContextMenu(HWND menuWnd, CPoint coords)
{
	CWindow(GetParent()).SendMessage(CurMsg().Message(), CurMsg().WParam(), 
		CurMsg().LParam());
}

BOOL 
CDiskUsersView::OnDrawItem(PGPUInt16 ctrlId, LPDRAWITEMSTRUCT pDIS)
{
	if (!IsWindowEnabled())
		return FALSE;

	switch (pDIS->itemAction)
	{
		case ODA_DRAWENTIRE:
		case ODA_FOCUS:
		case ODA_SELECT:
			DrawUserItem(pDIS);
			break;
	}

	return TRUE;
}

void 
CDiskUsersView::OnKeyDown(PGPUInt32 vKey, PGPUInt32 keyData)
{
	switch (vKey)
	{
	case 'a':
	case 'A':
		// Select all items on ctrl-A.
		if (!mSingleSelect && (GetAsyncKeyState(VK_CONTROL) & 1))
			SelectAllItems();
		else
			CListView::OnKeyDown(vKey, keyData);
		break;

	default:
		CListView::OnKeyDown(vKey, keyData);
		break;
	}
}

BOOL 
CDiskUsersView::OnMeasureItem(PGPUInt16 ctrlId, LPMEASUREITEMSTRUCT pMIS)
{
    if (pMIS->CtlType != ODT_LISTVIEW)
		return FALSE;

	CDC		listDC;
	CFont	font(GetFont());

	listDC.AttachFromWindow(Handle());
	HFONT	oldFont	= listDC.SelectObject(font.Get());

	TEXTMETRIC	tm;

	if (!listDC.GetTextMetrics(&tm))
		return TRUE;
		
    // Add a little extra space between items.
	pMIS->itemHeight = tm.tmHeight + 1;

	if (pMIS->itemHeight < (CIcon::kSmallIconHeight + 1))
		pMIS->itemHeight = CIcon::kSmallIconHeight + 1;

	listDC.SelectObject(oldFont);
	listDC.Clear();

	return TRUE;
}

void 
CDiskUsersView::OnMenuSelect(
	PGPUInt16	ctrlId, 
	PGPUInt16	flags, 
	HMENU		hwndMenu)
{
	CListView::OnMenuSelect(ctrlId, flags, hwndMenu);

	// Let parent see it too.
	CWindow(GetParent()).SendMessage(WM_MENUSELECT, CurMsg().WParam(), 
		CurMsg().LParam());
}

PGPUInt32 
CDiskUsersView::OnNotify(PGPUInt16 ctrlId, LPNMHDR pNMHDR)
{
	if (pNMHDR->hwndFrom == Handle())
	{
		NMLISTVIEW	*pNMLV	= reinterpret_cast<NMLISTVIEW *>(pNMHDR);

		if (pNMHDR->code == LVN_COLUMNCLICK)
			SortOnColumn(pNMLV->iSubItem);

		return 0;
	}
	else
	{
		return CListView::OnNotify(ctrlId, pNMHDR);
	}
}

void 
CDiskUsersView::OnNcDestroy()
{
	CListView::OnNcDestroy();
	Clear();
}

void 
CDiskUsersView::OnSysColorChange()
{
	CListView::OnSysColorChange();

	DeleteDrawElements();
	CreateDrawElements();
}