disklistctrl.cpp

磁盘容量扫描、但界面和程序结构非常不错

		rc.right += 1;
		break;
	case -4:
		rc.top = nTitleHeight + 1 + nHeight*(nDriveSize+(nDriveSize!=0)); // Plus border
		rc.bottom = rc.top + nHeight*GetFolderSize();
		break;
	case -5:
		rc.top = nTitleHeight;
		rc.bottom = rcC.bottom+1;
		rc.left -= 1;
		rc.right += 1;
		break;
	default:
		if (nType>=100) // Folders
			rc.top = nTitleHeight + 1 + nHeight*((nType-100)+(nDriveSize!=0)+nDriveSize);
		else
			rc.top = nTitleHeight + 1 + nHeight*nType;

		rc.bottom = rc.top + nHeight;		
	}
	
	
	if (nPos == -1)
		return;
	// nPos -1 = Max Width
	// nPos 0-n = for every column

	// nPos in percent
	// 4 20 11 15 15,6 15,6 18,8
	// 0 <= nCode <= 6

	// Drive item rects
	if (nType<100)
	{
		double dWidth[7] = {0.04, 0.242, 0.11, 0.156, 0.14, 0.156, 0.156};
	
		double dOff = 0;
		int nTotal = rcC.Width();
		for (int i=0; i<nPos; i++)
			dOff += nTotal*dWidth[i];
	
		rc.left += (int)dOff;
		if (nPos == 6) // Last 
			rc.right = rcC.right;
		else
			rc.right = rc.left + (int)(nTotal*dWidth[nPos]);
	}else // Folder rects
	{
		double dWidth[6] = {0.04, 0.47, 0.13, 0.13, 0.13, 0.10};
	
		double dOff = 0;
		int nTotal = rcC.Width();
		for (int i=0; i<nPos; i++)
			dOff += nTotal*dWidth[i];
	
		rc.left += (int)dOff;
		if (nPos == 5) // Last 
			rc.right = rcC.right;
		else
			rc.right = rc.left + (int)(nTotal*dWidth[nPos]);
	}
}

int CDiskListCtrl::GetItemHeight(const CRect& rcClient, BOOL bTitle)
{
	int nTotal = rcClient.Height() - 2; // minus borders
	int nDriveSize = m_arrayDrive.GetSize();
	int nNumber =  nDriveSize + m_arrayFolder.GetSize() + (nDriveSize!=0); // plus title and total info

	int nHeight = 22;//nTotal / nNumber;

	if (bTitle)
		return nTotal - nHeight*nNumber;
	else
		return nHeight;
}

int CDiskListCtrl::GetDriveSize()
{
	return m_arrayDrive.GetSize();
	/*
	for (int i = nCount-1; i > -1; i--)
	{
		if (!m_arrayItem.GetAt(i)->m_bIsDrive)
			nCount --;
	}
	
	return nCount;*/
}

int CDiskListCtrl::GetFolderSize()
{
	return m_arrayFolder.GetSize();
	/*
	for (int i = nCount-1; i > -1; i--)
	{
		if (m_arrayItem.GetAt(i)->m_bIsDrive)
			nCount --;
	}
	
	return nCount;*/
}

BOOL CDiskListCtrl::OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message) 
{
	SetCursor(LoadCursor(NULL, IDC_ARROW));

	return TRUE;
}

void CDiskListCtrl::DrawTotalItem(CDC *pDC, const CRect& rcClient)
{
	int nCount;
	long double ldTotal, ldFree;
	GetTotalUsage(nCount, ldTotal, ldFree);

	CRect rcItem;
	// Draw Total info
	GetItemRect(rcClient, rcItem, -3, 1);
	CString str, str1;
	str1.LoadString(IDS_TOTAL_DRIVES);
	str.Format(str1, nCount);
	pDC->DrawText(str, rcItem, DT_SINGLELINE | DT_VCENTER | DT_CENTER);	
	
	GetItemRect(rcClient, rcItem, -3, 3);
	FormatByteSize(ldTotal, str);
	pDC->DrawText(str, rcItem, DT_SINGLELINE | DT_VCENTER | DT_CENTER);
	
	long double ldUsed = ldTotal - ldFree;
	GetItemRect(rcClient, rcItem, -3, 4);
	rcItem.DeflateRect(0, 2);
	str.Format("%.0f%%", (ldTotal==0)?0:(ldUsed/ldTotal)*100);
	DrawPercentBar(pDC, rcItem, (ldTotal==0)?0:ldUsed/ldTotal, 
		str, GetFont());
	
	GetItemRect(rcClient, rcItem, -3, 5);
	FormatByteSize(ldUsed, str);
	pDC->DrawText(str, rcItem, DT_SINGLELINE | DT_VCENTER | DT_CENTER);
	
	GetItemRect(rcClient, rcItem, -3, 6);
	FormatByteSize(ldFree, str);
	pDC->DrawText(str, rcItem, DT_SINGLELINE | DT_VCENTER | DT_CENTER);
}

void CDiskListCtrl::DrawFolder(CDC *pDC, const CRect& rcClient, int nItem)
{
	CRect rcItem;
	CItemInfo* pItem = m_arrayFolder.GetAt(nItem);
	CString str, strTemp;

	// Image
	GetItemRect(rcClient, rcItem, nItem+100, 0);
	rcItem.left += (rcItem.Width() - 16) / 2;
	rcItem.top += (rcItem.Height() - 16) / 2;
	if (pItem->m_pThread)
		m_imgTypeList.Draw(pDC, 7, rcItem.TopLeft(), ILD_NORMAL);
	else
		m_imgTypeList.Draw(pDC, 6, rcItem.TopLeft(), ILD_NORMAL);

	GetItemRect(rcClient, rcItem, nItem+100, 1);
	rcItem.left += 2;
	rcItem.right -= 2;
	::DrawTextEx (pDC->m_hDC,
                pItem->m_strDriveName.GetBuffer (0),
                pItem->m_strDriveName.GetLength(),
                &rcItem,
                DT_SINGLELINE | DT_VCENTER | DT_LEFT | DT_PATH_ELLIPSIS,
                NULL);
	
	if (pItem->GetFinished())
	{
		GetItemRect(rcClient, rcItem, nItem+100, 2);
		rcItem.left += 2;
		strTemp.LoadString(IDS_COUNT_FOLDER);
		str.Format(strTemp, pItem->m_nFolderCount);
		pDC->DrawText(str, rcItem, DT_SINGLELINE | DT_VCENTER | DT_LEFT);
		
		GetItemRect(rcClient, rcItem, nItem+100, 3);
		rcItem.left += 2;
		strTemp.LoadString(IDS_COUNT_FILE);
		str.Format(strTemp, pItem->m_nFileCount);
		pDC->DrawText(str, rcItem, DT_SINGLELINE | DT_VCENTER | DT_LEFT);
		
		GetItemRect(rcClient, rcItem, nItem+100, 4);
		rcItem.left += 2;
		FormatByteSize(pItem->m_ldTotalSpace, str);
		pDC->DrawText(str, rcItem, DT_SINGLELINE | DT_VCENTER | DT_LEFT);
	}else
	{
		GetItemRect(rcClient, rcItem, nItem+100, 2);
		rcItem.left += 2;
		str.LoadString(IDS_ABORTED);
		pDC->DrawText(str, rcItem, DT_SINGLELINE | DT_VCENTER | DT_LEFT);
	}

	// Alert indicator
	GetItemRect(rcClient, rcItem, nItem+100, 5);
	rcItem.left += 2;
	rcItem.top += (rcItem.Height() - 16) / 2;
	double dMb = pItem->m_ldTotalSpace / (1024*1024);
	int nMode = ( dMb> m_dRedAlert)? 2 : 
				((dMb > m_dYellowAlert)? 1 : 0);

	for (int i=0; i<3; i++)
	{
		m_imgTypeList.Draw(pDC, 8 + ((nMode==i && (pItem->GetFinished()))?i+1:0), rcItem.TopLeft(), ILD_NORMAL);
		rcItem.left += 16;
	}

}

void CDiskListCtrl::DrawDrive(CDC *pDC, const CRect& rcClient, int nItem)
{
	CRect rcItem;
	CItemInfo* pItem = m_arrayDrive.GetAt(nItem);

	// Image
	GetItemRect(rcClient, rcItem, nItem, 0);
	rcItem.left += (rcItem.Width() - 16) / 2;
	rcItem.top += (rcItem.Height() - 16) / 2;

	switch (pItem->m_nDriveType)
	{
	case DRIVE_REMOVABLE:
		m_imgTypeList.Draw(pDC, 0, rcItem.TopLeft(), ILD_NORMAL);
		break;
		
	case DRIVE_FIXED:
		m_imgTypeList.Draw(pDC, 1, rcItem.TopLeft(), ILD_NORMAL);
		break;
		
	case DRIVE_REMOTE:
		if (pItem->m_bAvailable)
			m_imgTypeList.Draw(pDC, 3, rcItem.TopLeft(), ILD_NORMAL);
		else
			m_imgTypeList.Draw(pDC, 4, rcItem.TopLeft(), ILD_NORMAL);
		break;
		
		
	case DRIVE_CDROM:
		m_imgTypeList.Draw(pDC, 2, rcItem.TopLeft(), ILD_NORMAL);
		break;
		
	case DRIVE_RAMDISK:
		m_imgTypeList.Draw(pDC, 5, rcItem.TopLeft(), ILD_NORMAL);
		break;
	}

	CString str, strText;
								
	if (pItem->m_bAvailable)
	{	
		// Draw Title
		GetItemRect(rcClient, rcItem, nItem, 1);
		pDC->DrawText(pItem->m_strTitle, rcItem, DT_SINGLELINE | DT_VCENTER | DT_CENTER);
		
		//Draw Type
		GetItemRect(rcClient, rcItem, nItem, 2);
		pDC->DrawText(pItem->m_strPartitionType, rcItem, DT_SINGLELINE | DT_VCENTER | DT_CENTER);
		
		// Total
		GetItemRect(rcClient, rcItem, nItem, 3);
		//rcItem.right-=10;
		FormatByteSize(pItem->m_ldTotalSpace, str);
		pDC->DrawText(str, rcItem, DT_SINGLELINE | DT_VCENTER | DT_CENTER);
		
		
		long double ldUsed = pItem->m_ldTotalSpace - pItem->m_ldFreeSpace;
		// Draw Usage
		GetItemRect(rcClient, rcItem, nItem, 4);
		rcItem.DeflateRect(0, 2);
		str.Format("%.0f%%", pItem->GetUsage() * 100);
		DrawPercentBar(pDC, rcItem, pItem->GetUsage(), 
			str, GetFont());
		
		// Used
		GetItemRect(rcClient, rcItem, nItem, 5);
		FormatByteSize(ldUsed, str);
		pDC->DrawText(str, rcItem, DT_SINGLELINE | DT_VCENTER | DT_CENTER);
		
		// Free in bold font
		GetItemRect(rcClient, rcItem, nItem, 6);
		FormatByteSize(pItem->m_ldFreeSpace, str);
		pDC->DrawText(str, rcItem, DT_SINGLELINE | DT_VCENTER | DT_CENTER);
	}else
	{
		if (pItem->m_nDriveType == DRIVE_CDROM ||
			pItem->m_nDriveType == DRIVE_REMOVABLE )
			str.LoadString(IDS_NODISK);
		else
			str.LoadString(IDS_NOTAVAILABLE);
		
		strText.Format(str, pItem->m_strDriveName);
		GetItemRect(rcClient, rcItem, nItem, -1);
		pDC->DrawText(strText, rcItem, DT_SINGLELINE | DT_VCENTER | DT_CENTER);
	}
}

void CDiskListCtrl::Update(BOOL bFolders)
{
	int nCount = m_arrayDrive.GetSize();
	BOOL bUpdate = FALSE;
	CItemInfo* pItem;

	for (int i = 0; i < nCount; i++)
	{
		pItem = m_arrayDrive.GetAt(i);
			if (pItem->Update())
				bUpdate = TRUE;
	}
	
	if (bFolders)
	{
		nCount = m_arrayFolder.GetSize();
		
		for (i = 0; i < nCount; i++)
		{
			pItem = m_arrayFolder.GetAt(i);
			pItem->UpdateFolder(i+100);
		}
	}

	if (bUpdate)
		InvalidateRect(NULL, FALSE);
}

int CDiskListCtrl::OnCreate(LPCREATESTRUCT lpCreateStruct) 
{
	if (CWnd::OnCreate(lpCreateStruct) == -1)
		return -1;
	
	InitCtrl();
	
	return 0;
}

void CDiskListCtrl::InitCtrl()
{
	// Delete all
	if (!m_bmpDriveBack.IsEmpty()) m_bmpDriveBack.DestroyBitmap();
	if (!m_bmpFreeBack.IsEmpty()) m_bmpFreeBack.DestroyBitmap();
	if (!m_bmpTotalBack.IsEmpty()) m_bmpTotalBack.DestroyBitmap();
	if (!m_bmpFolderBack.IsEmpty()) m_bmpFolderBack.DestroyBitmap();
	if (!m_bmpHighBack.IsEmpty()) m_bmpHighBack.DestroyBitmap();
	if (!m_bmpPressedBack.IsEmpty()) m_bmpPressedBack.DestroyBitmap();

	if (m_fontTitle.m_hObject)
		m_fontTitle.DeleteObject();

	if (m_imgTypeList.m_hImageList)
		m_imgTypeList.DeleteImageList();
	
	m_fontTitle.CreateFont(16, 0,0,0,FW_NORMAL, 0,0,0,
		DEFAULT_CHARSET, OUT_CHARACTER_PRECIS, CLIP_CHARACTER_PRECIS,
		DEFAULT_QUALITY, DEFAULT_PITCH | FF_DONTCARE, "Arial");

	HINSTANCE hIns = AfxGetResourceHandle();
	AfxSetResourceHandle(AfxGetInstanceHandle());
	m_imgTypeList.Create(IDB_TYPE_LIST_SMALL, 16, 0, RGB(255,0,255));
	AfxSetResourceHandle(hIns);

	CWinApp* app = AfxGetApp();
	CString strPath = GetHomeDirectory();

	m_bEnableBackground = app->GetProfileInt("Settings", "EnableBackground",   1);
	CString strBmpDrive = app->GetProfileString("Settings", "BmpDrive",   strPath+"images\\Drive.bmp");
	CString strBmpFolder = app->GetProfileString("Settings", "BmpFolder",   strPath+"images\\Folder.bmp");
	CString strBmpFree = app->GetProfileString("Settings", "BmpFree",   strPath+"images\\Free.bmp");
	CString strBmpHigh = app->GetProfileString("Settings", "BmpHigh",   strPath+"images\\High.bmp");
	CString strBmpPressed = app->GetProfileString("Settings", "BmpPressed",   strPath+"images\\Pressed.bmp");
	CString strBmpTotal = app->GetProfileString("Settings", "BmpTotal",   strPath+"images\\Total.bmp");


	if (m_bEnableBackground)
	{
		m_bmpDriveBack.Load(strBmpDrive);
		m_bmpFreeBack.Load(strBmpFree);
		m_bmpTotalBack.Load(strBmpTotal);
		m_bmpFolderBack.Load(strBmpFolder);
		m_bmpHighBack.Load(strBmpHigh);
		m_bmpPressedBack.Load(strBmpPressed);
	}

	InvalidateRect(NULL, FALSE);
}

void CDiskListCtrl::GetTotalUsage(int& nCount, long double &ldTotal, long double &ldFree)
{
	int nSize = m_arrayDrive.GetSize();
	ldTotal = 0;
	ldFree = 0;
	nCount = 0;
	
	for (int i = 0; i < nSize; i++)
	{
		CItemInfo* pItem = m_arrayDrive.GetAt(i);
		if (pItem->m_bAvailable)
		{
			nCount ++;
			ldTotal += pItem->m_ldTotalSpace;
			ldFree += pItem->m_ldFreeSpace;
		}
	}
}

void CDiskListCtrl::OnMouseMove(UINT nFlags, CPoint point) 
{
	if (GetActiveWindow() == NULL || GetOwner() == NULL)
		return;

	int nOldCode = m_nMouseInCode;

	int nCode = HitTestEx(point);

	if (nFlags & MK_LBUTTON)
		m_bMouseDown = TRUE;
	else
	{
		m_bMouseDown = FALSE;
		m_nMouseDownCode = 1000;
	}

	if (m_nMouseInCode != nCode)
	{
		int nOld = m_nMouseInCode;
		m_nMouseInCode = nCode;
		RedrawItem(nOld);
		RedrawItem(m_nMouseInCode);

		KillTimer(5);
		SetTimer(5,10,NULL);
	}

	

	CWnd::OnMouseMove(nFlags, point);
}

void CDiskListCtrl::OnLButtonDown(UINT nFlags, CPoint point) 
{
	if (m_nMouseInCode<1000)
	{
		int n = HitTestEx(point);
		VERIFY(m_nMouseInCode == n);
		m_nMouseDownCode = n;

		if (!m_bMouseDown)
			m_bMouseDown = TRUE;

		RedrawItem(m_nMouseInCode);

/*
		CRect rcClient, rcItem;
		GetClientRect(&rcClient);
		GetItemRect(rcClient, rcItem, n, -1);
		CString str;
		str.Format("%d,%d, %d, %d", rcItem.left, rcItem.top, rcItem.right, rcItem.bottom);

		MessageBox(str);
*/
	}
	
	CWnd::OnLButtonDown(nFlags, point);
}

void CDiskListCtrl::OnLButtonUp(UINT nFlags, CPoint point) 
{
	if (m_nMouseInCode<1000 && m_nMouseDownCode== m_nMouseInCode)
	{
		int n = HitTestEx(point);
		
		if (m_bMouseDown)
		{
			if (m_nMouseInCode == n)
			{
				m_bMouseDown = FALSE;
				m_nMouseDownCode = 1000;
				RedrawItem(m_nMouseInCode);

				if (m_nMouseInCode < 0) // Sort
					SortItems(-m_nMouseInCode);
				else