bcgpcalendarbar.cpp

关于远程网络监视程序的源码

	}

	OnSelectionChanged();
}
//****************************************************************************************
void CBCGPCalendarBar::TranslateSelectionMode(SelectionMODE newMode)
{
	if (m_selMode == newMode)
		return;

	CList<int,int> dayList;

	int year = m_dateSelected.GetYear ();
	int mon = m_dateSelected.GetMonth ();

	//dayList results in Select_BYDAYS mode
	switch (m_selMode)
	{
	case Select_BYDAYS:
		{
			for (POSITION pos = m_lstSelectedDays.GetHeadPosition (); pos != NULL; )
			{
				int iDay = m_lstSelectedDays.GetNext (pos);
				dayList.AddTail (iDay);
			}
		}
		break;
	case Select_BYWEEKS:
		{
			int maxDays = GetMaxMonthDay(m_dateSelected);
			for (int iDay = 1; iDay <= maxDays; iDay ++)
			{
				int weekNo = (COleDateTime(year, mon, iDay, 0, 0, 0).GetDayOfYear () / 7);
				POSITION pos = m_lstSelectedDays.Find(weekNo);
				if (pos)
					dayList.AddTail (iDay);
			}
		}
		break;
	case Select_BYWEEKDAYS:
		{
			int maxDays = GetMaxMonthDay(m_dateSelected);
			for (int iDay = 1; iDay <= maxDays; iDay ++)
			{
				int weekNo = (COleDateTime(year, mon, iDay, 0, 0, 0).GetDayOfWeek());
				POSITION pos = m_lstSelectedDays.Find(weekNo);
				if (pos)
					dayList.AddTail (iDay);
			}
		}
		break;
	}

	m_lstSelectedDays.RemoveAll();

	for (POSITION pos = dayList.GetHeadPosition (); pos != NULL; )
	{
		int iDay = dayList.GetNext (pos);
		switch (newMode)
		{
		case Select_BYDAYS:
			{
				m_lstSelectedDays.AddTail (iDay);
			}
		break;
		case Select_BYWEEKS:
			{
				int weekNo = (COleDateTime(year, mon, iDay, 0, 0, 0).GetDayOfYear () / 7);
				POSITION p = m_lstSelectedDays.Find (weekNo);
				if (!p)
				{
					m_lstSelectedDays.AddTail (weekNo);
				}
			}
		break;
		case Select_BYWEEKDAYS:
			{
				int weekNo = (COleDateTime(year, mon, iDay, 0, 0, 0).GetDayOfWeek ());
				POSITION p = m_lstSelectedDays.Find (weekNo);
				if (!p)
				{
					m_lstSelectedDays.AddTail (weekNo);
				}
			}
		break;
		}
	}
	
	m_selMode = newMode;
}

//****************************************************************************************
void CBCGPCalendarBar::ClearSelectedDays ()
{
	while (!m_lstSelectedDays.IsEmpty ())
	{
		int iDay = m_lstSelectedDays.RemoveHead ();
		ASSERT (iDay >= 1 && iDay <= GetMaxMonthDay(m_dateSelected));

		CRect rect;
		if (GetButtonRect(iDay, rect))
		{
			rect.InflateRect (2, 2);
			InvalidateRect (rect);
		}
	}

	UpdateWindow ();
}
//****************************************************************************************
void CBCGPCalendarBar::AddSelectedDay (int iDay)
{
	ASSERT (iDay >= 1 && iDay <= 31);// GetMaxMonthDay(m_dateSelected));

	BOOL bInserted = FALSE;

	for (POSITION pos = m_lstSelectedDays.GetHeadPosition (); pos != NULL;)
	{
		POSITION posSave = pos;
		int iSelDay = m_lstSelectedDays.GetNext (pos);

		if (iSelDay == iDay)	// Already in list,
		{						// do nothing!
			return;
		}

		if (iSelDay > iDay)
		{
			m_lstSelectedDays.InsertBefore (posSave, iDay);
			bInserted = TRUE;
			break;
		}
	}

	if (!bInserted)
	{
		m_lstSelectedDays.AddTail (iDay);
	}

	CRect rect;
	if (GetButtonRect(iDay, rect))
	{
		rect.InflateRect (2, 2);
		InvalidateRect (rect);
	}
}
//****************************************************************************************
void CBCGPCalendarBar::RemoveSelectedDay (int iDay)
{
	ASSERT (iDay >= 1 && iDay <=  GetMaxMonthDay(m_dateSelected));

	for (POSITION pos = m_lstSelectedDays.GetHeadPosition (); pos != NULL;)
	{
		POSITION posSave = pos;
		if (m_lstSelectedDays.GetNext (pos) == iDay)
		{
			m_lstSelectedDays.RemoveAt (posSave);

			CRect rect;
			if (GetButtonRect(iDay, rect))
			{
				rect.InflateRect(2, 2);
				InvalidateRect (rect);
			}
			return;
		}
	}
}
//****************************************************************************************
BOOL CBCGPCalendarBar::IsDaySelected (const COleDateTime& date) const
{
	int iDay = date.GetDay ();
	if (date.GetMonth() !=  m_dateSelected.GetMonth())
	{
		return FALSE;
	}

	if (!m_bIsTearOff)
	{
		return (date == m_dateSelected);
	}

	for (POSITION pos = m_lstSelectedDays.GetHeadPosition (); pos != NULL;)
	{
		if (m_lstSelectedDays.GetNext (pos) == iDay)
		{
			return TRUE;
		}
	}

	return FALSE;
}
//****************************************************************************************
CBCGPCalendarButton* CBCGPCalendarBar::GetDayButton(int iID) const
{
	BOOL isStarted = FALSE;
	
	CRuntimeClass* dayRT = RUNTIME_CLASS(CBCGPCalendarButton);
	CString strRT = dayRT->m_lpszClassName;

	for (POSITION pos = m_Buttons.GetHeadPosition (); pos != NULL; )
	{
		CBCGPToolbarButton* pButton = (CBCGPToolbarButton*) m_Buttons.GetNext (pos);
		if (pButton->IsKindOf (RUNTIME_CLASS (CCalendarWeekNumButton))
			|| (pButton->IsKindOf (RUNTIME_CLASS (CCalendarWeekButton))))
			continue;
		if (pButton->m_nStyle & TBBS_SEPARATOR)
			continue;

		CRuntimeClass* pRunTime = pButton->GetRuntimeClass ();
		if (pRunTime && strRT == pRunTime->m_lpszClassName)
		{
			CBCGPCalendarButton* pCalendarButton = DYNAMIC_DOWNCAST (CBCGPCalendarButton, pButton);	
			int day = pCalendarButton->m_Calendar.GetDay();
			if (day == 1)
			{
				if (!isStarted)
					isStarted = TRUE;
				else break;
			}

			if (isStarted && day == iID)
			{
				return pCalendarButton;
			}
		}
	}

	return NULL;
}
//****************************************************************************************
BOOL CBCGPCalendarBar::GetButtonRect (int iID, CRect& rect, BOOL isHitTest) const
{
	CBCGPCalendarButton* pCalendarButton = GetDayButton(iID);
	if (!pCalendarButton)
		return FALSE;
	rect = pCalendarButton->m_rect;
	return TRUE;
}
//****************************************************************************************
int CBCGPCalendarBar::GetWeekNo(const COleDateTime& date, int weekStart)
{
	COleDateTime Jan1 (date.GetYear(), 1, 1, 0, 0, 0);
	int Jan1wd = Jan1.GetDayOfWeek ();
	Jan1wd = (Jan1wd + 7 - weekStart) % 7 + 1;
	int datewd = date.GetDayOfWeek ();
	datewd = (datewd + 7 - weekStart) % 7 + 1;
	int dd = datewd - Jan1wd;
		//- weekStart + 1);

	int dateyd = date.GetDayOfYear () - dd;
	return dateyd / 7 + 1;
}

//****************************************************************************************
int CBCGPCalendarBar::GetMaxMonthDay(COleDateTime date)
{ 
	//for(date)	
	int y = date.GetYear ();
	int m = date.GetMonth();
	for(int i = 31; i > 0; i --)
	{
		date.SetDate (y, m, i);
		if (date.GetStatus() == COleDateTime::valid)
			return i;
	}	
	return 0;
}
//***************************************************************************************
void CBCGPCalendarBar::OnSelectionChanged ()
{
	if (!m_bIsTearOff)
	{
		return;
	}

	CWnd* pOwner = GetOwner ();
	ASSERT_VALID (pOwner);

	pOwner->SendMessage (BCGM_CALENDAR_ON_SELCHANGED,
		0, (LPARAM) GetSafeHwnd ());
}
//***************************************************************************************
void CBCGPCalendarBar::SetFirstDayOfWeek (int nDay)
{
	ASSERT_VALID (this);
	ASSERT (nDay >= 0 && nDay < 7);

	m_nWeekStart = nDay + 1;
	SetDate (m_dateSelected);
}
//*************************************************************************************
int CBCGPCalendarBar::OnMouseActivate(CWnd* pDesktopWnd, UINT nHitTest, UINT message) 
{
	return CBCGPBaseToolBar::OnMouseActivate(pDesktopWnd, nHitTest, message);
}
//*************************************************************************************
void CBCGPCalendarBar::SelectDays (const CList<int,int>& lstDays,
									 BOOL bRedraw)
{
	if (!(m_styleFlags & CBR_MULTISELECTION))
	{
		ASSERT (FALSE);
		return;
	}

	m_lstSelectedDays.RemoveAll ();
	m_lstSelectedDays.AddTail ((CList<int, int>*) &lstDays);

	if (GetSafeHwnd () != NULL)
	{
		RedrawWindow ();
	}
}
//*************************************************************************************
void CBCGPCalendarBar::MarkDays (const CList<int,int>& lstDays,
								 BOOL bRedraw)
{
	m_lstMarkedDays.RemoveAll ();
	m_lstMarkedDays.AddTail ((CList<int, int>*) &lstDays);

	if (GetSafeHwnd () != NULL)
	{
		RedrawWindow ();
	}
}

/////////////////////////////////////////////////////////////////////////////
// CBCGPCalendarButton

IMPLEMENT_SERIAL(CBCGPCalendarButton, CBCGPToolbarButton, 1)

CBCGPCalendarButton::CBCGPCalendarButton(const COleDateTime& date, BOOL bHighlight)
{
	m_Calendar = date;
	m_bHighlight = bHighlight;
	m_strText.Format(_T("%d"), date.GetDay ());
	m_pParentBar = NULL;
}

CBCGPCalendarButton::CBCGPCalendarButton()
{
    m_Calendar = COleDateTime::GetCurrentTime();
	m_bHighlight = FALSE;
	m_strText.Format(_T("%d"), m_Calendar.GetDay ());
	m_pParentBar = NULL;
}

BOOL CBCGPCalendarButton::OnToolHitTest(const CWnd* /*pWnd*/, TOOLINFO* pTI)
{
	return FALSE;
}

void CBCGPCalendarButton::OnChangeParentWnd (CWnd* pWndParent)
{
	CBCGPToolbarButton::OnChangeParentWnd (pWndParent);
	m_pParentBar = DYNAMIC_DOWNCAST (CBCGPCalendarBar, pWndParent);
}

void CBCGPCalendarButton::SetDate (const COleDateTime& date)
{
	if (date != m_Calendar)
	{
		m_Calendar = date;
		m_strText.Format(_T("%d"), date.GetDay ());
		CRect invRect = m_rect;
		invRect.InflateRect (2, 2);
		m_pParentBar->InvalidateRect(m_rect);
	}
}

void CBCGPCalendarButton::OnDraw (CDC* pDC, const CRect& rect, CBCGPToolBarImages* pImages,
								BOOL bHorz, BOOL bCustomizeMode, BOOL bHighlight,
								BOOL bDrawBorder, BOOL bGrayDisabledButtons)
{
	ASSERT_VALID (this);

	BOOL isSelected = IsSelected();
	UINT nStyle = m_nStyle;

	if (m_bHighlight)
	{
		m_nStyle |= TBBS_CHECKED;
	}

	if (isSelected)
		m_nStyle |= TBBS_CHECKED;
	else
		m_nStyle &= ~TBBS_CHECKED;
	
	CBCGPToolbarButton::OnDraw (pDC, rect, pImages,
			bHorz, bCustomizeMode, bHighlight, bDrawBorder, bGrayDisabledButtons);

	//------------------
	// Draw today frame:
	//------------------
	COleDateTime today = COleDateTime::GetCurrentTime();
	if (IsActualDay () && today.GetMonth () == m_Calendar.GetMonth () &&
			today.GetDay () == m_Calendar.GetDay () &&
			today.GetYear () == m_Calendar.GetYear ())
	{
		CRect rectToday = rect;
		rectToday.DeflateRect (afxData.cxBorder2 - 1, afxData.cyBorder2 -  1);
		pDC->Draw3dRect (rectToday, globalData.clrBarShadow,
									globalData.clrBarShadow);
		rectToday.bottom = rectToday.top + 2;
		rectToday.top -= 1;
		pDC->FillSolidRect (rectToday, globalData.clrBarShadow);
	}

	//------------
	// Draw label:
	//------------
	if (m_iImage < 0)
	{
		CFont* pOldFont = NULL;

		if (IsCurrMonth () && IsActualDay () &&
			m_pParentBar->m_lstMarkedDays.Find (m_Calendar.GetDay()) != NULL)
		{
			pOldFont = pDC->SelectObject (&globalData.fontBold);
			ASSERT (pOldFont != NULL);
		}

		CBCGPVisualManager::BCGBUTTON_STATE state = CBCGPVisualManager::ButtonsIsRegular;

		if (bHighlight)
		{
			state = CBCGPVisualManager::ButtonsIsHighlighted;
		}
		else if (m_nStyle & (TBBS_PRESSED | TBBS_CHECKED))
		{
			//-----------------------
			// Pressed in or checked:
			//-----------------------
			state = CBCGPVisualManager::ButtonsIsPressed;
		}

		COLORREF clrText = CBCGPVisualManager::GetInstance ()->GetToolbarButtonTextColor (
			this, state);

		pDC->SetTextColor (clrText);

		CRect rectText = rect;
		pDC->DrawText (m_strText, &rectText, 
			DT_SINGLELINE | DT_VCENTER | DT_CENTER | DT_END_ELLIPSIS);

		if (pOldFont != NULL)
		{
			pDC->SelectObject (pOldFont);
		}
	}

	m_nStyle = nStyle;
}
//*************************************************************************************
BOOL CBCGPCalendarButton::IsCurrMonth () const
{
	ASSERT_VALID (m_pParentBar);
	return (m_pParentBar->m_dateSelected.GetMonth () == m_Calendar.GetMonth ());
}
//********************************************************************************
void CBCGPCalendarBar::OnSize(UINT nType, int cx, int cy) 
{
	CBCGPPopupMenuBar::OnSize(nType, cx, cy);
	
	ContextToSize ();
	RedrawWindow ();
}

/////////////////////////////////////////////////////////////////////////////
// CBCGPDefaultLocale

CBCGPDefaultLocale::CBCGPDefaultLocale ()
{
	m_strLanguage = CString (_tsetlocale (LC_TIME, NULL));
	
	int nLen = GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_SENGLANGUAGE , NULL, 0);
	
	TCHAR* pzBuffer = new TCHAR [nLen + 1];
	pzBuffer[nLen] = NULL;

	nLen = GetLocaleInfo (LOCALE_USER_DEFAULT, LOCALE_SENGLANGUAGE, pzBuffer, nLen);
	CString strLocale = CString (pzBuffer) + _T("_");
	delete [] pzBuffer;
	
	nLen = GetLocaleInfo (LOCALE_USER_DEFAULT, LOCALE_SENGCOUNTRY, NULL, 0);
	
	pzBuffer = new TCHAR [nLen + 1];
	pzBuffer [nLen] = NULL;

	nLen = GetLocaleInfo (LOCALE_USER_DEFAULT, LOCALE_SENGCOUNTRY, pzBuffer, nLen);
	strLocale += pzBuffer;
	delete [] pzBuffer;
	
	_tsetlocale (LC_TIME, strLocale);
}
//**************************************************************************************
CBCGPDefaultLocale::~CBCGPDefaultLocale ()
{
	_tsetlocale(LC_TIME, m_strLanguage);
}