bcgptaskspane.cpp

远程网络监视程序的源码

{
	if (GetSafeHwnd () == NULL || m_lstTaskGroups.IsEmpty ())
	{
		return 0;
	}

	if ((m_rectTasks.top < 0) || (m_rectTasks.bottom <= m_rectTasks.top) ||
		(m_rectTasks.left < 0) || (m_rectTasks.right <= m_rectTasks.left))
	{
		return 0; // m_rectTasks is not set yet
	}

	CRect rectTasks = m_rectTasks;
	rectTasks.DeflateRect (
		(GetHorzMargin() != -1 ? GetHorzMargin() :
		CBCGPVisualManager::GetInstance ()->GetTasksPaneHorzMargin()), 
		(GetVertMargin() != -1 ? GetVertMargin() :
		CBCGPVisualManager::GetInstance ()->GetTasksPaneVertMargin()));

	CClientDC dc (this);
	CFont* pFontOld = dc.SelectObject (&m_fontBold);

	TEXTMETRIC tm;
	dc.GetTextMetrics (&tm);

	m_nRowHeight = max (tm.tmHeight, m_sizeIcon.cy);

	int y = rectTasks.top - m_nVertScrollOffset * m_nRowHeight;

	// ---------------
	// Get active page
	// ---------------
	CBCGPTasksPanePage* pActivePage = NULL;
	POSITION posPage = m_lstTasksPanes.FindIndex (m_arrHistoryStack[m_iActivePage]);
	ASSERT(posPage != NULL);

	pActivePage = (CBCGPTasksPanePage*) m_lstTasksPanes.GetAt (posPage);
	ASSERT_VALID(pActivePage);

	// -------------
	// Recalc groups
	// -------------
	for (POSITION pos = m_lstTaskGroups.GetHeadPosition (); pos != NULL;)
	{
		CBCGPTasksGroup* pGroup = (CBCGPTasksGroup*) m_lstTaskGroups.GetNext (pos);
		ASSERT_VALID (pGroup);

		if (pGroup->m_pPage == pActivePage)
		{
		dc.SelectObject (&m_fontBold);

		int nCaptionHeight = 0;
		if (!pGroup->m_strName.IsEmpty())
		{
			CFont* pFontOld = dc.SelectObject (&globalData.fontBold);
			CSize sizeText = dc.GetTextExtent (pGroup->m_strName);
			dc.SelectObject (pFontOld);
			int nVOffset = (GetGroupCaptionVertOffset() != -1 ? GetGroupCaptionVertOffset() :
				CBCGPVisualManager::GetInstance ()->GetTasksPaneGroupCaptionVertOffset());
			int nHeight = (GetGroupCaptionHeight() != -1 ? GetGroupCaptionHeight() : 
				CBCGPVisualManager::GetInstance ()->GetTasksPaneGroupCaptionHeight());

				nCaptionHeight = max( sizeText.cy + nVOffset, nHeight );
		}
		else
		{
			nCaptionHeight = 0;
		}

		if (pGroup->m_hIcon != NULL && 
			(pGroup->m_sizeIcon.cx < rectTasks.Width () - nCaptionHeight))
		{
			if (nCaptionHeight < pGroup->m_sizeIcon.cy)
			{
				y += pGroup->m_sizeIcon.cy - nCaptionHeight;
			}
		}

		if (!bCalcHeightOnly)
		{
				pGroup->m_rect = CRect (rectTasks.left, y, 
					rectTasks.right, y + nCaptionHeight);
		}

		y += nCaptionHeight;
		int yGroup = y;

		SetFont (&dc);

		if (m_bCanCollapse && pGroup->m_bIsCollapsed && !pGroup->m_strName.IsEmpty() &&
			!(m_bAnimationEnabled && pGroup == m_pAnimatedGroup && m_sizeAnim.cy > 0 && !bCalcHeightOnly))
		{
			if (!bCalcHeightOnly)
			{
				// ---------------------
				// Recalc tasks in group
				// ---------------------
				pGroup->m_rectGroup = CRect (rectTasks.left, yGroup - 1, 
					rectTasks.right, yGroup - 1);

				for (POSITION posTask = pGroup->m_lstTasks.GetHeadPosition (); posTask != NULL;)
				{
					CBCGPTask* pTask = (CBCGPTask*) pGroup->m_lstTasks.GetNext (posTask);
					ASSERT_VALID (pTask);

					if (pTask->m_hwndTask == NULL)
					{
						pTask->m_rect.SetRectEmpty ();
					}
				}
			}
		}
		else	// not collapsed
		{
			// ---------------------
			// Recalc tasks in group
			// ---------------------
			y += (GetTasksIconVertOffset() != -1 ? GetTasksIconVertOffset() :
				CBCGPVisualManager::GetInstance ()->GetTasksPaneIconVertOffset());

			for (POSITION posTask = pGroup->m_lstTasks.GetHeadPosition (); posTask != NULL;)
			{
				CBCGPTask* pTask = (CBCGPTask*) pGroup->m_lstTasks.GetNext (posTask);
				ASSERT_VALID (pTask);

				if (pTask->m_hwndTask == NULL)
				{
						if (pTask->m_bVisible)
						{
							CFont* pFontOld = dc.SelectObject (&globalData.fontUnderline);
							CSize sizeText = dc.GetTextExtent (pTask->m_strName);
							dc.SelectObject (pFontOld);
							int cy = max (sizeText.cy, m_sizeIcon.cy);

							if (!bCalcHeightOnly)
							{
								int nTaskHOffset = (GetTasksHorzOffset() != -1 ? GetTasksHorzOffset() :
									CBCGPVisualManager::GetInstance ()->GetTasksPaneTaskHorzOffset());
								int nIconHOffset = (GetTasksIconHorzOffset() != -1 ? GetTasksIconHorzOffset() :
									CBCGPVisualManager::GetInstance ()->GetTasksPaneIconHorzOffset());

								pTask->m_rect = CRect (
									rectTasks.left + nTaskHOffset, 
									y, 
									rectTasks.left + sizeText.cx + m_sizeIcon.cx + nTaskHOffset + nIconHOffset, 
									y + cy);
								pTask->m_rect.right = max(pTask->m_rect.left, rectTasks.right - nTaskHOffset);
							}

							y += cy + (GetTasksIconVertOffset() != -1 ? GetTasksIconVertOffset() :
								CBCGPVisualManager::GetInstance ()->GetTasksPaneIconVertOffset());
						}
						else
						{
							if (!bCalcHeightOnly)
							{
								pTask->m_rect.SetRectEmpty();
							}
						}
				}

				else // Use child window
				{
					CWnd* pChildWnd = CWnd::FromHandle (pTask->m_hwndTask);
					ASSERT_VALID(pChildWnd);

					if (!bCalcHeightOnly)
					{
						CRect rectChildWnd = rectTasks;
						rectChildWnd.bottom = y + (pTask->m_bVisible ? pTask->m_nWindowHeight : 0);
						rectChildWnd.top = max (m_rectTasks.top + 1, y);
						rectChildWnd.bottom = min (m_rectTasks.bottom - 1, rectChildWnd.bottom);

						rectChildWnd.DeflateRect ((GetTasksHorzOffset() != -1 ? GetTasksHorzOffset(): 
							CBCGPVisualManager::GetInstance ()->GetTasksPaneTaskHorzOffset()), 0);

						pTask->m_rect = rectChildWnd;
					}

					y += pTask->m_nWindowHeight + 
						(GetTasksIconVertOffset() != -1 ? GetTasksIconVertOffset() :
						CBCGPVisualManager::GetInstance ()->GetTasksPaneIconVertOffset());
				}

				// constrain task's height during the animation:
				if (!bCalcHeightOnly)
				{
					if (m_bAnimationEnabled && pGroup == m_pAnimatedGroup)
					{
						if (y > yGroup + m_sizeAnim.cy)
						{
							y = yGroup + max (0, m_sizeAnim.cy);
							pTask->m_rect.bottom = max (pTask->m_rect.top, min (pTask->m_rect.bottom, y - 1));
						}
					}
				}
			}

			if (!bCalcHeightOnly)
			{
				pGroup->m_rectGroup = CRect (rectTasks.left, yGroup, rectTasks.right, y);
			}
		}

		y += (GetGroupVertOffset() != -1 ? GetGroupVertOffset() :
			CBCGPVisualManager::GetInstance ()->GetTasksPaneGroupVertOffset());
		}
	}

	if (!bCalcHeightOnly)
	{
		// ---------------------------------------------
		// Find the last task group for the active page:
		// ---------------------------------------------
		CBCGPTasksGroup* pLastGroup = NULL;
		for (POSITION posGroup = m_lstTaskGroups.GetTailPosition (); posGroup != NULL; )
		{
			CBCGPTasksGroup* pGroup = (CBCGPTasksGroup*) m_lstTaskGroups.GetPrev (posGroup);
			ASSERT_VALID (pGroup);

			if (pGroup->m_pPage == pActivePage)
			{
				pLastGroup = pGroup;
				break;
			}
		}

		if (pLastGroup != NULL)
		{
			// ---------------------------------------------
			// Offset the last group if it's bottom aligned:
			// ---------------------------------------------
			if (pLastGroup->m_bIsBottom && !pLastGroup->m_lstTasks.IsEmpty () &&
				m_nVertScrollTotal == 0)
			{
				int nOffset = 0;
				for (POSITION posTask = pLastGroup->m_lstTasks.GetTailPosition (); posTask != NULL;)
				{
					CBCGPTask* pTask = (CBCGPTask*) pLastGroup->m_lstTasks.GetPrev (posTask);
					ASSERT_VALID (pTask);

					if (pTask->m_bVisible)
					{
						nOffset = rectTasks.bottom - pLastGroup->m_rectGroup.bottom;
						break;
					}
				}

				if (nOffset > 0)
				{
					for (POSITION posTask = pLastGroup->m_lstTasks.GetHeadPosition (); posTask != NULL;)
					{
						CBCGPTask* pTask = (CBCGPTask*) pLastGroup->m_lstTasks.GetNext (posTask);
						ASSERT_VALID (pTask);

						pTask->m_rect.OffsetRect (0, nOffset);
					}

					pLastGroup->m_rect.OffsetRect (0, nOffset);
					pLastGroup->m_rectGroup.OffsetRect (0, nOffset);
				}
			}
		}

		// --------------------------------------------
		// Repos or hide child windows for active page:
		// --------------------------------------------
		for (pos = m_lstTaskGroups.GetHeadPosition (); pos != NULL;)
		{
			CBCGPTasksGroup* pGroup = (CBCGPTasksGroup*) m_lstTaskGroups.GetNext (pos);
			ASSERT_VALID (pGroup);

			if (pGroup->m_pPage == pActivePage)
			{
				BOOL bCollapsed = m_bCanCollapse && pGroup->m_bIsCollapsed && !pGroup->m_strName.IsEmpty();
				BOOL bAnimating = m_bAnimationEnabled && pGroup == m_pAnimatedGroup && m_sizeAnim.cy > 0;
				for (POSITION posTask = pGroup->m_lstTasks.GetHeadPosition (); posTask != NULL;)
				{
					CBCGPTask* pTask = (CBCGPTask*) pGroup->m_lstTasks.GetNext (posTask);
					ASSERT_VALID (pTask);

					if (pTask->m_hwndTask != NULL) // Use child window
					{
						CWnd* pChildWnd = CWnd::FromHandle (pTask->m_hwndTask);
						ASSERT_VALID(pChildWnd);
							
						if (bCollapsed && !bAnimating || !pTask->m_bVisible || pTask->m_rect.IsRectEmpty ())
						{
							pChildWnd->ShowWindow (SW_HIDE);
						}
						else
						{
							pChildWnd->SetWindowPos (NULL,
								pTask->m_rect.left, pTask->m_rect.top,
								pTask->m_rect.Width (), pTask->m_rect.Height (),
								SWP_NOZORDER | SWP_NOACTIVATE);
							pChildWnd->ShowWindow (SW_SHOWNOACTIVATE);
						}
					}

				}
			}
		}
	}

	dc.SelectObject (pFontOld);
	return y - (GetGroupVertOffset() != -1 ? GetGroupVertOffset() :
		CBCGPVisualManager::GetInstance ()->GetTasksPaneGroupVertOffset()) +
		m_nVertScrollOffset * m_nRowHeight -
		(GetTasksIconVertOffset() != -1 ? GetTasksIconVertOffset() :
		CBCGPVisualManager::GetInstance ()->GetTasksPaneIconVertOffset()) +
		(GetVertMargin() != -1 ? GetVertMargin() :
		CBCGPVisualManager::GetInstance ()->GetTasksPaneVertMargin());
}
//******************************************************************************************
void CBCGPTasksPane::OnDrawTasks (CDC* pDC, CRect rectWorkArea)
{
	ASSERT_VALID (this);
	ASSERT_VALID (pDC);

	CRect rectFill = m_rectTasks;
	rectFill.InflateRect (0, m_nVertScrollOffset * m_nRowHeight, 0, 0);
	CBCGPVisualManager::GetInstance ()->OnFillTasksPaneBackground (pDC, rectFill);

	// ---------------
	// Get active page
	// ---------------
	CBCGPTasksPanePage* pActivePage = NULL;
	POSITION posPage = m_lstTasksPanes.FindIndex (m_arrHistoryStack[m_iActivePage]);
	ASSERT(posPage != NULL);

	pActivePage = (CBCGPTasksPanePage*) m_lstTasksPanes.GetAt (posPage);
	ASSERT_VALID(pActivePage);

	// ---------------------
	// Draw all tasks groups
	// ---------------------
	for (POSITION pos = m_lstTaskGroups.GetHeadPosition (); pos != NULL; )
	{
		CBCGPTasksGroup* pGroup = (CBCGPTasksGroup*) m_lstTaskGroups.GetNext (pos);
		ASSERT_VALID (pGroup);

		if (pGroup->m_pPage == pActivePage)
		{
		if (!pGroup->m_bIsCollapsed || pGroup->m_strName.IsEmpty() ||
			(m_bAnimationEnabled && pGroup == m_pAnimatedGroup && m_sizeAnim.cy > 0))
		{
			if (!pGroup->m_rectGroup.IsRectEmpty ())
			{
				CBCGPVisualManager::GetInstance ()->OnFillTasksGroupInterior (
					pDC, pGroup->m_rectGroup);
			}
			if (!pGroup->m_rect.IsRectEmpty ())
			{
				CBCGPVisualManager::GetInstance ()->OnDrawTasksGroupCaption (
					pDC, pGroup, m_pHotGroupCaption == pGroup, FALSE, m_bCanCollapse);
			}
			if (!pGroup->m_rectGroup.IsRectEmpty ())
			{
				CBCGPVisualManager::GetInstance ()->OnDrawTasksGroupAreaBorder (
					pDC, pGroup->m_rectGroup, pGroup->m_bIsSpecial, pGroup->m_strName.IsEmpty());

				// --------------
				// Draw all tasks
				// --------------
				for (POSITION posTask = pGroup->m_lstTasks.GetHeadPosition (); posTask != NULL;)
				{
					CBCGPTask* pTask = (CBCGPTask*) pGroup->m_lstTasks.GetNext (posTask);
					ASSERT_VALID (pTask);

					if (pTask->m_bVisible && pTask->m_hwndTask == NULL) // the task is not child window
					{
						CRgn rgnClipTask;
						rgnClipTask.CreateRectRgnIndirect (&pTask->m_rect);

						pDC->SelectClipRgn (&rgnClipTask);

						CBCGPVisualManager::GetInstance ()->OnDrawTask(
							pDC, pTask, &m_lstIcons, (pTask == m_pHotTask));

						pDC->SelectClipRgn (NULL);
					}
				}
			}
		}
		else	// Group is collapsed
		{
			if (!pGroup->m_rect.IsRectEmpty ())
			{
				CBCGPVisualManager::GetInstance ()->OnDrawTasksGroupCaption(pDC, pGroup, 
					m_pHotGroupCaption == pGroup, FALSE, m_bCanCollapse);
			}
		}

		}
	}

	// ------------------------
	// Draw navigation toolbar: 
	// ------------------------
	CRect rectToolbarOld = m_rectToolbar;
	if (m_bUseNavigationToolbar)
	{
		m_wndToolBar.Invalidate ();
		m_wndToolBar.UpdateWindow ();
	}

	// --------------------
	// Draw scroll buttons:
	// --------------------
	if (m_bUseScrollButtons)
	{
		if (IsScrollUpAvailable ())
		{	
			CBCGPVisualManager::GetInstance ()->OnDrawScrollButtons(pDC, m_rectScrollUp,
				iBorderSize, CMenuImages::IdArowUp, m_iScrollMode < 0);
		}

		if (IsScrollDnAvailable ())
		{
			CBCGPVisualManager::GetInstance ()->OnDrawScrollButtons(pDC, m_rectScrollDn,
				iBorderSize, CMenuImages::IdArowDown, m_iScrollMode > 0);
		}
	}
}
//******************************************************************************************
void CBCGPTasksPane::SetIconsList (HIMAGELIST hIcons)
{
	ASSERT_VALID(this);

	if (m_lstIcons.GetSafeHandle () != NULL)
	{
		m_lstIcons.DeleteImageList ();
	}

	if (hIcons == NULL)
	{
		m_sizeIcon = CSize (0, 0);
	}
	else
	{
		m_lstIcons.Create (CImageList::FromHandle (hIcons));
		::ImageList_GetIconSize (hIcons, (int*) &m_sizeIcon.cx, (int*) &m_sizeIcon.cy);
	}

	AdjustScroll ();
	ReposTasks ();
	RedrawWindow (NULL, NULL, RDW_INVALIDATE | RDW_ERASE);
}
//******************************************************************************************
BOOL CBCGPTasksPane::SetIconsList (UINT uiImageListResID, int cx,
							  COLORREF clrTransparent)
{
	ASSERT_VALID(this);

	CBitmap bmp;
	if (!bmp.LoadBitmap (uiImageListResID))
	{
		TRACE(_T("Can't load bitmap: %x\n"), uiImageListResID);
		return FALSE;
	}

	CImageList icons;

	BITMAP bmpObj;
	bmp.GetBitmap (&bmpObj);

	UINT nFlags = (clrTransparent == (COLORREF) -1) ? 0 : ILC_MASK;

	switch (bmpObj.bmBitsPixel)
	{
	case 4:
	default:
		nFlags |= ILC_COLOR4;
		break;

	case 8:
		nFlags |= ILC_COLOR8;
		break;

	case 16:
		nFlags |= ILC_COLOR16;
		break;

	case 24:
		nFlags |= ILC_COLOR24;