bcgptaskspane.cpp

远程网络监视程序的源码

		{
			// remove old task hotlight
			CRect rectTask = m_pHotTask->m_rect;
			m_pHotTask = NULL;
			RedrawWindow (rectTask, NULL, RDW_INVALIDATE | RDW_ERASE);
		}
		
		// remove old group caption hotlight
		if (m_pHotGroupCaption != NULL)
		{
			CRect rectUpdate = m_pHotGroupCaption->m_rect;
			m_pHotGroupCaption = NULL;
			RedrawWindow (rectUpdate, NULL, RDW_INVALIDATE | RDW_ERASE);
		}

		// add new task hotlight
		m_pHotTask = pHotTask;
		RedrawWindow (pHotTask->m_rect, NULL, RDW_INVALIDATE | RDW_ERASE);

		if (pHotTask->m_uiCommandID != 0)
		{
			ShowCommandMessageString (pHotTask->m_uiCommandID);
		}
	}
}
//******************************************************************************************
void CBCGPTasksPane::OnLButtonUp(UINT nFlags, CPoint point) 
{
	CBCGPDockingControlBar::OnLButtonUp(nFlags, point);

	if (m_pHotTask == NULL && m_pClickedTask == NULL && 
		m_pHotGroupCaption == NULL && m_pClickedGroupCaption == NULL)
	{
		return;
	}

	ReleaseCapture ();

	// --------------------------
	// Handle group caption click
	// --------------------------
	CBCGPTasksGroup* pHotGroupCaption = m_pHotGroupCaption;
	BOOL bIsGroupCaptionClick = (m_pHotGroupCaption != NULL && 
		m_pHotGroupCaption == GroupCaptionHitTest (point) && 
		m_pClickedGroupCaption == m_pHotGroupCaption);

	m_pHotGroupCaption = NULL;
	m_pClickedGroupCaption = NULL;

	if (bIsGroupCaptionClick)
	{
		pHotGroupCaption->m_bIsCollapsed = !pHotGroupCaption->m_bIsCollapsed;

		if (m_bAnimationEnabled)
		{
			m_pAnimatedGroup = pHotGroupCaption;
			m_sizeAnim = m_pAnimatedGroup->m_rectGroup.Size ();
			
			SetTimer (iAnimTimerId, m_iAnimTimerDuration, NULL);
			m_nLastAnimTime = clock ();
		}
		
		AdjustScroll ();
		ReposTasks ();
		RedrawWindow (NULL, NULL, RDW_INVALIDATE | RDW_ERASE);

		// Trigger mouse move event (to change selection notification):
		SendMessage (WM_MOUSEMOVE, nFlags, MAKELPARAM (point.x, point.y));
		return;
	}
	else
	{
		CRect rectGroupCaption = (m_pHotGroupCaption != NULL) ? 
			m_pHotGroupCaption->m_rect : CRect (0, 0, 0, 0);
		RedrawWindow (rectGroupCaption, NULL, RDW_INVALIDATE | RDW_ERASE);
	}

	// -----------------
	// Handle task click
	// -----------------
	CBCGPTask* pHotTask = m_pHotTask;
	BOOL bIsTaskClick = (m_pHotTask != NULL && m_pHotTask == TaskHitTest (point) &&
		m_pClickedTask == m_pHotTask);

	CRect rectTask = (m_pHotTask != NULL) ? m_pHotTask->m_rect : CRect (0, 0, 0, 0);

	m_pHotTask = NULL;
	m_pClickedTask = NULL;

	RedrawWindow (rectTask, NULL, RDW_INVALIDATE | RDW_ERASE);

	if (bIsTaskClick)
	{
		// Find task number and group number:
		ASSERT_VALID (pHotTask->m_pGroup);

		int nTaskNumber = -1;
		int i = 0;

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

			if (pTask == pHotTask)
			{
				nTaskNumber = i;
				break;
			}
		}

		int nGroupNumber = -1;
		i = 0;

		for (POSITION pos = m_lstTaskGroups.GetHeadPosition (); pos != NULL; i++)
		{
			CBCGPTasksGroup* pGroup = (CBCGPTasksGroup*) m_lstTaskGroups.GetNext (pos);
			ASSERT_VALID (pGroup);

			if (pHotTask->m_pGroup == pGroup)
			{
				nGroupNumber = i;
				break;
			}
		}

		OnClickTask (nGroupNumber, nTaskNumber, pHotTask->m_uiCommandID, pHotTask->m_dwUserData);
	}
}
//******************************************************************************************
void CBCGPTasksPane::OnCancelMode() 
{
	CBCGPDockingControlBar::OnCancelMode();
	
	if (m_pHotTask != NULL || m_pClickedTask != NULL)
	{
		CRect rectTask = m_pHotTask != NULL ? m_pHotTask->m_rect : CRect (0, 0, 0, 0);
		m_pHotTask = NULL;
		m_pClickedTask = NULL;
		ReleaseCapture ();
		RedrawWindow (rectTask, NULL, RDW_INVALIDATE | RDW_ERASE);
	}

	if (m_pHotGroupCaption != NULL || m_pClickedGroupCaption != NULL)
	{
		CRect rectTask = m_pHotGroupCaption != NULL ? 
			m_pHotGroupCaption->m_rect : CRect (0, 0, 0, 0);
		m_pHotGroupCaption = NULL;
		m_pClickedGroupCaption = NULL;
		ReleaseCapture ();
		RedrawWindow (rectTask, NULL, RDW_INVALIDATE | RDW_ERASE);
	}

	m_pClickedTask = NULL;
	m_pClickedGroupCaption = NULL;
}
//******************************************************************************************
void CBCGPTasksPane::OnClickTask (int /*nGroupNumber*/, int /*nTaskNumber*/, 
							 UINT uiCommandID, DWORD /*dwUserData*/)
{
	if (uiCommandID != 0)
	{
		GetOwner ()->PostMessage (WM_COMMAND, uiCommandID);
	}
}
//****************************************************************************************
void CBCGPTasksPane::OnLButtonDown(UINT nFlags, CPoint point) 
{
	m_pClickedGroupCaption = GroupCaptionHitTest (point);
	m_pClickedTask = TaskHitTest (point);

	CRect rectClient;
	rectClient.SetRectEmpty ();
	GetClientRect (&rectClient);

	if (!rectClient.PtInRect(point) || m_rectToolbar.PtInRect(point))
	{
		CBCGPDockingControlBar::OnLButtonDown(nFlags, point);
	}
}
//****************************************************************************************

//-----------------------------------------------------
// My "classic " trick - how I can access to protected
// member m_pRecentFileList?
//-----------------------------------------------------
class CBCGApp : public CWinApp
{
	friend class CBCGPTasksPane;
};

int CBCGPTasksPane::AddMRUFilesList(int nGroup, int nMaxFiles /* = 4 */)
{
	POSITION pos = m_lstTaskGroups.FindIndex (nGroup);
	if (pos == NULL)
	{
		ASSERT (FALSE);
		return -1;
	}

	CBCGPTasksGroup* pGroup = (CBCGPTasksGroup*) m_lstTaskGroups.GetAt (pos);
	ASSERT_VALID (pGroup);

	POSITION posFirstMRUFile = NULL;

	// Clean up old MRU files from the group:
	for (pos = pGroup->m_lstTasks.GetHeadPosition (); pos != NULL;)
	{
		POSITION posSave = pos;

		CBCGPTask* pTask = (CBCGPTask*) pGroup->m_lstTasks.GetNext (pos);
		ASSERT_VALID (pTask);

		if (pTask->m_uiCommandID >= ID_FILE_MRU_FILE1 &&
			pTask->m_uiCommandID <= ID_FILE_MRU_FILE16)
		{
			posFirstMRUFile = posSave;
			pGroup->m_lstTasks.GetNext (posFirstMRUFile);

			delete pGroup->m_lstTasks.GetAt (posSave);
			pGroup->m_lstTasks.RemoveAt (posSave);
		}
	}

	CRecentFileList* pRecentFileList = 
		((CBCGApp*) AfxGetApp ())->m_pRecentFileList;

	if (pRecentFileList == NULL)
	{
		return pGroup->m_lstTasks.GetCount () - 1;
	}

	int nNum = min (pRecentFileList->GetSize(), nMaxFiles);

	for (int i = 0; i < nNum; i++)
	{
		if ((*pRecentFileList)[i].GetLength() != 0)
		{
			const int MAX_NAME_LEN = 512;

			TCHAR lpcszBuffer [MAX_NAME_LEN + 1];
			memset(lpcszBuffer, 0, MAX_NAME_LEN * sizeof(TCHAR));

			if (GetFileTitle((*pRecentFileList)[i], lpcszBuffer, MAX_NAME_LEN) != 0)
			{
				ASSERT(FALSE);
			}

			CBCGPTask* pTask = new CBCGPTask (pGroup, lpcszBuffer, -1, ID_FILE_MRU_FILE1 + i);
			ASSERT_VALID (pTask);

			if (posFirstMRUFile == NULL)
			{
				pGroup->m_lstTasks.AddTail (pTask);
			}
			else
			{
				pGroup->m_lstTasks.InsertBefore (posFirstMRUFile, pTask);
			}
		}
	}

	AdjustScroll ();
	ReposTasks ();
	return pGroup->m_lstTasks.GetCount () - 1;
}
//*******************************************************************************************

CScrollBar* CBCGPTasksPane::GetScrollBarCtrl(int nBar) const
{
	if (nBar == SB_HORZ || m_wndScrollVert.GetSafeHwnd () == NULL)
	{
		return NULL;
	}

	return (CScrollBar* ) &m_wndScrollVert;
}
//******************************************************************************************
void CBCGPTasksPane::OnVScroll(UINT nSBCode, UINT nPos, CScrollBar* /*pScrollBar*/) 
{
	int nPrevOffset = m_nVertScrollOffset;

	switch (nSBCode)
	{
	case SB_LINEUP:
		m_nVertScrollOffset--;
		break;

	case SB_LINEDOWN:
		m_nVertScrollOffset++;
		break;

	case SB_TOP:
		m_nVertScrollOffset = 0;
		break;

	case SB_BOTTOM:
		m_nVertScrollOffset = m_nVertScrollTotal;
		break;

	case SB_PAGEUP:
		m_nVertScrollOffset -= m_nVertScrollPage;
		break;

	case SB_PAGEDOWN:
		m_nVertScrollOffset += m_nVertScrollPage;
		break;

	case SB_THUMBPOSITION:
	case SB_THUMBTRACK:
		m_nVertScrollOffset = nPos;
		break;

	default:
		return;
	}

	m_nVertScrollOffset = min (max (0, m_nVertScrollOffset), 
		m_nVertScrollTotal - m_nVertScrollPage + 1);

	if (m_nVertScrollOffset == nPrevOffset)
	{
		return;
	}

	SetScrollPos (SB_VERT, m_nVertScrollOffset);

	AdjustScroll ();
	ReposTasks ();
	RedrawWindow (NULL, NULL, RDW_INVALIDATE | RDW_ERASE);
}
//*****************************************************************************************
void CBCGPTasksPane::SetScrollSizes ()
{
	ASSERT_VALID (this);

	if (m_wndScrollVert.GetSafeHwnd () == NULL)
	{
		return;
	}

	if (m_nRowHeight == 0)
	{
		m_nVertScrollPage = 0;
		m_nVertScrollTotal = 0;
		m_nVertScrollOffset = 0;
	}
	else
	{
		int nPageHeight = m_rectTasks.Height ();
		if (m_bUseScrollButtons)
		{
			nPageHeight -= m_iScrollBtnHeight + iBorderSize;
		}
		BOOL bMultiPage = (m_lstTasksPanes.GetCount () > 1);
		if ((m_bUseNavigationToolbar || ForceShowNavToolbar ()) && bMultiPage)
		{
			nPageHeight += m_rectToolbar.Height ();
		}

		m_nVertScrollPage = nPageHeight / m_nRowHeight - 1;

		int nTotalHeight = ReposTasks (TRUE);
		if (nTotalHeight == 0 || nTotalHeight <= nPageHeight)
		{
			m_nVertScrollPage = 0;
			m_nVertScrollTotal = 0;
			m_nVertScrollOffset = 0;
		}
		else
		{
			m_nVertScrollTotal = nTotalHeight / m_nRowHeight - 1;
		}

		m_nVertScrollOffset = min (max (0, m_nVertScrollOffset), 
			m_nVertScrollTotal - m_nVertScrollPage + 1);
	}

	if (!m_bUseScrollButtons)
	{
		SCROLLINFO si;

		ZeroMemory (&si, sizeof (SCROLLINFO));
		si.cbSize = sizeof (SCROLLINFO);

		si.fMask = SIF_RANGE | SIF_POS | SIF_PAGE;
		si.nMin = 0;
		si.nMax = m_nVertScrollTotal;
		si.nPage = m_nVertScrollPage;
		si.nPos = m_nVertScrollOffset;

		SetScrollInfo (SB_VERT, &si, TRUE);
	}
	m_wndScrollVert.EnableScrollBar (!m_bUseScrollButtons && m_nVertScrollTotal > 0 ? ESB_ENABLE_BOTH : ESB_DISABLE_BOTH);
}
//****************************************************************************************
void CBCGPTasksPane::AdjustScroll ()
{
	ASSERT_VALID (this);
	
	if (GetSafeHwnd () == NULL || m_lstTaskGroups.IsEmpty ())
	{
		return;
	}

	CRect rectClient;
	GetClientRect (rectClient);

	// --------------------------
	// Adjust navigation toolbar: 
	// --------------------------
	CRect rectToolbarOld = m_rectToolbar;
	BOOL bMultiPage = (m_lstTasksPanes.GetCount () > 1);
	if ((m_bUseNavigationToolbar || ForceShowNavToolbar ()) && bMultiPage)
	{
		int nToolbarHeight = m_wndToolBar.CalcFixedLayout (FALSE, TRUE).cy;

		m_rectToolbar = rectClient;
		m_rectToolbar.bottom = m_rectToolbar.top + nToolbarHeight;

		rectClient.top += m_rectToolbar.Height ();

		m_wndToolBar.SetWindowPos (NULL, m_rectToolbar.left, m_rectToolbar.top, 
									m_rectToolbar.Width (), nToolbarHeight,
									SWP_NOACTIVATE | SWP_NOZORDER);
		m_wndToolBar.ShowWindow (TRUE);
	}
	else
	{
		m_rectToolbar.SetRectEmpty ();
		m_wndToolBar.ShowWindow (FALSE);
	}

	// --------------------
	// Calculate work area:
	// --------------------
	m_rectTasks = rectClient;

	// ------------------
	// Adjust scroll bar:
	// ------------------
	SetScrollSizes ();

	m_wndScrollVert.EnableWindow (!m_bUseScrollButtons);
	if (!m_bUseScrollButtons && m_nVertScrollTotal > 0)
	{
		int cxScroll = ::GetSystemMetrics (SM_CXHSCROLL);

		m_rectTasks.right -= cxScroll;

		m_wndScrollVert.SetWindowPos (NULL, rectClient.right - cxScroll, rectClient.top,
			cxScroll, rectClient.Height (), SWP_SHOWWINDOW | SWP_NOZORDER | SWP_NOACTIVATE);
		rectClient.right -= cxScroll;
	}
	else
	{
		m_wndScrollVert.SetWindowPos (NULL, 0, 0,
			0, 0, SWP_HIDEWINDOW);
	}

	// ----------------------
	// Adjust scroll buttons:
	// ----------------------
	CRect rectScrollUpOld = m_rectScrollUp;
	CRect rectScrollDnOld = m_rectScrollDn;

	m_rectScrollUp.SetRectEmpty ();
	m_rectScrollDn.SetRectEmpty ();

	if (m_bUseScrollButtons)
	{
		if (IsScrollUpAvailable ())
		{
			m_rectScrollUp = rectClient;
			m_rectScrollUp.top += iBorderSize;
			m_rectScrollUp.bottom = m_rectScrollUp.top + m_iScrollBtnHeight;

			rectClient.top += m_iScrollBtnHeight + iBorderSize;
		}

		if (IsScrollDnAvailable ())
		{
			m_rectScrollDn = rectClient;
			m_