tlmouse.c

可以实现对邮件的加密解密以及签名

		pWD->nmTreeList.ptDrag = mpt;
		SendMessage (pWD->hWndParent,
				WM_NOTIFY, pWD->id, (LPARAM)&(pWD->nmTreeList));
	}
}


//	_______________________________________________
//
//  Handle left mouse button double click event

void 
TLLeftButtonDblClk (
		TLWndData*	pWD, 
		WPARAM		wParam,
		LPARAM		lParam) 
{
	int iHitType;
	TLTreeItem* pHit;
	POINT mpt;
	BOOL bControl;

	mpt.x = LOWORD (lParam);
	mpt.y = HIWORD (lParam);

	if (wParam & MK_CONTROL) 
		bControl = TRUE;
	else 
		bControl = FALSE;

	pHit = sPointSearch (pWD->rootItem, mpt, &iHitType);

	switch (iHitType) {
	case TLK_NONE :
		break;

	case TLK_BUTTON :
		if (pHit->state & TLIS_EXPANDED)
			pHit->state &= ~TLIS_EXPANDED;
		else 
		{
			pHit->state |= TLIS_EXPANDED;
			if (bControl)
				TLExpandTree (pHit->childItem);
			TLExpandAutoScroll (pWD, pHit);
		}
		InvalidateRect (pWD->hWnd, &pWD->tlInval, TRUE);
		break;

	case TLK_ACTIVE :
		break;

	case TLK_SELECT :
		if (pHit->childItem) 
		{
			if (pHit->state & TLIS_EXPANDED) 
				pHit->state &= ~TLIS_EXPANDED;
			else 
			{
				pHit->state |= TLIS_EXPANDED;
				if (bControl)
					TLExpandTree (pHit->childItem);
				TLExpandAutoScroll (pWD, pHit);
			}
			InvalidateRect (pWD->hWnd, &pWD->tlInval, TRUE);
		}
		else
		{
			pWD->nmTreeList.itemOld.hItem = NULL;
			pWD->nmTreeList.itemNew.hItem = (HTLITEM)pHit;
			pWD->nmTreeList.itemNew.state = pHit->state;
			pWD->nmTreeList.flags = TLC_BYMOUSE;
			pWD->nmTreeList.hdr.code = TLN_ITEMDBLCLICKED;
			pWD->nmTreeList.ptDrag = mpt;
			SendMessage (pWD->hWndParent, 
					WM_NOTIFY, pWD->id, (LPARAM)&(pWD->nmTreeList));
		}
		break;
	}
}


//	_______________________________________________
//
//  Handle right mouse button down event

void 
TLRightButtonDown (
		TLWndData*	pWD,
		WPARAM		wParam, 
		LPARAM		lParam) 
{
	int iHitType;
	TLTreeItem* pHit;
	POINT mpt;

	if (wParam & MK_CONTROL) 
		return;
	if (GetKeyState (VK_SHIFT) & 0x8000)
		return;

	mpt.x = LOWORD (lParam);
	mpt.y = HIWORD (lParam);

	pWD->nmTreeList.flags = 0;
	pWD->nmTreeList.itemNew.hItem = NULL;
	pWD->nmTreeList.itemOld.hItem = NULL;

	pHit = sPointSearch (pWD->rootItem, mpt, &iHitType);

	switch (iHitType) {
	case TLK_NONE :
		TLDeselectTree (pWD, pWD->rootItem, NULL);
		pWD->firstSelectItem = NULL;
		pWD->nmTreeList.flags |= TLC_BYMOUSE;
		if (pWD->focusItem) 
		{
			pHit = pWD->focusItem;
			pWD->focusItem = NULL;
			TLInvalidateItem (pWD, pHit);
		}
		break;

	case TLK_BUTTON :
		break;

	case TLK_SELECT :
		SendMessage (pWD->hWndToolTip, TTM_TRACKACTIVATE, FALSE, 0);
		if (!(pHit->state & TLIS_SELECTED)) 
		{
			TLDeselectTree (pWD, pWD->rootItem, pHit);
			pHit->state |= TLIS_SELECTED;
			pWD->iNumberSelected = 1;
			if (TLSelectAutoScroll (pWD, pHit))
				InvalidateRect (pWD->hWnd, &pWD->tlInval, TRUE);
			pWD->nmTreeList.itemNew.hItem = (HTLITEM)pHit;
			pWD->nmTreeList.itemNew.state = pHit->state;
			pWD->nmTreeList.flags |= TLC_BYMOUSE;
		}

		if (pWD->focusItem) 
		{
			pWD->focusItem->state &= ~TLIS_FOCUSED;
			pWD->nmTreeList.itemOld.hItem = (HTLITEM)pWD->focusItem;
			pWD->nmTreeList.itemOld.state = pWD->focusItem->state;
			TLInvalidateItem (pWD, pWD->focusItem);
		}
		pHit->state |= TLIS_FOCUSED;
		pWD->focusItem = pHit;
		TLInvalidateItem (pWD, pHit);
		break;
	}

	if (pWD->nmTreeList.flags) 
	{
		if (pWD->iNumberSelected > 1)
			pWD->nmTreeList.flags |= TLC_MULTIPLE;

		pWD->nmTreeList.hdr.code = TLN_SELCHANGED;
		pWD->nmTreeList.ptDrag = mpt;
		SendMessage (pWD->hWndParent, 
				WM_NOTIFY, pWD->id, (LPARAM)&(pWD->nmTreeList));
	}
}


//	_______________________________________________
//
//  Handle column resizing

static void 
sColumnResize (
		TLWndData*	pWD, 
		HD_NOTIFY*	hdn) 
{
	TLColumnItem* pci;
	int i, scx, left;
	HD_ITEM hdi;
	RECT rcInval;

	if (hdn->iButton == 0) 
	{
		rcInval = pWD->tlInval;
		left = pWD->iFirstColumnWidth;
		if (hdn->iItem == 0) 
		{
			scx = hdn->pitem->cxy - pWD->iFirstColumnWidth;
			pWD->iFirstColumnWidth = hdn->pitem->cxy;
			rcInval.right = pWD->iFirstColumnWidth + scx +1;

			if (scx < 0) 
				rcInval.left = rcInval.right - 24;
			else 
				rcInval.left = pWD->iFirstColumnWidth - 24;
		}
		else 
		{
			pci = pWD->columnItem;
			left += pci->cx;
			rcInval.left = pWD->iFirstColumnWidth;
			for (i=1; i<hdn->iItem; i++) 
			{
				rcInval.left += pci->cx;
				pci = pci->nextItem;
				left += pci->cx;
			}
			scx = hdn->pitem->cxy - pci->cx;
			pci->cx = hdn->pitem->cxy;

			if (pci->cx >= BITMAPWIDTH)
				pci->cxImageOffset = (pci->cx - BITMAPWIDTH) / 2;
			else
				pci->cxImageOffset = 0;
			rcInval.right = left + scx +1;
		}

		pci = pWD->columnItem;
		pWD->iTotalWidth = pWD->iFirstColumnWidth;
		for (i=1; i<pWD->iNumberColumns; i++) 
		{
			pWD->iTotalWidth += pci->cx;
			pci = pci->nextItem;
		}

		hdi.mask = HDI_WIDTH;
		hdi.cxy = hdn->pitem->cxy;
		Header_SetItem (pWD->hWndHeader, hdn->iItem, &hdi);
		InvalidateRect (pWD->hWndHeader, NULL, TRUE);

		rcInval.left -= pWD->iHorizontalPos;
		rcInval.right -= pWD->iHorizontalPos;
		InvalidateRect (pWD->hWnd, &pWD->tlInval, FALSE);

		if ((scx < 0) && (pWD->iHorizontalPos > 0))
		{
			i = pWD->iHorizontalPos + scx;
			if (i < 0)
				i = 0;

			SendMessage (pWD->hWnd, WM_HSCROLL,
					MAKEWPARAM (SB_THUMBPOSITION, i), 0);
			InvalidateRect (pWD->hWnd, &pWD->tlInval, TRUE);
		}
	}
}


//	_______________________________________________
//
//  Handle header notifications

BOOL 
TLHeaderNotification (
		TLWndData*	pWD,
		NMHEADER*	pnmh) 
{
	switch (pnmh->hdr.code) {
	case HDN_ENDTRACK :
	case HDN_TRACK :
		if (pnmh->iButton == 0) 
			sColumnResize (pWD, pnmh);
		break;

	case HDN_ITEMCLICK :
		if (pnmh->iButton == 0) 
		{
			pWD->nmTreeList.hdr.code = TLN_HEADERCLICKED;
			pWD->nmTreeList.index = pnmh->iItem;
			SendMessage (pWD->hWndParent, 
					WM_NOTIFY, pWD->id, (LPARAM)&(pWD->nmTreeList));
		}
		break;

	case HDN_BEGINDRAG :
		return FALSE;

	case HDN_ENDDRAG :
		if (pnmh->iItem == 0) 
			return TRUE;
		if (pnmh->pitem->iOrder == 0) 
			return TRUE;

		SetTimer (pWD->hWnd, REORDERTIMERID, REORDERTIMEOUT, NULL);
		return FALSE;

	case HDN_DIVIDERDBLCLICK :
		if (pnmh->iButton == 0) 
		{
			HDITEM	item;

			item.cxy = TLAutoComputeColumnWidth (pWD, pnmh->iItem);

			pnmh->pitem = &item;
			sColumnResize (pWD, pnmh);
		}
		break;
	}

	return FALSE;
}


//	_______________________________________________
//
//  Handle horizontal scrolling

void 
TLHScroll (
		TLWndData*	pWD, 
		int			code, 
		int			pos, 
		HWND		hWndBar) 
{
	int pagesize;
	int newpos;
	int scrollamount;

	pagesize = pWD->tlInval.right - pWD->tlInval.left;
	newpos = pWD->iHorizontalPos;

	switch (code) {
	case SB_TOP :
		newpos = 0;
		break;

	case SB_BOTTOM :
		newpos = (pWD->iTotalWidth-pagesize);
		break;

	case SB_PAGELEFT :
		newpos -= pagesize;
		if (newpos < 0) newpos = 0;
		break;

	case SB_PAGERIGHT :
		newpos += pagesize;
		if (newpos > (pWD->iTotalWidth-pagesize))
			newpos = (pWD->iTotalWidth-pagesize);
		break;

	case SB_LINELEFT :
		newpos-=3;
		if (newpos < 0) 
			newpos = 0;
		break;

	case SB_LINERIGHT :
		newpos+=3;
		if (newpos > (pWD->iTotalWidth-pagesize))
			newpos = (pWD->iTotalWidth-pagesize);
		break;

	case SB_THUMBPOSITION :
	case SB_THUMBTRACK :
		newpos = pos;
		break;

	default :
		return;
	}

	scrollamount = pWD->iHorizontalPos - newpos;
	pWD->iHorizontalPos = newpos;
	if (scrollamount) 
	{
		if (pWD->watermark.hbm)
			InvalidateRect (pWD->hWnd, &(pWD->tlInval), FALSE);

		ScrollWindowEx (pWD->hWnd, scrollamount, 0, NULL, &(pWD->tlRect),
				NULL, NULL, SW_INVALIDATE|SW_SCROLLCHILDREN);

		UpdateWindow (pWD->hWnd);
	}
}


//	_______________________________________________
//
//  Handle window resizing

void 
TLResize (
		TLWndData*	pWD, 
		WINDOWPOS*	pWP) 
{
	int dx, dy;

	dx = pWD->tlRect.right - pWP->cx;
	if ((dx < 0) && (pWD->iHorizontalPos > 0)) 
	{
		dx += pWD->iHorizontalPos;
		if (dx < 0)
			dx = 0;

		SendMessage (pWD->hWnd, 
				WM_HSCROLL, MAKEWPARAM (SB_THUMBPOSITION, dx), 0);
	}
	pWD->tlRect.right = pWP->cx;

	dy = pWD->tlRect.bottom - pWP->cy;
	if ((dy < 0) && (pWD->iFirstRow > 0)) 
	{
		dy += (pWD->iFirstRow * pWD->iRowHeight);
		dy /= pWD->iRowHeight;
		if (dy < 0) 
			dy = 0;

		SendMessage (pWD->hWnd,
				WM_VSCROLL, MAKEWPARAM (SB_THUMBPOSITION, dy), 0);
	}
	pWD->tlRect.bottom = pWP->cy;

	TLDeleteMemDC (pWD);

	pWD->tlInval = pWD->tlRect;
	pWD->tlInval.top += pWD->iRowHeight+1;

	InvalidateRect (pWD->hWnd, &pWD->tlInval, TRUE);
}


//	_______________________________________________
//
//  Handle vertical scrolling

void 
TLVScroll (
		TLWndData*	pWD,
		int			code, 
		int			pos, 
		HWND		hWndBar)
{
	int scrollamount;
	int newrow;

	newrow = pWD->iFirstRow;

	switch (code) {
	case SB_TOP :
		newrow = 0;
		break;

	case SB_BOTTOM :
		newrow = (pWD->iExpandedRows-pWD->iMaxRows);
		break;

	case SB_PAGEUP :
		newrow -= pWD->iMaxRows;
		if (newrow < 0) 
			newrow = 0;
		break;

	case SB_PAGEDOWN :
		newrow += pWD->iMaxRows;
		if (newrow > (pWD->iExpandedRows-pWD->iMaxRows))
			newrow = (pWD->iExpandedRows-pWD->iMaxRows) +1;
		break;

	case SB_LINEUP :
		newrow--;
		if (newrow < 0)
			newrow = 0;
		break;

	case SB_LINEDOWN :
		newrow++;
		if (newrow > (pWD->iExpandedRows-pWD->iMaxRows))
			newrow = (pWD->iExpandedRows-pWD->iMaxRows) +1;
		break;

	case SB_THUMBPOSITION :
	case SB_THUMBTRACK :
		newrow = pos;
		break;

	default :
		return;
	}

	scrollamount = pWD->iFirstRow - newrow;
	pWD->iFirstRow = newrow;

	if (scrollamount) 
		InvalidateRect (pWD->hWnd, &pWD->tlInval, TRUE);
}


//	_______________________________________________
//
//  Handle "Intellimouse" wheel scrolling

void 
TLMouseWheel (
		TLWndData*	pWD, 
		int			iKeys, 
		short int	iDelta) 
{
	int scrollamount;
	int newrow;

	newrow = pWD->iFirstRow;

	// if buttons or keyboard keys are pressed, don't do anything
	if (iKeys != 0) 
		return;

	// sum incoming movements of wheel
	pWD->iWheelDelta += iDelta;

	// positive value => wheel rotated away from user => scroll up
	if (pWD->iWheelDelta >= WHEELTHRESHOLD) 
	{
		if ((pWD->iWheelScroll == WHEEL_PAGESCROLL) ||
			(pWD->iWheelScroll > pWD->iMaxRows))
		{
			newrow -= pWD->iMaxRows;
		}
		else
			newrow -= pWD->iWheelScroll;

		pWD->iWheelDelta = 0;
		if (newrow < 0)
			newrow = 0;
	}

	// negative value => wheel rotated toward user => scroll down
	else if (pWD->iWheelDelta <= (-1 * WHEELTHRESHOLD)) 
	{
		if ((pWD->iWheelScroll == WHEEL_PAGESCROLL) ||
			(pWD->iWheelScroll > pWD->iMaxRows))
		{
			newrow += pWD->iMaxRows;
		}
		else
			newrow += pWD->iWheelScroll;

		pWD->iWheelDelta = 0;
		if (newrow > (pWD->iExpandedRows-pWD->iMaxRows))
			newrow = (pWD->iExpandedRows-pWD->iMaxRows) +1;
	}

	// not reached threshold => no movement
	else 
		return;

	scrollamount = pWD->iFirstRow - newrow;
	pWD->iFirstRow = newrow;

	if (scrollamount) 
		InvalidateRect (pWD->hWnd, &pWD->tlInval, TRUE);
}