alarmwnd.cpp

一个很漂亮的数字时钟程序,你一定会喜欢的.

// AlarmWnd.cpp : implementation of the CAlarmWnd class
//

#include "stdafx.h"
#include "Alarm.h"
#include "AlarmWnd.h"
#include "OptionsDlg.h"
#include "SpeakNumber.h"
#include "Sound.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

/////////////////////////////////////////////////////////////////////////////
// tagNumbersRC & tagWindowRC

BOOL bCAM = FALSE, bAAM = FALSE;
BOOL bClockAM = TRUE, bAlarmAM = TRUE;

enum { enON = 0, enOFF = 1 };

class tagNumbersRC
{
public:	
	tagNumbersRC()
	{
		Initialize();
	}

	void Initialize(BOOL bBackFace = FALSE)
	{
		int y = 0;

		if (! bBackFace) y = 100;
		
		rCAM[enON]  = CRect(34, 60, 34+50, 60+26);			rCAM[enON].OffsetRect(0, y);
		rCAM[enOFF] = CRect(34+50, 60, 34+50+50, 60+26);	rCAM[enOFF].OffsetRect(0, y);
		rCPM[enON]  = CRect(134, 60, 134+50, 60+26);		rCPM[enON].OffsetRect(0, y);
		rCPM[enOFF] = CRect(134+50, 60, 134+50+50, 60+26);	rCPM[enOFF].OffsetRect(0, y);

		rAAM[enON]  = CRect(240, 80, 240+15, 80+8);			rAAM[enON].OffsetRect(0, y);
		rAAM[enOFF] = CRect(240+15, 80, 240+15+15, 80+8);	rAAM[enOFF].OffsetRect(0, y);
		rAPM[enON]  = CRect(270, 80, 270+15, 80+8);			rAPM[enON].OffsetRect(0, y);
		rAPM[enOFF] = CRect(270+15, 80, 270+15+15, 80+8);	rAPM[enOFF].OffsetRect(0, y);
		
		rCdelim[enON]	= CRect(0, 60, 0+17, 60+40);		rCdelim[enON].OffsetRect(0, y);
		rCdelim[enOFF]	= CRect(0+17, 60, 0+17+17, 60+40);	rCdelim[enOFF].OffsetRect(0, y);

		rAdelim[enON]	= CRect(400, 60, 400+5, 60+12);		rAdelim[enON].OffsetRect(0, y);
		rAdelim[enOFF]	= CRect(400+5, 60, 400+5+5, 60+12);	rAdelim[enOFF].OffsetRect(0, y);

		rRinger[enON]	= CRect(420, 60, 420+12, 60+14);		rRinger[enON].OffsetRect(0, y);
		rRinger[enOFF]	= CRect(420+12, 60, 420+12+12, 60+14);	rRinger[enOFF].OffsetRect(0, y);
	
		for (int i=0; i<11; i++)
		{
			rClock[i].SetRect(0, 0, 44, 60);
			rClock[i].OffsetRect(44 * i, y);
		}

		for (i=0; i<11; i++)
		{
			rAlarm[i].SetRect(240, 60, 240+14, 60+20);
			rAlarm[i].OffsetRect(14 * i, y);
		}
	}
	
	CRect rCAM[2], rCPM[2], rCdelim[2], rClock[11];
	CRect rAAM[2], rAPM[2], rAdelim[2], rAlarm[11];
	CRect rRinger[2];
} nrc;

class tagWindowRC
{
public:	
	tagWindowRC()
	{
		pCAM = CPoint(52, 31);
		pCPM = CPoint(52, 60);

		pAAM = CPoint(222, 93);
		pAPM = CPoint(222, 102);
		
		pClock[0] = CPoint(105, 28);
		pClock[1] = CPoint(155, 28);
		pCdelim	  = CPoint(200, 38);
		pClock[2] = CPoint(216, 28);
		pClock[3] = CPoint(266, 28);

		pAlarm[0] = CPoint(240, 92);
		pAlarm[1] = CPoint(255, 92);
		pAdelim	  = CPoint(270, 96);
		pAlarm[2] = CPoint(276, 92);
		pAlarm[3] = CPoint(291, 92);

		pRinger	  = CPoint(205, 95);
	}
	
	CPoint pCAM, pCPM, pCdelim, pClock[4];
	CPoint pAAM, pAPM, pAdelim, pAlarm[4];
	CPoint pRinger;
} wrc;

/////////////////////////////////////////////////////////////////////////////
// CAlarmWnd

BEGIN_MESSAGE_MAP(CAlarmWnd, CFrameWnd)
	//{{AFX_MSG_MAP(CAlarmWnd)
	ON_WM_PAINT()
	ON_WM_LBUTTONDOWN()
	ON_WM_NCCALCSIZE()
	ON_WM_LBUTTONDBLCLK()
	ON_WM_CREATE()
	ON_WM_DESTROY()
	ON_WM_TIMER()
	ON_WM_ERASEBKGND()
	ON_COMMAND(ID_OPTIONS, OnOptions)
	ON_WM_RBUTTONDOWN()
	ON_COMMAND(ID_FLOATINGMENU_ALARMACTIVE, OnFloatingmenuAlarmactive)
	ON_UPDATE_COMMAND_UI(ID_FLOATINGMENU_ALARMACTIVE, OnUpdateFloatingmenuAlarmactive)
	ON_COMMAND(ID_FLOATINGMENU_EXIT, OnFloatingmenuExit)
	ON_WM_KEYDOWN()
	ON_COMMAND(ID_FLOATINGMENU_STOPALARM, OnFloatingmenuStopalarm)
	ON_UPDATE_COMMAND_UI(ID_FLOATINGMENU_STOPALARM, OnUpdateFloatingmenuStopalarm)
	ON_WM_MOVE()
	ON_WM_WINDOWPOSCHANGING()
	//}}AFX_MSG_MAP
	ON_MESSAGE(WM_USER_APPLY, OnUserApply)
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CAlarmWnd construction/destruction

extern CAlarmApp *pAlarmApp;

int iAtypes[] = { IDB_ALARM1, IDB_ALARM2, IDB_ALARM3, IDB_ALARM4 };

CAlarmWnd::CAlarmWnd()
         : m_bSecondsDot(FALSE)
		 , m_uiTimer(0)
		 , m_uiTimerAlarm(0)
		 , m_iButtonState(enBUTTONSTART)
		 , m_bSilent(TRUE)							// We don't want any noise when the program starts.
{
	CRect		rc;
	CRgn		wndRgn;
    BITMAP		bm;
	CRect		rDesk;
	int			width, height, x, y;
	CString		sAppName;

	memset(m_iC, 0, sizeof(m_iC) / sizeof(m_iC[0]));
	memset(m_iA, 0, sizeof(m_iA) / sizeof(m_iA[0]));

	m_iAlarmStarted24Hour = -1;
	m_iAlarmStartedMinute = -1;

	m_bmpClock.LoadBitmap(iAtypes[ pAlarmApp->m_iStyle ]);
	m_bmpNumbers.LoadBitmap(IDB_NUMBERS);

	m_bmpClock.GetObject(sizeof(BITMAP), &bm);
	width	= bm.bmWidth;
	height	= bm.bmHeight;
    GetDesktopWindow()->GetWindowRect(&rDesk);
	
	if (pAlarmApp->m_xPos < 0 || pAlarmApp->m_yPos < 0)
	{
		x = (rDesk.Width()/2)-(width/2);
		y = (rDesk.Height()/2)-(height/2);
	}
	else
	{
		x = pAlarmApp->m_xPos;
		y = pAlarmApp->m_yPos;
	}

	rc.SetRect(x, y, x+width, y+height);
	sAppName.LoadString(IDS_APPNAME);

	LOGFONT lf;
	memset(&lf, 0, sizeof(LOGFONT));
	lf.lfHeight = 18;
	strcpy(lf.lfFaceName, "Arial");
	VERIFY(m_fStaticFont.CreateFontIndirect(&lf));

	m_hAccelTable = LoadAccelerators(AfxGetInstanceHandle(), MAKEINTRESOURCE(IDR_ACCELERATOR1));

	DecodeTime(TRUE);											// Force change.
	nrc.Initialize(pAlarmApp->m_bGrayLetters);
	
	CreateEx(WS_EX_TOPMOST,
             AfxRegisterWndClass(CS_DBLCLKS, 
			 ::LoadCursor(NULL, IDC_ARROW), NULL,
			 AfxGetApp()->LoadIcon(IDR_MAINFRAME)),				// Our custom class.
			 "Vekjaraklukka",									// Window title.
			 WS_POPUP | WS_SYSMENU,								// Raw window.
			 rc,												// Screen coordinates.
			 NULL,												// Parent window (NULL == desktop wnd).
			 0,													// Menu ID (0 == no menu).
			 NULL);												// Attached data.

	m_nYOffset = 15;
	m_nXOffset = 15;
}

CAlarmWnd::~CAlarmWnd()
{
}

BOOL CAlarmWnd::PreCreateWindow(CREATESTRUCT& cs)
{
	return CFrameWnd::PreCreateWindow(cs);
}

/////////////////////////////////////////////////////////////////////////////
// CAlarmWnd diagnostics

#ifdef _DEBUG
void CAlarmWnd::AssertValid() const
{
	CFrameWnd::AssertValid();
}

void CAlarmWnd::Dump(CDumpContext& dc) const
{
	CFrameWnd::Dump(dc);
}

#endif //_DEBUG

/////////////////////////////////////////////////////////////////////////////
// CAlarmWnd message handlers

void CAlarmWnd::OnPaint() 
{
	CPaintDC dc(this); // device context for painting

	BITMAP	bm;
	CBitmap *pOldBmp;
	CDC		dcMem;
	CRect	rect;
	int		s;
	
	dcMem.CreateCompatibleDC(&dc);
	
	/*
		Start blitting the images.

		Blit the frame of the alarm.
	*/
	pOldBmp = dcMem.SelectObject(&m_bmpClock);
	m_bmpClock.GetObject(sizeof(BITMAP), &bm);
	dc.BitBlt(0, 0, bm.bmWidth, bm.bmHeight, &dcMem, 0, 0, SRCCOPY);

	dcMem.SelectObject(&m_bmpNumbers);
	m_bmpNumbers.GetObject(sizeof(BITMAP), &bm);

	
	/*
		Blit the AM/PM letters (on / off).	
	*/
	s = bClockAM ? enON : enOFF;
	if (! pAlarmApp->m_b12HourBase) s = enOFF;
	dc.BitBlt(wrc.pCAM.x, wrc.pCAM.y, nrc.rCAM[s].Width(), nrc.rCAM[s].Height(), &dcMem, nrc.rCAM[s].left, nrc.rCAM[s].top, SRCCOPY);

	s = bClockAM ? enOFF : enON;
	if (! pAlarmApp->m_b12HourBase) s = enOFF;
	dc.BitBlt(wrc.pCPM.x, wrc.pCPM.y, nrc.rCPM[s].Width(), nrc.rCPM[s].Height(), &dcMem, nrc.rCPM[s].left, nrc.rCPM[s].top, SRCCOPY);


	/*
		Blit all four digits on the screen including the two dots.	
	*/
	ASSERT(m_iC[0] > 0 || m_iC[0] < 10);
	ASSERT(m_iC[1] > 0 || m_iC[1] < 10);	
	ASSERT(m_iC[2] > 0 || m_iC[2] < 10);
	ASSERT(m_iC[3] > 0 || m_iC[3] < 10);

	dc.BitBlt(wrc.pClock[0].x, wrc.pClock[0].y, nrc.rClock[m_iC[0]].Width(), nrc.rClock[m_iC[0]].Height(), &dcMem, nrc.rClock[m_iC[0]].left, nrc.rClock[m_iC[0]].top, SRCCOPY);
	dc.BitBlt(wrc.pClock[1].x, wrc.pClock[1].y, nrc.rClock[m_iC[1]].Width(), nrc.rClock[m_iC[1]].Height(), &dcMem, nrc.rClock[m_iC[1]].left, nrc.rClock[m_iC[1]].top, SRCCOPY);

	{
		s = m_bSecondsDot ? enON : enOFF;
		dc.BitBlt(wrc.pCdelim.x, wrc.pCdelim.y, nrc.rCdelim[s].Width(), nrc.rCdelim[s].Height(), &dcMem, nrc.rCdelim[s].left, nrc.rCdelim[s].top, SRCCOPY);
	}

	dc.BitBlt(wrc.pClock[2].x, wrc.pClock[2].y, nrc.rClock[m_iC[2]].Width(), nrc.rClock[m_iC[2]].Height(), &dcMem, nrc.rClock[m_iC[2]].left, nrc.rClock[m_iC[2]].top, SRCCOPY);
	dc.BitBlt(wrc.pClock[3].x, wrc.pClock[3].y, nrc.rClock[m_iC[3]].Width(), nrc.rClock[m_iC[3]].Height(), &dcMem, nrc.rClock[m_iC[3]].left, nrc.rClock[m_iC[3]].top, SRCCOPY);


	/*
		Blit alarm digits.
	*/
	dc.BitBlt(wrc.pAlarm[0].x, wrc.pAlarm[0].y, nrc.rAlarm[m_iA[0]].Width(), nrc.rAlarm[m_iA[0]].Height(), &dcMem, nrc.rAlarm[m_iA[0]].left, nrc.rAlarm[m_iA[0]].top, SRCCOPY);
	dc.BitBlt(wrc.pAlarm[1].x, wrc.pAlarm[1].y, nrc.rAlarm[m_iA[1]].Width(), nrc.rAlarm[m_iA[1]].Height(), &dcMem, nrc.rAlarm[m_iA[1]].left, nrc.rAlarm[m_iA[1]].top, SRCCOPY);
	
	{
		s = pAlarmApp->m_bAlarmActive ? enON : enOFF;
		dc.BitBlt(wrc.pAdelim.x, wrc.pAdelim.y, nrc.rAdelim[s].Width(), nrc.rAdelim[s].Height(), &dcMem, nrc.rAdelim[s].left, nrc.rAdelim[s].top, SRCCOPY);
	}
	
	dc.BitBlt(wrc.pAlarm[2].x, wrc.pAlarm[2].y, nrc.rAlarm[m_iA[2]].Width(), nrc.rAlarm[m_iA[2]].Height(), &dcMem, nrc.rAlarm[m_iA[2]].left, nrc.rAlarm[m_iA[2]].top, SRCCOPY);
	dc.BitBlt(wrc.pAlarm[3].x, wrc.pAlarm[3].y, nrc.rAlarm[m_iA[3]].Width(), nrc.rAlarm[m_iA[3]].Height(), &dcMem, nrc.rAlarm[m_iA[3]].left, nrc.rAlarm[m_iA[3]].top, SRCCOPY);
	
	
	s = bAlarmAM ? enON : enOFF;
	if (! pAlarmApp->m_bAlarmActive) s = enOFF;
	if (! pAlarmApp->m_b12HourBase) s = enOFF;
	dc.BitBlt(wrc.pAAM.x, wrc.pAAM.y, nrc.rAAM[s].Width(), nrc.rAAM[s].Height(), &dcMem, nrc.rAAM[s].left, nrc.rAAM[s].top, SRCCOPY);
	
	s = bAlarmAM ? enOFF : enON;
	if (! pAlarmApp->m_bAlarmActive) s = enOFF;
	if (! pAlarmApp->m_b12HourBase) s = enOFF;
	dc.BitBlt(wrc.pAPM.x, wrc.pAPM.y, nrc.rAPM[s].Width(), nrc.rAPM[s].Height(), &dcMem, nrc.rAPM[s].left, nrc.rAPM[s].top, SRCCOPY);

	s = pAlarmApp->m_bAlarmActive ? enON : enOFF;
	if (! pAlarmApp->m_b12HourBase) s = enOFF;
	dc.BitBlt(wrc.pRinger.x, wrc.pRinger.y, nrc.rRinger[s].Width(), nrc.rRinger[s].Height(), &dcMem, nrc.rRinger[s].left, nrc.rRinger[s].top, SRCCOPY);
	
	dc.SelectObject(pOldBmp);
}

void CAlarmWnd::UpdateTime(BOOL bSilent /*=FALSE*/)
{
	CRect rect;
	
	DecodeTime();
	
	if (m_iClockSecond != pAlarmApp->m_iClockSecond)
	{
		pAlarmApp->m_iClockSecond = m_iClockSecond;
		
		if (m_bSecondsDot)
			m_bSecondsDot = FALSE;
		else
			m_bSecondsDot = TRUE;
	
		rect.SetRect(wrc.pCdelim.x, wrc.pCdelim.y, wrc.pCdelim.x + nrc.rCdelim[0].Width(), wrc.pCdelim.y + nrc.rCdelim[0].Height());
		InvalidateRect(rect);
	}
	
	if (bCAM != bClockAM)
	{
		bClockAM = bCAM;
		rect.SetRect(wrc.pCAM.x, wrc.pCAM.y, wrc.pCAM.x + nrc.rCAM[0].Width(), wrc.pCAM.y + (nrc.rCAM[0].Height()*2));
		InvalidateRect(rect);
	}
	
	if ((m_iClock24Hour != pAlarmApp->m_iClock24Hour) || (m_iClockMinute != pAlarmApp->m_iClockMinute))
	{
		pAlarmApp->m_iClock24Hour = m_iClock24Hour;
		pAlarmApp->m_iClockMinute = m_iClockMinute;
	
		if (iC[0] != m_iC[0])
		{
			m_iC[0] = iC[0];
			rect.SetRect(wrc.pClock[0].x, wrc.pClock[0].y, wrc.pClock[0].x + nrc.rClock[0].Width(), wrc.pClock[0].y + nrc.rClock[0].Height());
			InvalidateRect(rect);
		}
	
		if (iC[1] != m_iC[1])
		{
			m_iC[1] = iC[1];
			rect.SetRect(wrc.pClock[1].x, wrc.pClock[1].y, wrc.pClock[1].x + nrc.rClock[1].Width(), wrc.pClock[1].y + nrc.rClock[1].Height());
			InvalidateRect(rect);
		}
	
		if (iC[2] != m_iC[2])
		{
			m_iC[2] = iC[2];
			rect.SetRect(wrc.pClock[2].x, wrc.pClock[2].y, wrc.pClock[2].x + nrc.rClock[2].Width(), wrc.pClock[2].y + nrc.rClock[2].Height());
			InvalidateRect(rect);
		}
	
		if (iC[3] != m_iC[3])
		{
			m_iC[3] = iC[3];
			rect.SetRect(wrc.pClock[3].x, wrc.pClock[3].y, wrc.pClock[3].x + nrc.rClock[3].Width(), wrc.pClock[3].y + nrc.rClock[3].Height());
			InvalidateRect(rect);
		}
	
		if (pAlarmApp->m_bSpeakClock && !bSilent)
			CheckForSpeech(m_iClock24Hour, m_iClockMinute);
	}

	if (/*(bAAM != bAlarmAM) || */(iA[0] != m_iA[0]) || (iA[1] != m_iA[1]) || (iA[2] != m_iA[2]) || (iA[3] != m_iA[3]))
	{
		bAlarmAM = bAAM;
		
		m_iA[0] = iA[0];
		m_iA[1] = iA[1];
		m_iA[2] = iA[2];
		m_iA[3] = iA[3];
		
		InvalidateRect(CRect(200, 90, 200+110, 90+20));	// Invalidates the alarm area.
	}
}