uictrl.cpp

vc座的资源管理器源代码

				DrawItem((LPDRAWITEMSTRUCT)lParam);
				break;
			case WM_MEASUREITEM:
				ASSERT(pResult == NULL);       
				MeasureItem((LPMEASUREITEMSTRUCT)lParam);
				break;
			case WM_NOTIFY:
				pnmh = (LPNMHDR)lParam;
				if (pnmh->code == LVN_ITEMCHANGED)
				{
					NM_LISTVIEW* pNMListView = (NM_LISTVIEW*)pnmh;
					if ((pNMListView->uNewState & LVIS_SELECTED) == LVIS_SELECTED && 
						(pNMListView->uNewState & LVIS_FOCUSED) == LVIS_FOCUSED) 
					{
						return OnSelChanged(pNMListView->iItem,pResult);
					}	
				}
				else if (pnmh->code == LVN_GETDISPINFO) 
				{
					return GetDispInfo((LV_DISPINFO*)pnmh);
				}
				else if (pnmh->code == LVN_COLUMNCLICK) 
				{
					return ColumnClick((NM_LISTVIEW*)pnmh);
				}
				else if (pnmh->code == LVN_ENDLABELEDIT) 
				{
					return OnEndLabelEdit(pnmh,pResult);
				}
				else if (pnmh->code == NM_DBLCLK) 
				{
					return DoubleClick((NM_LISTVIEW*)pnmh);
				}
				else if (pnmh->code == NM_RETURN) 
				{
					return OnEnter((NM_LISTVIEW*)pnmh);
				}
				else if (pnmh->code == NM_CUSTOMDRAW)
				{
				     LPNMLVCUSTOMDRAW  lplvcd = (LPNMLVCUSTOMDRAW)lParam;
					 if(lplvcd->nmcd.dwDrawStage == CDDS_PREPAINT)
					 {
						//tell the control we want pre-paint notifications for each item
						*pResult = CDRF_NOTIFYITEMDRAW;
						return TRUE;
					 }
					 if (lplvcd->nmcd.dwDrawStage == (CDDS_ITEMPREPAINT | CDDS_SUBITEM))
					 {
						 return SubItemPrePaint(lplvcd,pResult);
					 }
					 if (lplvcd->nmcd.dwDrawStage == (CDDS_ITEMPOSTPAINT | CDDS_SUBITEM))
					 {
						 return SubItemPostPaint(lplvcd,pResult);
					 }
					 if (lplvcd->nmcd.dwDrawStage == CDDS_ITEMPREPAINT)
					 {
						 return ItemPrePaint(lplvcd,pResult);
					 }
					 if (lplvcd->nmcd.dwDrawStage == CDDS_ITEMPOSTPAINT)
					 {
						 return ItemPostPaint(lplvcd,pResult);
					 }
       			}
	}
	return CWnd::OnChildNotify(message, wParam, lParam, pResult);
}

LRESULT CUIODListCtrl::OnUpdateHeaderWidth(WPARAM wParam,LPARAM lParam)
{
	// lParam = column that has changed its width
	int nItem = lParam;
	m_pColWidths[nItem] = GetColumnWidth(nItem);
    GetParent()->SendMessage(WM_HEADERWIDTHCHANGED,(WPARAM)GetSafeHwnd(),nItem);
	return TRUE;
}

BOOL CUIODListCtrl::OnNotify(WPARAM wParam, LPARAM lParam, LRESULT* pResult)
{
	LPNMHDR pnmh = (LPNMHDR)lParam;
	if ((pnmh->code == HDN_BEGINTRACKW || pnmh->code == HDN_BEGINTRACKA)) 
	{
		if (m_bColumnSizing == FALSE) 
		{
			*pResult = TRUE;
			return TRUE;
		}
		LPNMHEADER phdr = (LPNMHEADER)lParam;
		if (phdr->pitem->mask & HDI_WIDTH)
		{
		}
	}
	if ((pnmh->code == HDN_ITEMCHANGINGW || pnmh->code == HDN_ITEMCHANGINGA)) 
	{
		LPNMHEADER phdr = (LPNMHEADER)lParam;
	}
	if ((pnmh->code == HDN_ENDTRACKW || pnmh->code == HDN_ENDTRACKA)) 
	{
	    HD_NOTIFY *phdn = (HD_NOTIFY*)pnmh;
		LPNMHEADER phdr = (LPNMHEADER)lParam;
		if (m_bColumnSizing == TRUE && (phdr->pitem->mask & HDI_WIDTH))
			PostMessage(WM_UPDATEHEADERWIDTH,(WPARAM)phdn->hdr.hwndFrom,(LPARAM)phdn->iItem);
	} 
	// wParam is zero for Header ctrl
	if( wParam == 0 && pnmh->code == NM_RCLICK )
	{
		// Right button was clicked on header
		CPoint ptScreen(GetMessagePos());
		CHeaderCtrl* pHeader = (CHeaderCtrl*)GetDlgItem(0);
		ASSERT(pHeader);
		CPoint ptClient(ptScreen);
		pHeader->ScreenToClient(&ptClient);
		
		// Determine the column index
		int index=-1;
		CRect rcCol;
		for( int i=0; Header_GetItemRect(pHeader->m_hWnd, i, &rcCol); i++ )
		{
			if( rcCol.PtInRect( ptClient ) )
			{
				index = i;
				break;
			}
		}
		OnRClickHeader(ptScreen,index);
	}
	return CWnd::OnNotify(wParam,lParam,pResult);
}

DWORD CUIODListCtrl::GetItemData(int nIndex) const
{
	if (nIndex != LB_ERR)
	{
		const CUIListCtrlData* pListObj = GetListCtrlData(nIndex);
		if (pListObj)
			return pListObj->GetExtData();
	}
	return 0;
}

BOOL CUIODListCtrl::SetItemDataAutoDelete(int nIndex,CObject *pObj)
{
	ASSERT_KINDOF(CObject,pObj);
	return SetItemData(nIndex,(DWORD)pObj,true);
}

BOOL CUIODListCtrl::SetItemData(int nIndex,DWORD dwData,bool bAutoDelete)
{
	if (nIndex != LB_ERR) 
	{
		CUIListCtrlData* pListObj = GetListCtrlData(nIndex);
		if (pListObj) 
		{
			pListObj->SetExtData(dwData);
			pListObj->SetAutoDelete(bAutoDelete);
			return TRUE;
		}
	}
	return FALSE;
}

int CUIODListCtrl::SetIcon(int nRow,int nImage)
{
	LV_ITEM lvItem;
	ZeroMemory(&lvItem,sizeof(LV_ITEM));
	lvItem.mask = LVIF_IMAGE;
	lvItem.iItem = nRow;
	lvItem.iImage = nImage;
	SetItem(&lvItem);
	return lvItem.iImage;
}

int CUIODListCtrl::SetIcon(int nRow,UINT nIconID)
{
	int nImage = GetImageIndex(nIconID);
	return SetIcon(nRow,nImage);
}

BOOL CUIODListCtrl::SetColumnFormat(int nCol,int fmt)
{
	LVCOLUMN lvCol;
	ZeroMemory(&lvCol,sizeof(lvCol));
	lvCol.mask = LVCF_FMT;
	lvCol.fmt = fmt;
	return SetColumn(nCol,&lvCol);
}

void CUIODListCtrl::SetTextColor(int nRow, int nCol, COLORREF TextColor)
{
	CUIListCtrlData *pData = GetListCtrlData(nRow);
	if (pData)
		pData->SetTextColor(TextColor,nCol);
}

void CUIODListCtrl::SetDefaultTextColor(int nRow,int nCol)
{
	CUIListCtrlData *pData = GetListCtrlData(nRow);
	if (pData)
		pData->SetDefaultTextColor(nCol);
}

void CUIODListCtrl::SetBkColor(int nRow,int nCol,COLORREF BkColor)
{
	CUIListCtrlData *pData = GetListCtrlData(nRow);
	if (pData)
		pData->SetBkColor(BkColor,nCol);
}

void CUIODListCtrl::SetDefaultBkColor(int nRow,int nCol)
{
	CUIListCtrlData *pData = GetListCtrlData(nRow);
	if (pData)
		pData->SetDefaultBkColor(nCol);
}

CUIListCtrlData *CUIODListCtrl::GetListCtrlData(int nItem) const
{
	CUIListCtrlData *pData = (CUIListCtrlData *)CListCtrl::GetItemData(nItem);
	if (pData == NULL)
		return NULL;
	ASSERT(pData->IsKindOf(RUNTIME_CLASS(CUIListCtrlData)));
	return pData;
}

int CUIODListCtrl::AddColumn(LPCTSTR szText)
{
	// don't add again
	int nCol = FindColumn(szText);
	if (nCol >= 0)
		return nCol;
	nCol = InsertColumn(m_nSubItems,szText);
	if (nCol != -1)
	{
		m_strHeadings += COLUMN_DELIMITER_STR;
		m_strHeadings += szText;
		m_nSubItems++;
		SaveProfile();
		LoadProfile();
	}
	return nCol;
}

int CUIODListCtrl::FindColumn(LPCTSTR pszText)
{
	LPCTSTR pszHeadings = m_strHeadings;
	int nCol=0;
	while (*pszHeadings != '\0')
	{
		if (*pszHeadings == COLUMN_DELIMITER)
			nCol++;
		if (_tcsnicmp(pszHeadings,pszText,_tcslen(pszText)) == 0)
		{
			break;			
		}
		pszHeadings = _tcsinc(pszHeadings);
	}
	return *pszHeadings == '\0' ? -1 : nCol;
}

BOOL CUIODListCtrl::InitListCtrl(UINT IconID,LPCTSTR szHeadings,LPCTSTR pszProfile)
{
	static UINT Icons[2];

	Icons[0] = IconID;
	Icons[1] = 0;
	return InitListCtrl(&Icons[0],szHeadings,pszProfile);
}

BOOL CUIODListCtrl::InitListCtrl(LPCTSTR szHeadings,LPCTSTR pszProfile)
{
	static UINT Icons[1];

	Icons[0] = 0;
	return InitListCtrl(&Icons[0],szHeadings,pszProfile);
}

int CUIODListCtrl::InitListCtrl(const UINT *pIconIDs,LPCTSTR szHeadings,LPCTSTR pszProfile)
{
	BOOL bFailed = FALSE;
	// TODO: Add extra initialization here
	if (pszProfile)
	{
		SetSection(pszProfile);
	}
	//clean up
	if (m_nSubItems) 
	{
		if (m_strHeadings == szHeadings)
			return m_nSubItems;
		DeleteAllItems();
		int nSubItems=m_nSubItems;
		for(int i=0;i < nSubItems;i++)
			DeleteColumn(0);
		m_nSubItems = 0;
		Empty();
	}
	if (pszProfile == NULL)
	{
		if (!m_strSection.IsEmpty())
			pszProfile = m_strSection;
	}
	if (pszProfile)
	{
		LoadProfile();
		// Use profile headings if found
		if (!m_strHeadings.IsEmpty())
		{
			if (m_strHeadings != szHeadings)
			{
				m_strHeadings = szHeadings;
				SaveProfile();
			}
		}
	}
	if (m_dwExStyle)
		SendMessage(LVM_SETEXTENDEDLISTVIEWSTYLE, 0, m_dwExStyle);

	// at least one image
	if (pIconIDs && *pIconIDs) 
	{
		// load the icons and add them to the image lists
		int i;
		for(i=0;*pIconIDs;i++,pIconIDs++) 
		{
			if (AddIcon(*pIconIDs) == -1)
				bFailed = TRUE;
		} 
	}

	// Now initialize the columns we will need
	// Initialize the LV_COLUMN structure
	// the mask specifies that the .fmt, .ex, width, and .subitem members 
	// of the structure are valid,
	LV_COLUMN lvC;
	lvC.mask = LVCF_FMT | LVCF_WIDTH | LVCF_TEXT | LVCF_SUBITEM;
	lvC.fmt = LVCFMT_LEFT;  // left align the column

	if (szHeadings)
	{
		// parse the string, format it and get column count
		const int MAX_HEADING_LEN = 512;
		TCHAR szHeadingsCopy[MAX_HEADING_LEN]; 
		if (_tcslen(szHeadings) >= MAX_HEADING_LEN-1)
		{
			_tcsncpy(szHeadingsCopy,szHeadings,MAX_HEADING_LEN-1);
			szHeadingsCopy[MAX_HEADING_LEN-1] = '\0';
		}
		else
			_tcscpy(szHeadingsCopy,szHeadings);
		LPTSTR p = szHeadingsCopy;
		int nCols = 0;
		while (*p != '\0')
		{
				if (*p == COLUMN_DELIMITER) 
				{
					 nCols++;
					 *p = '\0';
				}
				p = _tcsinc(p);
		}
		if (*szHeadingsCopy)		
			nCols++;
		LPTSTR pszText = szHeadingsCopy;
		m_nSubItems = nCols; 
		for (int index = 0;index < nCols; index++)
		{
			lvC.iSubItem = index;
			lvC.pszText = pszText;
//			lvC.cx = LVSCW_AUTOSIZE_USEHEADER;  
			lvC.cx = 100;  
			if (InsertColumn(index, &lvC) == -1) 
			{
				TRACE(_T("InsertColumn failed\n"));
				m_nSubItems--;
				bFailed = TRUE;
			}
			while (*pszText)
				   pszText = _tcsinc(pszText);
			pszText = _tcsinc(pszText);	// Runs past the end of the buffer
		}
		// Add the columns.
		m_strHeadings = szHeadings;
		if (pszProfile)
		{
			SaveProfile();
			LoadProfile();
		}
		if (m_pColOrder)
		{
			SendMessage(LVM_SETCOLUMNORDERARRAY,(WPARAM)nCols,(LPARAM)m_pColOrder);
		}
		if (m_pColWidths)
		{
			for(int i=0;i < nCols;i++)
			{
				if (m_pColWidths[i] != 0)
					SetColumnWidth(i,m_pColWidths[i]);
			}
		}
		else
		{
			m_pColWidths = new int[nCols];
			for(int i=0;i < nCols;i++)
			{
				m_pColWidths[i] = GetColumnWidth(i);
			}
		}
		if (m_pColTypes == NULL)
		{
			// set default column types
			m_pColTypes = new int[nCols];
			for(int i=0;i < nCols;i++)
			{
				m_pColTypes[i] = e_Text;
			}			
		}
	}
	SetSortHeader();
	return m_nSubItems;
}

void CUIODListCtrl::GetImageLists(CImageList **pILSmall,CImageList **pILLarge)
{
	*pILSmall = GetImageList(LVSIL_SMALL);
	if (*pILSmall == NULL)
	{
		CreateImageLists();
		*pILSmall = GetImageList(LVSIL_SMALL);
	}
	*pILLarge = GetImageList(LVSIL_NORMAL);
	ASSERT(*pILSmall);
	ASSERT(*pILLarge);
}

void CUIODListCtrl::CreateImageLists()
{
	m_cxSmallIcon = ::GetSystemMetrics(SM_CXSMICON);
	m_cySmallIcon = ::GetSystemMetrics(SM_CYSMICON);
	m_cxLargeIcon = ::GetSystemMetrics(SM_CXICON);
	m_cyLargeIcon = ::GetSystemMetrics(SM_CYICON);
	if (m_ImageSmall.GetSafeHandle() != NULL)
		m_ImageSmall.DeleteImageList();	
	if (m_ImageLarge.GetSafeHandle() != NULL)
		m_ImageLarge.DeleteImageList();	
	// create the small icon image list	
	m_ImageSmall.Create(m_cxSmallIcon,
						m_cySmallIcon,
						ILC_MASK | ILC_COLOR16,	
						1,
						1);	
	// create the large icon image list	
	m_ImageLarge.Create(m_cxLargeIcon,
						m_cyLargeIcon,
						ILC_MASK | ILC_COLOR16,	
						1,
						1);	
	// Associate the image lists with the list view
	SetImageList(&m_ImageSmall, LVSIL_SMALL);
	SetImageList(&m_ImageLarge, LVSIL_NORMAL);
}

void CUIODListCtrl::AddExtraString(int nRow,LPCTSTR pszExtraText)
{
	CUIStrListCtrlData *pData = (CUIStrListCtrlData *)GetListCtrlData(nRow);
	ASSERT_KINDOF(CUIStrListCtrlData,pData);
	pData->AddExtraString(pszExtraText);	
}

void CUIODListCtrl::ConvertToTime(CString &str)
{
	int nPoint = str.Find(GetDecimalSep());
	int nSecs=0;
	if (nPoint == -1)
		nSecs = _ttoi(str);
	else
	{
		LPTSTR pszStop;
		double dSecs = _tcstod(str,&pszStop);
		nSecs = dSecs;
	}
	if (nSecs == 0)
		return;
	int nMins = nSecs / 60;
	nSecs = nSecs % 60;
	str.Format(_T("%u:%u"),nMins,nSecs);
}

void CUIODListCtrl::AddThousandSeps(CString &str)
{
	CString strTemp;
	CString strExp;
	CString strNeg;
	int nDouble = str.Find(GetDecimalSep());
	if (nDouble >= 0)
	{
		strTemp = str.Left(nDouble);