/*
* Windows Calendar
* Copyright (c) 1985 by Microsoft Corporation, all rights reserved.
* Written by Mark L. Chamberlin, consultant to Microsoft.
*
*/
/*
*****
***** caltdd.c
*****
*/
#include "cal.h"
#define CDDMAX 512 /* Max number of DD in the tdd. */
#define CDDEXTRA 8 /* When grabbing more memory for the tdd,
allocate CDDEXTRA extra DDs. This avoids
doing a ReAlloc for each DD needed, so
things happen faster.
*/
/**** InitTdd - Initialize the tdd. */
VOID APIENTRY InitTdd ()
{
//- InitTdd: Fixed to take care of bug with LocalReAlloc of returning
//- NULL when the original block is already of size zero.
//- Now just free and allocate later.
if (vcddAllocated != 0 && vhlmTdd)
{
LocalFree (vhlmTdd);
}
vcddUsed = vcddAllocated = 0;
vhlmTdd = (LOCALHANDLE)NULL;
}
/**** FSearchTdd - Search the tdd for the specified DT.
If found, return TRUE and the index of the matching entry.
If not found, return FALSE and the index of where to insert (the
first dd having a DT greater than the one searched for).
*/
BOOL APIENTRY FSearchTdd (
DT dt, /* Input - Date to search for. */
INT *pitdd) /* Output - index of match or insertion point if no
match.
*/
{
/* Note - it's important that the indices be declared as signed
ints since it's possible for itddHigh to go to -1 (if the
item being searched for is less than the first entry in the
table). If it were necessary for the indices to be unsigned
(to allow a larger table size), some coding changes would be
necessary, but for this application ints will work fine since
the table will not be allowed to exceed 32767 entries (in fact,
the limit will be much lower).
*/
register INT itddLow;
register INT itddHigh;
BOOL fFound;
DD *pddFirst;
DT dtTemp;
BOOL fGreater;
/* Lock down the tdd and get the address of the first dd in it. */
pddFirst = TddLock ();
/* Note - in case the tdd is empty, initialize the insertion point
to 0 for the caller. Also set fGreater to FALSE so if the tdd is
empty, the 0 in itdd will get returned without being incremented.
*/
*pitdd = itddLow = 0;
itddHigh = vcddUsed - 1;
fFound = fGreater = FALSE;
while (itddLow <= itddHigh && !fFound)
{
fGreater = FALSE;
*pitdd = (itddLow + itddHigh) / 2;
if (dt == (dtTemp = (pddFirst + *pitdd) -> dt))
fFound = TRUE;
else if (dt > dtTemp)
{
fGreater = TRUE;
itddLow = *pitdd + 1;
}
else
itddHigh = *pitdd - 1;
}
TddUnlock ();
/* The search item was greater than the table item on the last
comparison made. Return the index of the next higher table
entry, since this is the insertion point. Note that if
dt == dtTemp, the index is already that of the matching item,
and if dt < dtTemp, the index is already that of the insertion
point.
*/
if (fGreater)
(*pitdd)++;
return (fFound);
}
/**** FGrowTdd - Grow the tdd by the specified number of DD at the specified
place. If can't grow that much, put up an error message then return
FALSE. If successful, return TRUE.
*/
BOOL APIENTRY FGrowTdd (
INT itdd, /* INPUT - Where the insertion occurs. */
INT cdd) /* INPUT - How many DD to insert. */
{
DD *pdd;
register INT cddUsedNew;
register INT cddAllocatedNew;
if ((cddUsedNew = vcddUsed + cdd) > CDDMAX)
{
/* Can't make it that big. */
AlertBox (vszTooManyDates, (CHAR *)NULL,
MB_APPLMODAL | MB_OK | MB_ICONEXCLAMATION);
return (FALSE);
}
if (cddUsedNew > vcddAllocated)
{
/* We must allocate some more memory to the tdd. Allocate
more than we need right now to avoid always having to allocate
for each new DD.
*/
cddAllocatedNew = cddUsedNew + CDDEXTRA;
//- GrowTdd: Fixed to call LocalAlloc instead of LocalReAlloc because
//- of bug in LocalReAlloc with zero size allocation.
if (vcddAllocated == 0 || vhlmTdd == 0)
{
if ((vhlmTdd = LocalAlloc (LMEM_MOVEABLE,
cddAllocatedNew * sizeof (DD))) == (LOCALHANDLE)NULL)
{
/* Could not get the requested memory. */
AlertBox (vszOutOfMemory, (CHAR *)NULL,
MB_APPLMODAL | MB_OK | MB_ICONEXCLAMATION);
return (FALSE);
}
}
else
{
if ((vhlmTdd = LocalReAlloc (vhlmTdd, cddAllocatedNew * sizeof (DD),
LMEM_MOVEABLE)) == (LOCALHANDLE)NULL)
{
/* Could not get the requested memory. */
AlertBox (vszOutOfMemory, (CHAR *)NULL,
MB_APPLMODAL | MB_OK | MB_ICONEXCLAMATION);
return (FALSE);
}
}
vcddAllocated = cddAllocatedNew;
}
/* Block transfer up all DD at or beyond the insertion point. */
pdd = TddLock () + itdd;
BltByte ((BYTE *)pdd, (BYTE *)(pdd + cdd),
(WORD)(sizeof (DD) * (vcddUsed - itdd)));
TddUnlock ();
vcddUsed = cddUsedNew;
return (TRUE);
}
/**** ShrinkTdd - Shrink the tdd by the specified number of DD. */
VOID APIENTRY ShrinkTdd (
INT itdd, /* The index of the first DD to be deleted. */
INT cdd) /* The number of DD to be deleted. */
{
register DD *pdd;
register INT cddAllocatedNew;
/* Lock the tdd, and get a pointer to the deletion point. */
pdd = TddLock () + itdd;
/* Block transfer down all dd beyond the deletion point. */
BltByte ((BYTE *)(pdd + cdd), (BYTE *)pdd,
(WORD)(sizeof (DD) * (vcddUsed - (itdd + cdd))));
/* Adjust the count of dd. */
vcddUsed -= cdd;
TddUnlock ();
if (vcddAllocated > (cddAllocatedNew = vcddUsed + CDDEXTRA))
{
/* There's more than CDDEXTRA free DDs now, so free up the
extra ones.
*/
//- ShrinkTdd: Fixed to handle bug in LocalReAlloc when trying to do
//- realloc of size zero.
if ((vcddAllocated = cddAllocatedNew) == 0)
{
if (vhlmTdd)
vhlmTdd = LocalFree (vhlmTdd);
}
else
{
if (vhlmTdd)
vhlmTdd = LocalReAlloc (vhlmTdd, cddAllocatedNew * sizeof (DD),
LMEM_MOVEABLE);
}
}
}
/**** BltByte - Block transfer a range of bytes either up or down. */
BYTE * APIENTRY BltByte (
BYTE *pbSrc,
BYTE *pbDst,
UINT cb)
{
register BYTE *pbMax;
pbMax = pbDst + cb;
if (pbSrc >= pbDst)
{
/* Transferring down (from high to low addresses).
Start at the beginning of the block and work
towards higher addresses to avoid overwrite.
*/
while (cb-- != 0)
*pbDst++ = *pbSrc++;
}
else
{
/* Transferring up (from low to high addresses).
Start at the end of the block and work towards lower
addresses to avoid overwrite.
*/
pbSrc += cb;
pbDst = pbMax;
while (cb-- != 0)
*--pbDst = *--pbSrc;
}
/* Return a pointer to the first byte following those moved to the
destination.
*/
return (pbMax);
}
/**** DeleteEmptyDd - delete DD from tdd if the DD is "empty".
The DD is "empty" if the date is not marked and it has
no longer has any data (on disk or in memory). Note that
it cannot have any alarms if there are no Qrs for it, so
there is no need to check cAlarms. If it is empty, get rid of the DD.
*/
VOID APIENTRY DeleteEmptyDd (INT itdd)
{
register DD *pdd;
register BOOL fEmpty;
pdd = TddLock () + itdd;
fEmpty = !pdd -> fMarked && pdd -> dl == DLNIL && pdd -> idr == IDRNIL;
TddUnlock ();
if (fEmpty)
ShrinkTdd (itdd, 1);
}
/**** TddLock */
DD * APIENTRY TddLock ()
{
return ((DD *)LocalLock (vhlmTdd));
}
/**** TddUnlock */
VOID APIENTRY TddUnlock ()
{
LocalUnlock (vhlmTdd);
}