|
|
/*
* Windows Calendar * Copyright (c) 1985 by Microsoft Corporation, all rights reserved. * Written by Mark L. Chamberlin, consultant to Microsoft. **/
/*
***** ***** calalarm.c ******/
#include "cal.h"
/**** FAlarm - return TRUE if the ln has an alarm set. */
BOOL APIENTRY FAlarm (INT ln)
{
BOOL fAlarm; WORD otqr;
fAlarm = FALSE; if ((otqr = vtld [ln].otqr) != OTQRNIL) { fAlarm = ((PQR )(PbTqrLock () + otqr)) -> fAlarm; DrUnlockCur (); } return (fAlarm); }
/**** AlarmToggle - Here on Alarm Set command.
Since the command is only enabled when the focus in on an ln, we know that all we need to do is toggle the alarm state for the ln that has the focus.*/
VOID APIENTRY AlarmToggle ()
{
QR qrNew; WORD otqr; register PQR pqr; TM tm; RECT rect; BOOL fAlarm; BOOL fEmpty; register INT ln; DT dt; INT itdd; FT ftTemp; DR *pdr;
if ((otqr = vtld [ln = vlnCur].otqr) == OTQRNIL) { /* There is no QR for this ln, so we know that it can't
have an alarm set. We create a QR for it with the alarm flag set. */ qrNew.cb = CBQRHEAD + 1; fAlarm = qrNew.fAlarm = TRUE; qrNew.fSpecial = FALSE; qrNew.tm = tm = vtld [ln].tm; qrNew.qd [0] = '\0';
/* Since we know there
was no old QR, we know FSearchTqr will not find a match - so we ignore it's return value. We call it to set up the insertion point in votqrNext. */ FSearchTqr (tm);
/* If there's not enough room to insert the new QR,
then the alarm cannot get set, so we don't want to alter cAlarm (or any of the other stuff that gets altered if the QR is inserted). Note that FinsertQr puts up the alert. */ if (!FInsertQr (votqrNext, &qrNew)) return;
vtld [ln].otqr = votqrNext;
/* Adjust up the otqrs in the tld beyond the current ln. */ AdjustOtqr (ln, CBQRHEAD + 1); }
else
{ /* There is a QR for this ln. Toggle its alarm flag. */ pqr = (PQR )(PbTqrLock () + otqr); fAlarm = pqr -> fAlarm = !pqr -> fAlarm; fEmpty = !fAlarm && !pqr -> fSpecial && pqr -> cb == CBQRHEAD + 1; DrUnlockCur ();
if (fEmpty) { /* We can get rid of this QR now since it has no flags
set and it has a null appointment description. */ DeleteQr (otqr); vtld [ln].otqr = OTQRNIL;
/* Adjust down the otqrs in the tld beyond the current ln. */ AdjustOtqr (ln, -(int)(CBQRHEAD + 1)); } }
/* Get rid of or display the alarm bell icon. */ rect.top = YcoFromLn (ln); rect.bottom = rect.top + vcyLineToLine; rect.right = (rect.left = vxcoBell) + vcxBell; InvalidateRect (vhwnd2B, (LPRECT)&rect, TRUE); UpdateWindow (vhwnd2B);
/* Set the dirty flags, and adjust the count of alarms for this date. */ (pdr = PdrLockCur ()) -> fDirty = vfDirty = TRUE; dt = pdr -> dt; DrUnlockCur (); FSearchTdd (dt, &itdd); (TddLock () + itdd) -> cAlarms += fAlarm ? 1 : -1; TddUnlock ();
ftTemp.dt = dt; ftTemp.tm = vtld [ln].tm; if (fAlarm) { /* Setting an alarm. */ if (CompareFt (&ftTemp, &vftAlarmNext) == -1 && CompareFt (&ftTemp, &vftCur) > -1) { /* The alarm being set is less than the next armed alarm
and it is greater than or equal to the current time. Make it the next alarm, and see if it needs to go off right now. (Waiting for it to go off "naturally" could result in its being a minutue too late since the alarms are only checked when the minute changes.) */ vftAlarmNext = ftTemp; AlarmCheck (); } } else { /* Cancelling an alarm. */ if (CompareFt (&ftTemp, &vftAlarmNext) == 0) { /* Cancelling the next armed alarm. Need to arm the one
after it. Since the one we are cancelling has not yet gone off, it can't be time for the one after it to go off either, so there is no need to call AlarmCheck - just let it go off naturally. */ GetNextAlarm (&vftCur, &vftCur, TRUE, NULL); } } }
/**** ProcessAlarms */
VOID APIENTRY FAR uProcessAlarms ()
{ static BOOL vfLocked = FALSE;
/* This routine is locked to prevent reentry. This is done to prevent
an alarm dialog from getting put up on top of another one. In addition to being less confusing for the user, this avoids the nasty problems of running out of resources (such as stack and heap). The reason that reentry may occur is that we arm the next alarm in the process of putting up the dialog, and while the dialog is waiting for input, timer messages can come in and the next alarm can be triggered. This is a desirable feature since it means the user still hears the audible alarm and we flash the window if the next alarm goes off before the OK button is pressed for the current alarm dialog (a likely scenario if the user is not at the machine but left it with the focus on Calendar). As soon as the user pushes the OK button for the current dialog, another dialog will be put up to show the new alarms. This is done by looping here until there are no new alarms. */
/* Only enter if the routine is not locked. */ if (!vfLocked) { /* Lock this routine to prevent reentry. */ vfLocked = TRUE;
/* vftAlarmFirst.dt will get set to DTNIL when the next alarm
gets armed (during the ACKALARMS dialog). If that alarm gets triggered while the dialog box is up, vdtAlarmFirst will get set to that alarm time by AlarmCheck. We continue putting up dialog boxes as long as alarms go off while the previous one is up. */ while (vftAlarmFirst.dt != DTNIL) { /* Quit flashing. */ StartStopFlash (FALSE);
if (vfMustSyncAlarm) { /* The system clock was changed so we need to
resynchronize the alarms. Tell the user about it. */ AlertBox (vszAlarmSync, (CHAR *)NULL, MB_SYSTEMMODAL | MB_OK | MB_ICONEXCLAMATION);
/* Now that the user has had his last chance to mess
with the clock (could have changed it again during the application modal alert), reset the flag. We will resync to the latest time that's been read by CalTimer. */ vfMustSyncAlarm = FALSE;
/* Arm the first alarm >= the current time. */ GetNextAlarm (&vftCur, &vftCur, TRUE, NULL);
/* Say there are no unacknowledged alarms. */ vftAlarmFirst.dt = DTNIL;
/* See if the alarm must go off immediately. If so,
AlarmCheck will make vftAlarmFirst something other than DTNIL, so this loop will continue. */ AlarmCheck(); } else { /* Show the alarms that have been triggered, returning
here after the user presses the OK button. */ FDoDialog (IDD_ACKALARMS); } }
/* Unlock this routine. */ vfLocked = FALSE; } }
/**** FnAckAlarms */
INT_PTR CALLBACK FnAckAlarms ( HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
FT ftTemp;
switch (message) { case WM_INITDIALOG: /* Remember the window handle of the dialog for AlertBox. */ vhwndDialog = hwnd;
/* Fill the list box, and arm the next alarm. The first
alarm to put in the list box is the first unacknowledged one (which is in vftAlarmFirst). The next alarm to arm (the one following the last one to go into the list box), is the first one > the current time + the early ring period. Since GetNextAlarm works with >=, add one more than the early ring period. */ ftTemp = vftCur; AddMinsToFt (&ftTemp, vcMinEarlyRing + 1); GetNextAlarm (&vftAlarmFirst, &ftTemp, TRUE, hwnd);
/* Say there are no unacknowledged alarms. Note that
there has not been an opportunity for the alarm just armed by GetNextAlarm to be triggered, since the last thing that routine does is arm the alarm so no error dialogs could have occurred after arming, and consequently we could not have yielded and processed a timer message. */ vftAlarmFirst.dt = DTNIL; return (TRUE);
case WM_COMMAND: if (GET_WM_COMMAND_ID(wParam, lParam) == IDOK) { EndDialog (hwnd, TRUE); return (TRUE); } /* Fall into default case if WM_COMMAND is not from IDOK. */ default: /* Tell Windows we did not process the message. */ return (FALSE); } }
/**** GetNextAlarm */
VOID APIENTRY FAR GetNextAlarm (
FT *pftStart, /* Start looking at alarms >= this. */ FT *pftStop, /* Stop when find alarm >= this. If an alarm >=
this is found, arm it. */ BOOL fDisk, /* Ok to read from disk if this is TRUE. If FALSE,
give up if the next alarm is not in memory. */ HWND hwnd) /* If not null, use this handle to send the triggered
alarms to the list box in the alarm acknowledgement dialog box. */ {
/* Need enough space for a time sz (we overwrite the terminating 0
with a space), a maximum length appointment description, and a terminating 0. */ CHAR rgchAlarm [CCHTIMESZ + CCHQDMAX + 1]; INT itdd; INT cch; DD *pdd; FT ftTemp; FT ftStart; FT ftStop; INT cAlarms; DL dl; register WORD idr; register PQR pqr; WORD idrFree;
/* This could take some time if we hit the disk. */ HourGlassOn();
/* Make local copies of the FTs we were passed pointers to so we
don't overwrite them (suppose we are passed a pointer to vftAlarmNext for example). */ ftStart = *pftStart; ftStop = *pftStop;
/* Say there is no next alarm. */ vftAlarmNext.dt = DTNIL;
/* Find a free DR in case we need to read in from disk. */ idrFree = IdrFree ();
for (FSearchTdd (ftStart.dt, &itdd); itdd < vcddUsed; itdd++) { pdd = TddLock () + itdd; ftTemp.dt = pdd -> dt; cAlarms = pdd -> cAlarms; dl = pdd -> dl; idr = pdd -> idr; TddUnlock ();
if (cAlarms == 0) continue;
if (idr == IDRNIL) { /* The next alarm is not in memory. If we're not supposed
to hit the disk, we've done all we can do. */ if (!fDisk) goto Exit0;
/* Note - since cAlarms was not zero, there must be some
data for this date somewhere. It isn't in memory, so it must be on disk. Therefore, dl cannot be DLNIL, so we don't need check to see if it is. */ ReadTempDr (idr = idrFree, dl); }
pqr = (PQR)PbTqrFromPdr(PdrLock(idr));
for ( ; cAlarms; pqr = (PQR )((BYTE *)pqr + pqr -> cb)) { if (pqr -> fAlarm) { cAlarms--;
/* Remember the time of the alarm. */ ftTemp.tm = pqr -> tm;
if (CompareFt (&ftTemp, &ftStart) != -1) { /* This ft is greater than or equal to ftStart. */ if (CompareFt (&ftTemp, &ftStop) != -1) { /* This ft is greater than or equal
to ftStop, so this is the next alarm. */ vftAlarmNext = ftTemp; DrUnlock (idr); goto Exit0; }
/* This is a triggered alarm, so put it into the
list box of the alarm acknowledgement dialog box. */ if (hwnd != NULL) { cch = GetTimeSz(pqr -> tm, rgchAlarm); rgchAlarm[cch] = ' '; lstrcpy(&rgchAlarm[cch + 1], pqr -> qd); if (SendDlgItemMessage (hwnd, IDCN_LISTBOX, LB_ADDSTRING, 0, (LPARAM)rgchAlarm) == LB_ERRSPACE) { /* ??? Not enough memory. Be sure to unlock
if bail out due to this error. */ } } } } }
DrUnlock (idr);
}
/* End of tdd reached - there is no next alarm. */Exit0: HourGlassOff ();
}
/**** IdrFree - find a free DR. */
WORD APIENTRY IdrFree ()
{
register WORD idr; register DT dt;
/* Find a free DR to read the date into. There is guaranteed
to be at least one free one since there are 3 and we keep at most 2 dates in memory at one time, so finding a free one will terminate this loop with idr containing the index of the free DR. */ idr = CDR; do { idr--; dt = PdrLock(idr)->dt; DrUnlock (idr); } while (dt != DTNIL);
return (idr);
}
/**** ReadTempDr - read date into DR for temporary use. */
VOID APIENTRY ReadTempDr ( WORD idr, DL dl) {
register DR *pdr;
pdr = PdrLock (idr);
if (!FReadDrFromFile (TRUE, pdr, dl)) { /* ??? Error trying to read date - what now? */ }
/* Make the DR still look free since we are only using it
temporarily. */ pdr -> dt = DTNIL; DrUnlock (idr);
}
/**** StartStopFlash */
VOID APIENTRY StartStopFlash (BOOL fStart) /* FALSE means stop flashing, TRUE means start flashing. */ { if (fStart != vfFlashing) FlashWindow (vhwnd0, vfFlashing = fStart); }
|
