📄 tltree.c

📁 PGP8.0源码请认真阅读您的文件包然后写出其具体功能
💻 C
📖 第 1 页 / 共 2 页
字号:
上一页 12
		}
		p = p->nextItem;
	}
	return bDeselected;
}


//	_______________________________________________
//
//  Expand Tree

void 
TLExpandTree (
		TLTreeItem*	p) 
{
	while (p) 
	{
		if (p->childItem) 
		{
			p->state |= TLIS_EXPANDED;
			TLExpandTree (p->childItem);
		}

		p = p->nextItem;
	}
}


//	_______________________________________________
//
//  Expand entire Tree

static void 
sExpandTree (
		TLTreeItem*	p) 
{
	while (p) 
	{
		if (p->childItem)
			sExpandTree (p->childItem);

		p->state |= TLIS_EXPANDED;
		p = p->nextItem;
	}
}


//	_______________________________________________
//
//  Expand/Collapse Tree item

BOOL 
TLExpandTreeItem (
		TLWndData*		pWD, 
		TL_TREEITEM*	lpti, 
		int				flags) 
{
	TLTreeItem* p;

	switch (flags) {
	case TLE_COLLAPSE :
		p = (TLTreeItem*) lpti->hItem;
		if (!p) 
			return FALSE;

		if (p->state & TLIS_EXPANDED)
		{
			p->state &= ~TLIS_EXPANDED;
			TLDeselectTree (pWD, p->childItem, NULL);
			TLSelectAutoScroll (pWD, p);
			return TRUE;
		}
		else 
			return FALSE;

	case TLE_EXPAND :
		p = (TLTreeItem*) lpti->hItem;
		if (!p) 
			return FALSE;

		if (p->state & TLIS_EXPANDED)
			return FALSE;
		else 
		{
			p->state |= TLIS_EXPANDED;
			TLExpandAutoScroll (pWD, p);
			return TRUE;
		}
		break;

	case TLE_TOGGLE :
		p = (TLTreeItem*) lpti->hItem;
		if (!p) 
			return FALSE;

		if (p->state & TLIS_EXPANDED) 
		{
			p->state &= ~TLIS_EXPANDED;
			TLDeselectTree (pWD, p->childItem, NULL);
			TLSelectAutoScroll (pWD, p);
			return TRUE;
		}
		else
			p->state |= TLIS_EXPANDED;
		return TRUE;

	case TLE_COLLAPSEALL :
		p = NULL;
		if (lpti) 
			p = (TLTreeItem*) lpti->hItem;

		if (p) 
		{
			p->state &= ~TLIS_EXPANDED;
			TLDeselectTree (pWD, p->childItem, NULL);
			TLSelectAutoScroll (pWD, p);
		}
		else
		{
			p = pWD->rootItem;
			while (p)
			{
				p->state &= ~TLIS_EXPANDED;
				TLDeselectTree (pWD, p->childItem, NULL);
				p = p->nextItem;
			}
			TLSelectAutoScroll (pWD, pWD->rootItem);
		}
		return TRUE;

	case TLE_EXPANDALL :
		p = NULL;
		if (lpti) 
			p = (TLTreeItem*) lpti->hItem;

		if (p) 
		{
			p->state |= TLIS_EXPANDED;
			TLExpandTree (p->childItem);
			TLExpandAutoScroll (pWD, p);
		}
		else 
		{
			TLExpandTree (pWD->rootItem);
			TLExpandAutoScroll (pWD, pWD->rootItem);
		}
		return TRUE;
	}

	return FALSE;
}


//	_______________________________________________
//
//  Select Tree item

BOOL 
TLSelectTreeItem (
		TLWndData*		pWD, 
		TL_TREEITEM*	lpti,
		BOOL			bDeselect)
 {
	TLTreeItem* p;

	if (pWD->focusItem) 
		pWD->focusItem->state &= ~TLIS_FOCUSED;

	if (bDeselect) 
	{
		TLDeselectTree (pWD, pWD->rootItem, NULL);
		pWD->iNumberSelected = 0;
	}

	if (lpti) 
	{
		p = (TLTreeItem*) lpti->hItem;
		if (!p) 
			return FALSE;

		p->state |= TLIS_SELECTED | TLIS_FOCUSED;
		pWD->focusItem = p;
		pWD->firstSelectItem = p;
		(pWD->iNumberSelected)++;

		if (TLSelectAutoScroll (pWD, p))
			InvalidateRect (pWD->hWnd, &pWD->tlInval, TRUE);
		else 
			TLInvalidateItem (pWD, p);

		if (pWD->iNumberSelected > 1)
			pWD->nmTreeList.flags = TLC_MULTIPLE;
		else 
			pWD->nmTreeList.flags = 0;

		pWD->nmTreeList.itemOld.hItem = NULL;
		pWD->nmTreeList.itemNew.hItem = (HTLITEM)p;
		pWD->nmTreeList.itemNew.state = p->state;
		pWD->nmTreeList.hdr.code = TLN_SELCHANGED;
		SendMessage (pWD->hWndParent, 
				WM_NOTIFY, pWD->id, (LPARAM)&(pWD->nmTreeList));
	}
	return TRUE;
}


//	_______________________________________________
//
//  Select all the children of a Tree item

BOOL 
TLSelectChildren (
	TLWndData*		pWD, 
	TL_TREEITEM*	lpti) 
{
	TLTreeItem* p;

	TLDeselectTree (pWD, pWD->rootItem, NULL);
	pWD->iNumberSelected = 0;

	if (lpti == NULL) 
	{
		p = pWD->rootItem;
		pWD->focusItem = p;
	}
	else 
	{
		p = (TLTreeItem*) lpti->hItem;
		if (p) 
			p = p->childItem;
	}

	if (!p) 
		return FALSE;

	while (p) 
	{
		p->state |= TLIS_SELECTED;
		pWD->iNumberSelected++;
		TLInvalidateItem (pWD, p);
		p = p->nextItem;
	}
	return TRUE;
}


//	_______________________________________________
//
//  Delete Tree List linked list

void 
TLDeleteTreeList (
		TLWndData*		pWD, 
		TLTreeItem*		p) 
{
	TLTreeItem* op;
	TLListItem* pli;
	TLListItem* opli;

	while (p) 
	{
		if (pWD->focusItem == p) 
			pWD->focusItem = NULL;
		if (pWD->firstSelectItem == p) 
			pWD->firstSelectItem = NULL;

		if (p->childItem) 
			TLDeleteTreeList (pWD, p->childItem);

		pli = p->listItem;
		while (pli) 
		{
			TLFree (pli->pszText);
			opli = pli;
			pli = pli->nextItem;
			TLFree (opli);
		}

		TLFree (p->pszText);
		op = p;
		p = p->nextItem;
		TLFree (op);
	}
}


//	_______________________________________________
//
//  Delete Column linked list

BOOL 
TLDeleteAllColumns (
		TLWndData*	pWD) 
{
	TLColumnItem* p;
	TLColumnItem* opci;
	INT i;

	for (i=pWD->iNumberColumns-1; i>=0; i--)
		Header_DeleteItem (pWD->hWndHeader, i);

	p = pWD->columnItem;
	while (p) 
	{
		opci = p;
		p = p->nextItem;
		TLFree (opci);
	}

	pWD->columnItem = NULL;
	pWD->iNumberColumns = 0;

	return TRUE;
}


//	_______________________________________________
//
//  Insert column into TreeList

LONG 
TLInsertColumn (
		TLWndData*	pWD, 
		LONG		index, 
		TL_COLUMN*	tlc)
{
	HD_ITEM hditem;
	TLColumnItem* pci;

	memset (&hditem, 0, sizeof(hditem));

	if (index == 0) 
	{
		if (tlc->mask & TLCF_WIDTH) 
			pWD->iFirstColumnWidth = tlc->cx;

		hditem.mask = HDI_FORMAT | HDI_WIDTH | HDI_TEXT;
		hditem.fmt = tlc->fmt;
		hditem.cxy = tlc->cx;
		hditem.pszText = tlc->pszText;
		pWD->iNumberColumns++;
		pWD->iFirstColumnWidth = tlc->cx;
		pWD->iTotalWidth = tlc->cx;

		return (Header_InsertItem (pWD->hWndHeader, index, &hditem));
	}

	pWD->iTotalWidth += tlc->cx;

	pci = pWD->columnItem;
	if (pci) 
	{
		while (pci->nextItem) 
			pci = pci->nextItem;

		pci->nextItem = TLAlloc (sizeof (TLColumnItem));
		pci = pci->nextItem;
	}
	else 
	{
		pWD->columnItem = TLAlloc (sizeof (TLColumnItem));
		pci = pWD->columnItem;
	}
	pci->iSubItem = index;

	if (tlc->mask & TLCF_DATATYPE)
		pci->iDataType = tlc->iDataType;

	if (tlc->mask & TLCF_DATAMAX) 
		pci->lMaxValue = tlc->cchTextMax;

	if (tlc->mask & TLCF_FMT) 
	{
		hditem.mask |= HDI_FORMAT;
		hditem.fmt = tlc->fmt;
		if ((hditem.fmt == TLCFMT_LOGBAR) ||
			(hditem.fmt == TLCFMT_LINBAR) ||
			(hditem.fmt == TLCFMT_IMAGE))
		{
			hditem.fmt = HDF_CENTER;
		}
		else if ((hditem.fmt == TLCFMT_IMAGELIST) ||
			(hditem.fmt == TLCFMT_HIMAGELIST) ||
			(hditem.fmt == TLCFMT_HICON))
		{
			hditem.fmt = HDF_LEFT;
		}
		pci->iDataFmt = tlc->fmt;
	}

	if (tlc->mask & TLCF_WIDTH) 
	{
		hditem.mask |= HDI_WIDTH;
		hditem.cxy = tlc->cx;
		pci->cx = tlc->cx;

		if (pci->cx >= BITMAPWIDTH)
			pci->cxImageOffset = (pci->cx - BITMAPWIDTH) / 2;
		else
			pci->cxImageOffset = 0;
	}

	if (tlc->mask & TLCF_TEXT) 
	{
		hditem.mask |= HDI_TEXT;
		hditem.pszText = tlc->pszText;
	}

	if (tlc->mask & TLCF_SUBITEM)
	{
		hditem.mask |= HDI_LPARAM;
		hditem.lParam = tlc->iSubItem;
	}

	if (tlc->mask & TLCF_MOUSENOTIFY)
		pci->bMouseNotify = tlc->bMouseNotify;

	if (tlc->mask & TLCF_HEADERIMAGE)
	{
		if (tlc->iHeaderImage >= 0)
		{
			hditem.mask |= HDI_IMAGE;
			hditem.fmt |= HDF_IMAGE;
			hditem.iImage = tlc->iHeaderImage;
		}
	}

	pWD->iNumberColumns++;

	return (Header_InsertItem (pWD->hWndHeader, index, &hditem));
}


//	_______________________________________________
//
//  Change column attributes

LONG 
TLSetColumn (
		TLWndData*	pWD, 
		LONG		index, 
		TL_COLUMN*	tlc) 
{
	TLColumnItem* pci;
	HD_ITEM hdi;
	int i;

	if (index < 1) 
		return -1;
	if (index >= pWD->iNumberColumns) 
		return -1;

	memset (&hdi, 0, sizeof(hdi));

	pci = pWD->columnItem;
	for (i=1; i<index; i++)
		if (pci) pci = pci->nextItem;

	pci->iSubItem = index;

	if (tlc->mask & TLCF_DATATYPE)
		pci->iDataType = tlc->iDataType;

	if (tlc->mask & TLCF_FMT)
		pci->iDataFmt = tlc->fmt;

	if (tlc->mask & TLCF_DATAMAX) 
		pci->lMaxValue = tlc->cchTextMax;

	if (tlc->mask & TLCF_WIDTH) 
	{
		pci->cx = tlc->cx;

		if (pci->cx >= BITMAPWIDTH)
			pci->cxImageOffset = (pci->cx - BITMAPWIDTH) / 2;
		else
			pci->cxImageOffset = 0;

		hdi.mask = HDI_WIDTH;
		hdi.cxy = tlc->cx;
		pWD->iTotalWidth += tlc->cx;
	}

	if (tlc->mask & TLCF_HEADERIMAGE)
	{
		if (tlc->iHeaderImage >= 0)
		{
			hdi.mask |= HDI_IMAGE;
			hdi.fmt |= HDF_IMAGE;
			hdi.iImage = tlc->iHeaderImage;
		}
	}

	if (hdi.mask) 
		Header_SetItem (pWD->hWndHeader, index, &hdi);

	InvalidateRect (pWD->hWnd, NULL, TRUE);
	return index;
}


//	_______________________________________________
//
//  Get column width

LONG 
TLGetColumnWidth (
		TLWndData*	pWD, 
		LONG		index)
{

	TLColumnItem* pci;
	int i;

	if (index < 0) 
		return -1;
	if (index >= pWD->iNumberColumns) 
		return -1;

	if (index == 0) 
		return (pWD->iFirstColumnWidth);

	pci = pWD->columnItem;
	for (i=1; i<index; i++)
		if (pci) pci = pci->nextItem;

	return pci->cx;
}


//	_______________________________________________
//
//  Set data in list item

LONG 
TLSetListItem (
		TLWndData*		pWD, 
		TL_LISTITEM*	lpli, 
		BOOL			bInvalidate) 
{
	TLListItem* pli;
	int i;

	if (!lpli) 
		return -1;
	if (lpli->iSubItem < 1) 
		return -1;
	if (lpli->iSubItem >= pWD->iNumberColumns) 
		return -1;

	pli = ((TLTreeItem*)(lpli->hItem))->listItem;
	for (i=1; i<lpli->iSubItem; i++) 
		pli = pli->nextItem;

	if (lpli->mask & TLIF_STATE) 
	{
		pli->state &= ~(lpli->stateMask);
		pli->state |= (lpli->stateMask & lpli->state);
	}

	if (lpli->mask & TLIF_TEXT) 
	{
		TLFree (pli->pszText);
		if (lpli->pszText) 
		{
			pli->pszText = TLAlloc (lstrlen (lpli->pszText) +1);
			lstrcpy (pli->pszText, lpli->pszText);
		}
		else
			pli->pszText = NULL;
	}

	if (lpli->mask & TLIF_DATAVALUE) 
		pli->lDataValue = lpli->lDataValue;

	if (bInvalidate) 
		TLInvalidateItem (pWD, (TLTreeItem*)lpli->hItem);

	return (lpli->iSubItem);
}


//	_______________________________________________
//
//  Get data in list item

LONG 
TLGetListItem (
		TLWndData*		pWD, 
		TL_LISTITEM*	lpli)
{
	TLListItem* pli;
	int i;

	if (!lpli) 
		return -1;
	if (lpli->iSubItem < 1) 
		return -1;
	if (lpli->iSubItem >= pWD->iNumberColumns) 
		return -1;

	pli = ((TLTreeItem*)(lpli->hItem))->listItem;
	for (i=1; i<lpli->iSubItem; i++) 
		pli = pli->nextItem;

	if (lpli->mask & TLIF_TEXT) 
	{
		if (lpli->pszText) 
		{
			if (lstrlen (pli->pszText) < lpli->cchTextMax)
				lstrcpy (lpli->pszText, pli->pszText);
		}
	}

	if (lpli->mask & TLIF_DATAVALUE)
		lpli->lDataValue = pli->lDataValue;

	return (lpli->iSubItem);
}


//	_______________________________________________
//
//  Ensure that specified item is visible

BOOL 
TLEnsureVisible (
		TLWndData*		pWD,
		TL_TREEITEM*	lpti)
{
	if (!lpti->hItem) 
		return FALSE;
	if (!pWD->rootItem) 
		return FALSE;

	return (TLSelectAutoScroll (pWD, (TLTreeItem*)lpti->hItem));
}
上一页 12
⌨️ 快捷键说明

复制代码 Ctrl + C
搜索代码 Ctrl + F
全屏模式 F11
切换主题 Ctrl + Shift + D
显示快捷键 ?
增大字号 Ctrl + =
减小字号 Ctrl + -