|
|
/*
* Windows Calendar * Copyright (c) 1985 by Microsoft Corporation, all rights reserved. * Written by Mark L. Chamberlin, consultant to Microsoft. **/
/*
***** ***** caltqr.c ******/
#include "cal.h"
/**** FSearchTqr */
BOOL APIENTRY FSearchTqr (TM tm) {
BYTE *pbPrev; BYTE *pbCur; BYTE *pbNext; BYTE *pbFirst; BYTE *pbMax; BOOL fFound; DR *pdr;
pdr = PdrLockCur (); votqrPrev = votqrCur = OTQRNIL; votqrNext = pdr -> cbTqr; pbMax = (pbCur = pbFirst = PbTqrFromPdr (pdr)) + pdr -> cbTqr; fFound = FALSE;
while (pbCur < pbMax) { pbNext = pbCur + ((PQR )pbCur) -> cb;
if (((PQR )pbCur) -> tm == tm) { votqrCur = (WORD)(pbCur - pbFirst); votqrNext = (WORD)(pbNext - pbFirst); fFound = TRUE; break; }
else if (((PQR )pbCur) -> tm > tm) { votqrNext = (WORD)(pbCur - pbFirst); break; }
pbPrev = pbCur; pbCur = pbNext;
}
if (pbCur != pbFirst) votqrPrev = (WORD)(pbPrev - pbFirst);
DrUnlockCur (); return (fFound); }
/**** StoreQd - Move the appointment description from the edit control
into the tqr. No need to check for room in DR here since we have been monitoring key strokes and checking for room.*/
VOID APIENTRY StoreQd ()
{
BYTE rgbQrBuf [CBQRHEAD + CCHQDMAX + 1]; CHAR szqdOld [CCHQDMAX + 1]; INT cchqdOld; INT cchqdNew; WORD otqr; BYTE *pb; BOOL fSame; register INT ln;
/* Copy into register variable to save code. */ ln = vlnCur;
/* Fetch the text from the edit control. */ cchqdNew = (int)SendMessage (vhwnd3, WM_GETTEXT, CCHQDMAX + 1, (LPARAM)(rgbQrBuf + CBQRHEAD));
*szqdOld = '\0'; cchqdOld = 0; pb = PbTqrLock (); if ((otqr = vtld [ln].otqr) != OTQRNIL) { cchqdOld = ((PQR )(pb + otqr)) -> cb - CBQRHEAD - 1; lstrcpy (szqdOld, (CHAR *)(pb + otqr + CBQRHEAD)); } fSame = cchqdOld == cchqdNew && lstrcmp ((LPSTR)szqdOld, (LPSTR)(rgbQrBuf + CBQRHEAD)) == 0; DrUnlockCur (); if (fSame) { /* This thing hasn't changed, so don't waste alot of time. */ return; }
/* The QD has changed, so mark the DR and the file dirty. */ PdrLockCur () -> fDirty = vfDirty = TRUE; DrUnlockCur ();
if (otqr == OTQRNIL) { /* There was no previous QR. Say there is no alarm set,
say it's not a special time, and copy in the appointment time from the tld. */ ((PQR )rgbQrBuf) -> fAlarm = ((PQR )rgbQrBuf) -> fSpecial = FALSE; ((PQR )rgbQrBuf) -> tm = vtld [ln].tm; } else { /* There was a previous QR. Copy it's header information
(we want the flags and the appointment time) into the new QR we're building. */ BltByte (PbTqrLock () + otqr, rgbQrBuf, CBQRHEAD); DrUnlockCur ();
/* Delete the old QR. */ DeleteQr (otqr);
/* In case we don't insert a new qr. */ vtld [ln].otqr = OTQRNIL;
/* Adjust down the otqrs in the tld beyond the current ln. */ AdjustOtqr (ln, -((PQR )rgbQrBuf) -> cb); }
/* Set the length of the new QR. */ ((PQR )rgbQrBuf) -> cb = (WORD)(CBQRHEAD + cchqdNew + 1);
if (cchqdNew != 0 || ((PQR )rgbQrBuf) -> fAlarm || ((PQR )rgbQrBuf) -> fSpecial) { if (otqr == OTQRNIL) { /* There was no previous QR, so search the tqr to find
out where to put the new one. Since we know there was no old QR, we know FSearchTqr will not find a match - so we ignore its return value. */ FSearchTqr (vtld [ln].tm); otqr = votqrNext; }
FInsertQr (otqr, (PQR )rgbQrBuf); vtld [ln].otqr = otqr;
/* Adjust up the otqrs in the tld beyond the current ln. */ AdjustOtqr (ln, ((PQR )rgbQrBuf) -> cb);
} }
/**** AdjustOtqr */
VOID APIENTRY AdjustOtqr ( INT ln, /* otqr starting with vtld [ln + 1] are adjusted. */ INT cb) /* The amount to adjust the otqr by (can be negative). */ { while (++ln < vcln) { if (vtld [ln].otqr != OTQRNIL) vtld [ln].otqr += (WORD)cb; } }
/**** DeleteQr - delete qr from tqr. */
VOID APIENTRY DeleteQr (WORD otqr) {
BYTE *pbTqr; BYTE *pbSrc; BYTE *pbDst; WORD cb; DR *pdr;
pdr = PdrLockCur (); pbDst = (pbTqr = PbTqrFromPdr (pdr)) + otqr; pbSrc = pbDst + (cb = ((PQR )pbDst) -> cb); BltByte (pbSrc, pbDst, (WORD)(pbTqr + pdr -> cbTqr - pbSrc)); pdr -> cbTqr -= cb; DrUnlockCur ();
}
/**** FInsertQr - insert qr into tqr. */
BOOL APIENTRY FInsertQr ( WORD otqr, PQR pqr) {
BYTE *pbTqr; register BYTE *pbSrc; BYTE *pbDst; WORD cb; register DR *pdr; BOOL fOk;
/* Make sure there's enough room. */ pdr = PdrLockCur (); if ((WORD)(fOk = cb = pqr->cb) <= (WORD)(CBTQRMAX - pdr -> cbTqr)) { /* Zero the unused bits. */ pqr -> reserved = 0;
pbSrc = (pbTqr = PbTqrFromPdr (pdr)) + otqr; pbDst = pbSrc + cb; BltByte (pbSrc, pbDst, (WORD)(pbTqr + pdr -> cbTqr - pbSrc)); BltByte ((BYTE *)(pqr), pbSrc, cb); pdr -> cbTqr += cb; } else { /* Tell the user the date is full. */ AlertBox (vszDateIsFull, (CHAR *)NULL, MB_APPLMODAL | MB_OK | MB_ICONEXCLAMATION); }
DrUnlockCur (); return (fOk);
}
/**** PbTqrLock - Lock the current DR, returning a pointer to the first
byte of the embedded Tqr.*/
BYTE * APIENTRY PbTqrLock ()
{
register DR *pdr;
pdr = PdrLockCur (); return (PbTqrFromPdr (pdr));
}
/**** PdrLockCur - Lock the current DR, returning a pointer to it. */
DR * APIENTRY PdrLockCur ()
{
return (PdrLock (vidrCur));
}
/**** DrUnlockCur - Unlock the current DR. */
VOID APIENTRY DrUnlockCur ()
{
DrUnlock (vidrCur);
}
/**** PdrLock - lock and return a pointer to the specified DR. */
DR * APIENTRY PdrLock (UINT idr) { return ((DR *)LocalLock (vrghlmDr [idr])); }
/**** DrUnlock - unlock the specified DR. */
VOID APIENTRY DrUnlock (UINT idr) { LocalUnlock (vrghlmDr [idr]); }
/**** PbTqrFromPdr - Given a pdr, return a pointer to the first byte
of the embedded tqr.*/
BYTE * APIENTRY PbTqrFromPdr (DR*pdr) { return ((BYTE *)pdr + CBDRHEAD + pdr -> cbNotes); }
/**** StoreNotes - store the notes into the DR.
No need to check for room in DR here since we have been monitoring key strokes and checking for room.*/
VOID APIENTRY StoreNotes ()
{
BYTE rgbEcNotes [CBNOTESMAX]; CHAR *szNew; CHAR *szOld; register INT cbNew; INT cbMore; register DR *pdr; BOOL fFormatted;
/* Set up a pointer to the old notes, using the null string if there
were no old notes. Also assume the new notes are empty. */ szNew = szOld = ""; pdr = PdrLockCur (); if (pdr -> cbNotes != 0) szOld = (CHAR *)((BYTE *)pdr + CBDRHEAD);
/* Format the new text. This inserts <CR,CR,LF> where soft line breaks
are. (Hard line breaks are represented by <CR,LF>.) */ fFormatted = (BOOL)SendMessage (vhwnd2C, EM_FMTLINES, TRUE, 0L);
/* Find out how long the text is (not including the string
terminator). */ cbNew = (int)SendMessage (vhwnd2C, WM_GETTEXTLENGTH, 0, 0L);
if (cbNew != 0) { /* String is not null - will need an extra byte to store the zero
terminator (which is why we ++cbNew here). */ SendMessage (vhwndFocus, WM_GETTEXT, ++cbNew, (LPARAM)(szNew = rgbEcNotes)); }
/* If the notes have not changed don't mark the DR dirty or store the
new (unchanged) text. (For speed, don't strcmp if length not same.) */ if ((cbMore = cbNew - pdr -> cbNotes) != 0 || lstrcmp ((LPSTR)szOld, (LPSTR)szNew) != 0) { /* Adjust the hole for the notes if necessary by moving the tqr
up or down. Note that the same length case works OK too. */ BltByte (PbTqrFromPdr (pdr), PbTqrFromPdr (pdr) + cbMore, pdr -> cbTqr);
/* Copy in the new string. Note - can't copy to szOld since
it is not in the DR if the old string was null. */ BltByte ((BYTE *)szNew, (BYTE *)pdr + CBDRHEAD, cbNew);
/* Set the new length. */ pdr -> cbNotes = (WORD)cbNew;
/* Mark the DR and the file dirty. */ pdr -> fDirty = vfDirty = TRUE; }
DrUnlockCur ();
/* Remove soft line breaks. */ if (fFormatted) SendMessage (vhwnd2C, EM_FMTLINES, FALSE, 0L);
}
/**** SetNotesEc - Set the text of the notes edit control. */
VOID APIENTRY SetNotesEc ()
{ register CHAR *szNotes; register DR *pdr;
szNotes = ""; if ((pdr = PdrLockCur ()) -> cbNotes != 0) szNotes = (CHAR *)((BYTE *)pdr + CBDRHEAD); SetEcText(vhwnd2C, szNotes); DrUnlockCur ();
/* Length of text in edit ctl will probably be different than cbNotes
since formatting info has been removed. Set selection to end of text based on new length. */
}
/**** EcNotification - handle notifications from edit controls.
Note - all of the vcbEcTextMax code assumes that the data in the DR is up-to-date. This is the case as long as my assumption that you can't get an EN_SETFOCUS for the same edit control without having seen an EN_KILLFOCUS in the intervening time. (The KILLFOCUS will bring the DR up-to-date because that's when we store the data.)*/
INT vcbEcTextMax = 32767; /* This is the maximum number of bytes we can
allow the text of the edit control to grow to. This does NOT include the zero terminator, only the space used by the text itself. We reserve space for the terminator outside of this count. Keep it set very large when not otherwise set up so an EN_CHANGE (which can come in from a WM_SETTEXT for example) won't erroneously trigger a DR full situation. */
VOID APIENTRY EcNotification ( WORD idec, /* ID of the edit control. */ WORD en) /* The notification code. */ {
register DR *pdr; WORD otqr; register BOOL fQd;
if ((fQd = idec == IDECQD) || idec == IDECNOTES) { switch (en) { case EN_SETFOCUS: if (fQd) { vhwndFocus = vhwnd3;
/* Assuming there is no QR for this appointment time,
we will need room to insert one (CBQRHEAD + 1 (for the string terminator)). Subtract this from the available space for the tqr to grow to determine the maximum size we can allow for the edit control text. (The available space is given by CBTQRMAX - cbTqr.) */ pdr = PdrLockCur (); vcbEcTextMax = CBTQRMAX - CBQRHEAD - 1 - pdr -> cbTqr; if ((otqr = vtld [vlnCur].otqr) != OTQRNIL) { /* There is already a QR for this appointment
time, so the space it's occupying will also be available. */ vcbEcTextMax += ((PQR )(PbTqrFromPdr (pdr) + otqr)) -> cb; } DrUnlockCur ();
/* Don't allow vcbEcTextMax to be negative (which
it could be right now if there's no QR for this appointment and the amount of free space for the tqr is less than CBQRHEAD + 1). By setting it to zero we will prevent any characters from being typed, and the pruning process will work correctly (which it wouldn't for a negative value). */ if (vcbEcTextMax < 0) vcbEcTextMax = 0; } else { vhwndFocus = vhwnd2C;
/* The notes edit control is not allowed to grow
beyond CBNOTESTESTMAX bytes. */ vcbEcTextMax = CBNOTESTEXTMAX; }
break;
case EN_KILLFOCUS: /* Put big value in while not in use. */ vcbEcTextMax = 32767;
if (fQd) { /* Leaving appointment edit control - store away
the text if it has changed. */ StoreQd (); } else { /* Leaving notes edit control - store away the
text if it has changed. */ StoreNotes (); }
break;
case EN_ERRSPACE: AlertBox (vszOutOfMemory, (CHAR *) NULL, MB_APPLMODAL | MB_OK | MB_ICONEXCLAMATION); break;
case EN_MAXTEXT: AlertBox (vszTextTruncated, (CHAR *) NULL, MB_APPLMODAL | MB_OK | MB_ICONEXCLAMATION); break;
case EN_CHANGE: /* If this change is not for the edit control that has
the focus, ignore it. (This happens for example when we have set the focus to a QD and then set the text of the notes - as when switching to a new date.) If we didn't ignore it we would be comparing the wrong lengths against each other. Also check out of here if we haven't exceeded the maximum text length yet. */ if (vhwndFocus == (fQd ? vhwnd3 : vhwnd2C) && ((INT)SendMessage (vhwndFocus, WM_GETTEXTLENGTH,0,0L) > vcbEcTextMax)) PruneEcText ();
/* Fall into the return. */ } } }
/**** PruneEcText - truncate edit control text since it won't fit in the DR.
This is a separate routine so that the large buffer on the stack would not be allocated in EcNotification. This is because EcNotification gets called recursively (because WM_SETTEXT causes an EN_CHANGE) and it also calls StoreNotes which also uses a large buffer on the stack.*/
VOID APIENTRY PruneEcText ()
{
BYTE rgbEcTextBuf [CBNOTESMAX]; register BYTE *pbCur; INT cbEcText; INT cbTemp;
/* That last change made the text too big to fit in
the DR. Truncate the text, and tell the user about it. */ SendMessage (vhwndFocus, WM_GETTEXT, CBNOTESMAX, (LPARAM)rgbEcTextBuf);
/* Truncate what doesn't fit, being careful not
to truncate in the middle of a multi-byte character (Kanji). Note that this loop is guaranteed to execute at least once (since 0 has to be <= vcbEcTectMax), so cbEcText will definitely get set. */ for (pbCur = rgbEcTextBuf; (cbTemp = (int)(pbCur - rgbEcTextBuf)) <= vcbEcTextMax; pbCur = (BYTE *)AnsiNext ((LPSTR)pbCur)) cbEcText = cbTemp;
/* cbEcText now contains the count of bytes in the
the characters that would fit (not including the string terminator). Put in the terminator. */ rgbEcTextBuf [cbEcText] = '\0';
/* Put the shortened text back into the edit control.
This will put the caret at the end of the text and redisplay. (Putting the caret at the end is good since it draws the user's attention to where the chopping occurred.)
Note that this WM_SETTEXT will cause an EN_CHANGE, but the text will no longer be too long so we will not end up recursing into PruneEcText (which we want to avoid due to the large buffer on the stack). */ SetEcText(vhwndFocus, rgbEcTextBuf);
/* Tell the user the bad news. */ AlertBox (vszDateIsFull, vszTextTruncated, MB_APPLMODAL | MB_OK | MB_ICONEXCLAMATION);
}
|
