1279 lines
55 KiB
C
1279 lines
55 KiB
C
/****************************************************************************/
|
|
// nbadisp.c
|
|
//
|
|
// RDP Bounds Accumulator display driver code
|
|
//
|
|
// Copyright (C) 1997-2000 Microsoft Corporation
|
|
/****************************************************************************/
|
|
|
|
#include <precmpdd.h>
|
|
#define hdrstop
|
|
|
|
#define TRC_FILE "nbadisp"
|
|
#include <adcg.h>
|
|
|
|
#include <atrcapi.h>
|
|
#include <abaapi.h>
|
|
#include <nbadisp.h>
|
|
|
|
#define DC_INCLUDE_DATA
|
|
#include <ndddata.c>
|
|
#undef DC_INCLUDE_DATA
|
|
|
|
// No data.
|
|
//#include <nbaddat.c>
|
|
|
|
#include <nbainl.h>
|
|
|
|
// Instantiate common code.
|
|
#include <abacom.c>
|
|
|
|
|
|
// Local prototypes.
|
|
#ifdef DC_DEBUG
|
|
void BAPerformUnitTests();
|
|
#endif
|
|
|
|
|
|
/****************************************************************************/
|
|
// BA_DDInit
|
|
/****************************************************************************/
|
|
void RDPCALL BA_DDInit(void)
|
|
{
|
|
DC_BEGIN_FN("BA_DDInit");
|
|
|
|
// No data to declare, don't waste time opening the file.
|
|
//#define DC_INIT_DATA
|
|
//#include <nbaddat.c>
|
|
//#undef DC_INIT_DATA
|
|
|
|
#ifdef DC_DEBUG
|
|
// Perform one-time checks on the algorithm.
|
|
BAPerformUnitTests();
|
|
#endif
|
|
|
|
DC_END_FN();
|
|
}
|
|
|
|
|
|
/****************************************************************************/
|
|
// BA_InitShm
|
|
//
|
|
// Init BA block in shared memory just after alloc.
|
|
/****************************************************************************/
|
|
void RDPCALL BA_InitShm(void)
|
|
{
|
|
unsigned i;
|
|
|
|
DC_BEGIN_FN("BA_InitShm");
|
|
|
|
// Initialize all members - shared memory is not zeroed on alloc.
|
|
|
|
// Initialize rectangle array slots as unused, set up free list
|
|
// containing all rects.
|
|
pddShm->ba.firstRect = BA_INVALID_RECT_INDEX;
|
|
pddShm->ba.rectsUsed = 0;
|
|
pddShm->ba.totalArea = 0;
|
|
pddShm->ba.firstFreeRect = 0;
|
|
for (i = 0; i < BA_TOTAL_NUM_RECTS; i++) {
|
|
pddShm->ba.bounds[i].inUse = FALSE;
|
|
pddShm->ba.bounds[i].iNext = i + 1;
|
|
}
|
|
pddShm->ba.bounds[BA_TOTAL_NUM_RECTS - 1].iNext = BA_INVALID_RECT_INDEX;
|
|
|
|
DC_END_FN();
|
|
}
|
|
|
|
|
|
/****************************************************************************/
|
|
// BA_AddScreenData
|
|
//
|
|
// Adds a specified rectangle to the current Screen Data Area.
|
|
/****************************************************************************/
|
|
void RDPCALL BA_AddScreenData(PRECTL pRect)
|
|
{
|
|
DC_BEGIN_FN("BA_AddScreenData");
|
|
|
|
// Check that the caller has passed a valid rectangle.
|
|
// Make sure we add a rectangle with coordinates within the screen area.
|
|
if((pRect->right > pRect->left) && (pRect->bottom > pRect->top) &&
|
|
(pRect->left >= 0) && (pRect->left < ddDesktopWidth) &&
|
|
(pRect->right > 0) && (pRect->right <= ddDesktopWidth) &&
|
|
(pRect->top >= 0) && (pRect->top < ddDesktopHeight) &&
|
|
(pRect->bottom > 0) && (pRect->bottom <= ddDesktopHeight)) {
|
|
BAAddRect(pRect, 0);
|
|
}
|
|
|
|
DC_END_FN();
|
|
}
|
|
|
|
|
|
/****************************************************************************/
|
|
// BAOverlap
|
|
//
|
|
// Detects overlap between two rectangles. Note that all rectangle
|
|
// coordinates are exclusive. Returns one of the overlap return codes or
|
|
// outcode combinations defined above.
|
|
/****************************************************************************/
|
|
int RDPCALL BAOverlap(PRECTL pRect1, PRECTL pRect2)
|
|
{
|
|
int externalEdges;
|
|
int externalCount;
|
|
int internalEdges;
|
|
int internalCount;
|
|
int rc;
|
|
|
|
DC_BEGIN_FN("BAOverlap");
|
|
|
|
// We start with special cases of the rects being immediately adjacent
|
|
// or overlapping while lying side-by-side.
|
|
if (pRect1->top == pRect2->top && pRect1->bottom == pRect2->bottom) {
|
|
if (pRect1->left <= pRect2->right &&
|
|
pRect1->left > pRect2->left &&
|
|
pRect1->right > pRect2->right) {
|
|
rc = OL_MERGE_LEFT;
|
|
DC_QUIT;
|
|
}
|
|
|
|
if (pRect1->right >= pRect2->left &&
|
|
pRect1->right < pRect2->right &&
|
|
pRect1->left < pRect2->left) {
|
|
rc = OL_MERGE_RIGHT;
|
|
DC_QUIT;
|
|
}
|
|
}
|
|
if (pRect1->left == pRect2->left && pRect1->right == pRect2->right) {
|
|
if (pRect1->top <= pRect2->bottom &&
|
|
pRect1->top > pRect2->top &&
|
|
pRect1->bottom > pRect2->bottom) {
|
|
rc = OL_MERGE_TOP;
|
|
DC_QUIT;
|
|
}
|
|
|
|
if (pRect1->bottom >= pRect2->top &&
|
|
pRect1->bottom < pRect2->bottom &&
|
|
pRect1->top < pRect2->top) {
|
|
rc = OL_MERGE_BOTTOM;
|
|
DC_QUIT;
|
|
}
|
|
}
|
|
|
|
// Check for no overlapping -- we've exhausted the cases where adjacency
|
|
// can be taken advantage of.
|
|
if (pRect1->left >= pRect2->right ||
|
|
pRect1->top >= pRect2->bottom ||
|
|
pRect1->right <= pRect2->left ||
|
|
pRect1->bottom <= pRect2->top) {
|
|
rc = OL_NONE;
|
|
DC_QUIT;
|
|
}
|
|
|
|
// Use outcodes for Internal edge cases.
|
|
// If 3 or more bits are set then rect1 is enclosed either partially or
|
|
// completely within rect2 according to the OL_ENCLOSED and
|
|
// OL_PART_ENCLOSED_XXX definitions. The negative of the outcode value
|
|
// is retruned to ensure that it is distinct from the external edge
|
|
// outcode returns (see below).
|
|
internalCount = 0;
|
|
internalEdges = 0;
|
|
if (pRect1->left >= pRect2->left && pRect1->left < pRect2->right) {
|
|
// Rect1 left is enclosed within rect2.
|
|
internalEdges |= EE_LEFT;
|
|
internalCount++;
|
|
}
|
|
if (pRect1->top >= pRect2->top && pRect1->top < pRect2->bottom) {
|
|
// Rect1 top is enclosed within rect2.
|
|
internalEdges |= EE_TOP;
|
|
internalCount++;
|
|
}
|
|
if (pRect1->right > pRect2->left && pRect1->right <= pRect2->right) {
|
|
// Rect1 right is enclosed within rect2.
|
|
internalEdges |= EE_RIGHT;
|
|
internalCount++;
|
|
}
|
|
if (pRect1->bottom > pRect2->top && pRect1->bottom <= pRect2->bottom) {
|
|
// Rect1 bottom is enclosed within rect2.
|
|
internalEdges |= EE_BOTTOM;
|
|
internalCount++;
|
|
}
|
|
if (internalCount >= 3) {
|
|
rc = -internalEdges;
|
|
DC_QUIT;
|
|
}
|
|
|
|
// Use outcodes for External edge cases. These are the classic "line"
|
|
// outcodes. If 2 or more bits are set then rect1 overlaps rect2 per the
|
|
// OL_ENCLOSES_XXX and OL_SPLIT_XXX definitions.
|
|
externalEdges = 0;
|
|
externalCount = 0;
|
|
if (pRect1->left <= pRect2->left) {
|
|
// Rect1 left is left of rect2 left.
|
|
externalEdges |= EE_LEFT;
|
|
externalCount++;
|
|
}
|
|
if (pRect1->top <= pRect2->top) {
|
|
// Rect1 top is above rect2 top.
|
|
externalEdges |= EE_TOP;
|
|
externalCount++;
|
|
}
|
|
if (pRect1->right >= pRect2->right) {
|
|
// Rect1 right is right of rect2 right.
|
|
externalEdges |= EE_RIGHT;
|
|
externalCount++;
|
|
}
|
|
if (pRect1->bottom >= pRect2->bottom) {
|
|
// Rect1 bottom is below rect2 bottom.
|
|
externalEdges |= EE_BOTTOM;
|
|
externalCount++;
|
|
}
|
|
if (externalCount >= 2) {
|
|
rc = externalEdges;
|
|
DC_QUIT;
|
|
}
|
|
|
|
// If get here then we failed to detect a valid case.
|
|
TRC_ALT((TB, "Unrecognised Overlap: (%d,%d,%d,%d),(%d,%d,%d,%d)",
|
|
pRect1->left, pRect1->top, pRect1->right, pRect1->bottom,
|
|
pRect2->left, pRect2->top, pRect2->right, pRect2->bottom ));
|
|
rc = OL_NONE;
|
|
|
|
DC_EXIT_POINT:
|
|
DC_END_FN();
|
|
return rc;
|
|
}
|
|
|
|
|
|
/****************************************************************************/
|
|
// BARemoveRectList
|
|
//
|
|
// Removes a rectangle from the list.
|
|
/****************************************************************************/
|
|
__inline void RDPCALL BARemoveRectList(unsigned iRect)
|
|
{
|
|
BA_RECT_INFO *pRect;
|
|
|
|
DC_BEGIN_FN("BARemoveRectList");
|
|
|
|
pRect = &(pddShm->ba.bounds[iRect]);
|
|
|
|
// Unlink from used list.
|
|
if (pRect->iPrev != BA_INVALID_RECT_INDEX)
|
|
pddShm->ba.bounds[pRect->iPrev].iNext = pRect->iNext;
|
|
else
|
|
pddShm->ba.firstRect = pRect->iNext;
|
|
|
|
if (pRect->iNext != BA_INVALID_RECT_INDEX)
|
|
pddShm->ba.bounds[pRect->iNext].iPrev = pRect->iPrev;
|
|
|
|
// Add to beginning of free list.
|
|
pRect->inUse = FALSE;
|
|
pRect->iNext = pddShm->ba.firstFreeRect;
|
|
pddShm->ba.firstFreeRect = iRect;
|
|
|
|
// Update bookkeeping variables.
|
|
pddShm->ba.rectsUsed--;
|
|
pddShm->ba.totalArea -= pRect->area;
|
|
|
|
#ifdef DC_DEBUG
|
|
// Check the list integrity.
|
|
BACheckList();
|
|
#endif
|
|
|
|
DC_END_FN();
|
|
}
|
|
|
|
|
|
/****************************************************************************/
|
|
// BARecalcArea
|
|
//
|
|
// Recalculates a rect area, preserving the totalArea central tally of areas.
|
|
/****************************************************************************/
|
|
__inline void RDPCALL BARecalcArea(unsigned iRect)
|
|
{
|
|
// Reset area to new size and update totalArea.
|
|
pddShm->ba.totalArea -= pddShm->ba.bounds[iRect].area;
|
|
pddShm->ba.bounds[iRect].area =
|
|
COM_SIZEOF_RECT(pddShm->ba.bounds[iRect].coord);
|
|
pddShm->ba.totalArea += pddShm->ba.bounds[iRect].area;
|
|
}
|
|
|
|
|
|
/****************************************************************************/
|
|
// BAAddRect
|
|
//
|
|
// Accumulates rectangles. This is a complex routine, with the essential
|
|
// algorithm as follows:
|
|
//
|
|
// - Start with the supplied rect as the candidate rect.
|
|
//
|
|
// - Compare the candidate against each of the existing accumulated rects.
|
|
//
|
|
// - If some form of overlap is detected between the candidate and an
|
|
// existing rect, this may result in one of the following (see the cases of
|
|
// the switch for details):
|
|
//
|
|
// - adjust the candidate or the existing rect or both
|
|
// - merge the candidate into the existing rect
|
|
// - discard the candidate as it is enclosed by an existing rect.
|
|
//
|
|
// - If the merge or adjustment results in a changed candidate, restart the
|
|
// comparisons from the beginning of the list with the changed candidate.
|
|
//
|
|
// - If the adjustment results in a split (giving two candidate rects),
|
|
// invoke this routine recursively with one of the two candidates as its
|
|
// candidate.
|
|
//
|
|
// - If no overlap is detected against the existing rects, add the candidate
|
|
// to the list of accumulated rectangles.
|
|
//
|
|
// - If the add results in more than BA_MAX_ACCUMULATED_RECTS accumulated
|
|
// rects, do a forced merge of two of the accumulate rects (which include
|
|
// the newly added candidate) - choosing the two rects where the merged rect
|
|
// results in the smallest increase in area over the two non-merged rects.
|
|
//
|
|
// - After a forced merge, restart the comparisons from the beginning of the
|
|
// list with the newly merged rectangle as the candidate.
|
|
//
|
|
// For a particular call, this process will continue until the candidate
|
|
// (whether the supplied rect, an adjusted version of that rect, or a merged
|
|
// rect):
|
|
//
|
|
// - does not find an overlap among the rects in the list and does not cause
|
|
// a forced merge
|
|
// - is discarded becuase it is enclosed within one of the rects in the list.
|
|
//
|
|
// Returns TRUE if rectangle was spoiled due to a complete overlap.
|
|
/****************************************************************************/
|
|
BOOL RDPCALL BAAddRect(PRECTL pCand, int level)
|
|
{
|
|
INT32 bestMergeIncrease;
|
|
INT32 mergeIncrease;
|
|
unsigned iBestMerge1;
|
|
unsigned iBestMerge2;
|
|
unsigned iExist;
|
|
unsigned iTmp;
|
|
BOOLEAN fRectToAdd;
|
|
BOOLEAN fRectMerged;
|
|
BOOLEAN fResetRects;
|
|
RECTL rectNew;
|
|
unsigned iLastMerge;
|
|
int overlapType;
|
|
BOOL rc = TRUE;
|
|
|
|
DC_BEGIN_FN("BAAddRect");
|
|
|
|
#ifdef DC_DEBUG
|
|
// Check list, esp. the area calculations.
|
|
BACheckList();
|
|
#endif
|
|
|
|
// Increase the level count in case we recurse.
|
|
level++;
|
|
|
|
// Start off by assuming the candidate rectangle will be added to the
|
|
// accumulated list of rectangles, and that no forced merge has
|
|
// occurred.
|
|
fRectToAdd = TRUE;
|
|
fRectMerged = FALSE;
|
|
|
|
// Loop until no merges occur.
|
|
do {
|
|
TRC_DBG((TB, "Candidate rect: (%d,%d,%d,%d)",
|
|
pCand->left,pCand->top,pCand->right,pCand->bottom));
|
|
|
|
// Compare the current candidate rectangle against the rectangles
|
|
// in the current accumulated list.
|
|
iExist = pddShm->ba.firstRect;
|
|
|
|
while (iExist != BA_INVALID_RECT_INDEX) {
|
|
// Assume that the comparisons will run through the whole list.
|
|
fResetRects = FALSE;
|
|
|
|
// If the candidate and the existing rectangle are the same
|
|
// then ignore. This occurs when an existing rectangle is
|
|
// replaced by a candidate and the comparisons are restarted
|
|
// from the front of the list - whereupon at some point the
|
|
// candidate will be compared with itself.
|
|
if (&pddShm->ba.bounds[iExist].coord == pCand) {
|
|
TRC_DBG((TB, "OL_SAME - %d", iExist));
|
|
iExist = pddShm->ba.bounds[iExist].iNext;
|
|
continue;
|
|
}
|
|
|
|
// Switch on the overlap type (see Overlap routine).
|
|
overlapType = BAOverlap(&(pddShm->ba.bounds[iExist].coord), pCand);
|
|
switch (overlapType) {
|
|
case OL_NONE:
|
|
// No overlap.
|
|
TRC_DBG((TB, "OL_NONE - %d", iExist));
|
|
break;
|
|
|
|
|
|
case OL_MERGE_LEFT:
|
|
// Candidate abuts or overlaps existing rect at existing
|
|
// rect's left.
|
|
TRC_DBG((TB, "OL_MERGE_LEFT - %d", iExist));
|
|
if (fRectToAdd) {
|
|
// Candidate is the original rect; merge the
|
|
// candidate into the existing, and make the existing
|
|
// the new candidate.
|
|
pddShm->ba.bounds[iExist].coord.left = pCand->left;
|
|
pCand = &(pddShm->ba.bounds[iExist].coord);
|
|
fRectToAdd = FALSE;
|
|
iLastMerge = iExist;
|
|
BARecalcArea(iExist);
|
|
}
|
|
else {
|
|
// This is a merge of two existing rectangles (ie
|
|
// the candidate is the result of a merge), merge the
|
|
// overlapping existing into the candidate (the last
|
|
// merged) and remove the existing.
|
|
pCand->right = pddShm->ba.bounds[iExist].coord.right;
|
|
BARemoveRectList(iExist);
|
|
}
|
|
|
|
// Start the comparisons again with the new candidate.
|
|
fResetRects = TRUE;
|
|
break;
|
|
|
|
|
|
case OL_MERGE_RIGHT:
|
|
// Candidate abuts or overlaps existing rect at existing
|
|
// rect's right.
|
|
TRC_DBG((TB, "OL_MERGE_RIGHT - %d", iExist));
|
|
if (fRectToAdd) {
|
|
// Candidate is the original rect; merge the
|
|
// candidate into the existing, and make the existing
|
|
// the new candidate.
|
|
pddShm->ba.bounds[iExist].coord.right = pCand->right;
|
|
pCand = &(pddShm->ba.bounds[iExist].coord);
|
|
fRectToAdd = FALSE;
|
|
iLastMerge = iExist;
|
|
BARecalcArea(iExist);
|
|
}
|
|
else {
|
|
// This is a merge of two existing rectangles (ie
|
|
// the candidate is the result of a merge), merge the
|
|
// overlapping existing into the candidate (the last
|
|
// merged) and remove the existing.
|
|
pCand->left = pddShm->ba.bounds[iExist].coord.left;
|
|
BARemoveRectList(iExist);
|
|
}
|
|
|
|
// Start the comparisons again with the new candidate.
|
|
fResetRects = TRUE;
|
|
break;
|
|
|
|
|
|
case OL_MERGE_TOP:
|
|
// Candidate abuts or overlaps existing rect at existing
|
|
// rect's top.
|
|
TRC_DBG((TB, "OL_MERGE_TOP - %d", iExist));
|
|
if (fRectToAdd) {
|
|
// Candidate is the original rect; merge the
|
|
// candidate into the existing, and make the existing
|
|
// the new candidate.
|
|
pddShm->ba.bounds[iExist].coord.top = pCand->top;
|
|
pCand = &(pddShm->ba.bounds[iExist].coord);
|
|
fRectToAdd = FALSE;
|
|
iLastMerge = iExist;
|
|
BARecalcArea(iExist);
|
|
}
|
|
else {
|
|
// This is a merge of two existing rectangles (ie
|
|
// the candidate is the result of a merge), merge the
|
|
// overlapping existing into the candidate (the last
|
|
// merged) and remove the existing.
|
|
pCand->bottom =
|
|
pddShm->ba.bounds[iExist].coord.bottom;
|
|
BARemoveRectList(iExist);
|
|
}
|
|
|
|
// Start the comparisons again with the new candidate.
|
|
fResetRects = TRUE;
|
|
break;
|
|
|
|
|
|
case OL_MERGE_BOTTOM:
|
|
// Candidate abuts or overlaps existing rect at existing
|
|
// rect's bottom.
|
|
TRC_DBG((TB, "OL_MERGE_BOTTOM - %d", iExist));
|
|
if (fRectToAdd) {
|
|
// Candidate is the original rect; merge the
|
|
// candidate into the existing, and make the existing
|
|
// the new candidate.
|
|
pddShm->ba.bounds[iExist].coord.bottom =
|
|
pCand->bottom;
|
|
pCand = &(pddShm->ba.bounds[iExist].coord);
|
|
fRectToAdd = FALSE;
|
|
iLastMerge = iExist;
|
|
BARecalcArea(iExist);
|
|
}
|
|
else {
|
|
// This is a merge of two existing rectangles (ie
|
|
// the candidate is the result of a merge), merge the
|
|
// overlapping existing into the candidate (the last
|
|
// merged) and remove the existing.
|
|
pCand->top = pddShm->ba.bounds[iExist].coord.top;
|
|
BARemoveRectList(iExist);
|
|
}
|
|
|
|
// Start the comparisons again with the new candidate.
|
|
fResetRects = TRUE;
|
|
break;
|
|
|
|
|
|
case OL_ENCLOSED:
|
|
// The existing is enclosed by the candidate.
|
|
//
|
|
// 100,100 +----------------------+
|
|
// | Cand |
|
|
// | |
|
|
// | 130,130 |
|
|
// | +------------+ |
|
|
// | | | |
|
|
// | | Exist | |
|
|
// | | | |
|
|
// | +------------+ |
|
|
// | 170,170 |
|
|
// +----------------------+ 200,200
|
|
TRC_DBG((TB, "OL_ENCLOSED - %d", iExist));
|
|
if (fRectToAdd) {
|
|
// Candidate is the original rect; replace the
|
|
// existing with the candidate and make the new
|
|
// existing the new candidate.
|
|
pddShm->ba.bounds[iExist].coord = *pCand;
|
|
pCand = &(pddShm->ba.bounds[iExist].coord);
|
|
fRectToAdd = FALSE;
|
|
iLastMerge = iExist;
|
|
BARecalcArea(iExist);
|
|
}
|
|
else {
|
|
// Candidate is an existing rect: Remove the other
|
|
// existing rect.
|
|
BARemoveRectList(iExist);
|
|
}
|
|
|
|
// Start the comparisons again with the new candidate.
|
|
fResetRects = TRUE;
|
|
break;
|
|
|
|
|
|
case OL_PART_ENCLOSED_LEFT:
|
|
// The existing is partially enclosed by the candidate
|
|
// - but not on the right.
|
|
//
|
|
// 100,100 +----------------------+
|
|
// | Cand |
|
|
// | 130,130 +-----------+--------+
|
|
// | | | |
|
|
// | | Exist | |
|
|
// | | | |
|
|
// | +-----------+--------+
|
|
// | | 220,170
|
|
// +----------------------+
|
|
// 200,200
|
|
//
|
|
// Adjust the existing rectangle to be the non-
|
|
// overlapped portion.
|
|
//
|
|
// 100,100 +----------------------+
|
|
// | |200,130
|
|
// | |+-------+
|
|
// | || |
|
|
// | Cand || Exist |
|
|
// | || |
|
|
// | |+-------+
|
|
// | | 220,170
|
|
// +----------------------+
|
|
// 200,200
|
|
//
|
|
// Note that this does not restart the comparisons.
|
|
TRC_DBG((TB, "OL_PART_ENCLOSED_LEFT - %d", iExist));
|
|
pddShm->ba.bounds[iExist].coord.left = pCand->right;
|
|
BARecalcArea(iExist);
|
|
break;
|
|
|
|
|
|
case OL_PART_ENCLOSED_RIGHT:
|
|
// The existing is partially enclosed by the candidate
|
|
// - but not on the left. Adjust the existing rect to be
|
|
// the non-overlapping portion, similar to
|
|
// OL_PART_ENCLOSED_LEFT above.
|
|
// Note that this does not restart the comparisons.
|
|
TRC_DBG((TB, "OL_PART_ENCLOSED_RIGHT - %d", iExist));
|
|
pddShm->ba.bounds[iExist].coord.right = pCand->left;
|
|
BARecalcArea(iExist);
|
|
break;
|
|
|
|
|
|
case OL_PART_ENCLOSED_TOP:
|
|
// The existing is partially enclosed by the candidate
|
|
// - but not on the bottom. Adjust the existing rect to be
|
|
// the non-overlapping portion, similar to
|
|
// OL_PART_ENCLOSED_LEFT above.
|
|
// Note that this does not restart the comparisons.
|
|
TRC_DBG((TB, "OL_PART_ENCLOSED_TOP - %d", iExist));
|
|
pddShm->ba.bounds[iExist].coord.top = pCand->bottom;
|
|
BARecalcArea(iExist);
|
|
break;
|
|
|
|
|
|
case OL_PART_ENCLOSED_BOTTOM:
|
|
// The existing is partially enclosed by the candidate
|
|
// - but not on the top. Adjust the existing rect to be
|
|
// the non-overlapping portion, similar to
|
|
// OL_PART_ENCLOSED_LEFT above.
|
|
// Note that this does not restart the comparisons.
|
|
TRC_DBG((TB, "OL_PART_ENCLOSED_BOTTOM - %d", iExist));
|
|
pddShm->ba.bounds[iExist].coord.bottom = pCand->top;
|
|
BARecalcArea(iExist);
|
|
break;
|
|
|
|
|
|
case OL_ENCLOSES:
|
|
// The existing encloses the candidate.
|
|
//
|
|
// 100,100 +----------------------+
|
|
// | Exist |
|
|
// | |
|
|
// | 130,130 |
|
|
// | +------------+ |
|
|
// | | | |
|
|
// | | Cand | |
|
|
// | | | |
|
|
// | +------------+ |
|
|
// | 170,170 |
|
|
// +----------------------+ 200,200
|
|
TRC_DBG((TB, "OL_ENCLOSES - %d", iExist));
|
|
|
|
// Return FALSE indicating that the rectangle is
|
|
// already catered for by the existing bounds.
|
|
rc = FALSE;
|
|
DC_QUIT;
|
|
|
|
|
|
case OL_PART_ENCLOSES_LEFT:
|
|
// The existing partially encloses the candidate - but
|
|
// not on the left.
|
|
//
|
|
// 100,100 +----------------------+
|
|
// | Exist |
|
|
// 70,130 | |
|
|
// +-----+---------------+ |
|
|
// | | | |
|
|
// | | Cand | |
|
|
// | | | |
|
|
// +-----+---------------+ |
|
|
// | 170,170 |
|
|
// +----------------------+ 200,200
|
|
//
|
|
// Adjust the candidate rectangle to be the non-
|
|
// overlapped portion.
|
|
//
|
|
// 100,100
|
|
// +----------------------+
|
|
// | |
|
|
// 70,130 | |
|
|
// +----+| |
|
|
// | || |
|
|
// |Cand|| Exist |
|
|
// | || |
|
|
// +----+| |
|
|
// 100,170| |
|
|
// +----------------------+ 200,200
|
|
TRC_DBG((TB, "OL_PART_ENCLOSES_LEFT - %d", iExist));
|
|
pCand->right = pddShm->ba.bounds[iExist].coord.left;
|
|
|
|
// The candidate changed. Restart the comparisons to check
|
|
// for overlaps between the adjusted candidate and other
|
|
// existing rects.
|
|
fResetRects = TRUE;
|
|
BARecalcArea(iExist);
|
|
break;
|
|
|
|
|
|
case OL_PART_ENCLOSES_RIGHT:
|
|
// The existing partially encloses the candidate - but
|
|
// not on the right. Adjust the candidate rect to be
|
|
// the non-overlapping portion, similar to
|
|
// OL_PART_ENCLOSES_LEFT above.
|
|
TRC_DBG((TB, "OL_PART_ENCLOSES_RIGHT - %d", iExist));
|
|
pCand->left = pddShm->ba.bounds[iExist].coord.right;
|
|
|
|
// The candidate changed. Restart the comparisons to check
|
|
// for overlaps between the adjusted candidate and other
|
|
// existing rects.
|
|
fResetRects = TRUE;
|
|
BARecalcArea(iExist);
|
|
break;
|
|
|
|
|
|
case OL_PART_ENCLOSES_TOP:
|
|
// The existing partially encloses the candidate - but
|
|
// not on the top. Adjust the candidate rect to be
|
|
// the non-overlapping portion, similar to
|
|
// OL_PART_ENCLOSES_LEFT above.
|
|
TRC_DBG((TB, "OL_PART_ENCLOSES_TOP - %d", iExist));
|
|
pCand->bottom = pddShm->ba.bounds[iExist].coord.top;
|
|
|
|
// The candidate changed. Restart the comparisons to check
|
|
// for overlaps between the adjusted candidate and other
|
|
// existing rects.
|
|
fResetRects = TRUE;
|
|
BARecalcArea(iExist);
|
|
break;
|
|
|
|
|
|
case OL_PART_ENCLOSES_BOTTOM:
|
|
// The existing partially encloses the candidate - but
|
|
// not on the bottom. Adjust the candidate rect to be
|
|
// the non-overlapping portion, similar to
|
|
// OL_PART_ENCLOSES_LEFT above.
|
|
TRC_DBG((TB, "OL_PART_ENCLOSES_BOTTOM - %d", iExist));
|
|
pCand->top = pddShm->ba.bounds[iExist].coord.bottom;
|
|
|
|
// The candidate changed. Restart the comparisons to check
|
|
// for overlaps between the adjusted candidate and other
|
|
// existing rects.
|
|
fResetRects = TRUE;
|
|
BARecalcArea(iExist);
|
|
break;
|
|
|
|
|
|
case OL_SPLIT_HORIZ:
|
|
// The existing overlaps the candicate, but neither can
|
|
// be merged or adjusted.
|
|
//
|
|
// 100,100 +--------+
|
|
// 70,130 | Exist |
|
|
// +-----+--------+------+
|
|
// | | | |
|
|
// | Cand| | |
|
|
// | | | |
|
|
// +-----+--------+------+180,160
|
|
// | |
|
|
// +--------+150,200
|
|
//
|
|
// Need to split candidate into left and right halves.
|
|
// Only do a split if there is spare room in the list -
|
|
// because both the split rectangles may need to be
|
|
// added to the list.
|
|
//
|
|
// If there is spare room, split the candidate into a
|
|
// smaller candidate on the left and a new rectangle on
|
|
// the right. Call this routine recursively to handle
|
|
// the new rectangle.
|
|
//
|
|
// 100,100 +--------+
|
|
// 70,130 | |150,130
|
|
// +----+| |+-----+
|
|
// | || || |
|
|
// |Cand|| Exist || New |
|
|
// | || || |
|
|
// +----+| |+-----+
|
|
// 100,160| | 180,160
|
|
// +--------+150,200
|
|
TRC_DBG((TB, "OL_SPLIT_HORIZ - %d", iExist));
|
|
|
|
if (pddShm->ba.rectsUsed < BA_MAX_ACCUMULATED_RECTS &&
|
|
level < ADDR_RECURSE_LIMIT) {
|
|
if (((pCand->bottom - pCand->top) *
|
|
(pddShm->ba.bounds[iExist].coord.right -
|
|
pddShm->ba.bounds[iExist].coord.left)) >
|
|
MIN_OVERLAP_BYTES) {
|
|
rectNew.left =
|
|
pddShm->ba.bounds[iExist].coord.right;
|
|
rectNew.right = pCand->right;
|
|
rectNew.top = pCand->top;
|
|
rectNew.bottom = pCand->bottom;
|
|
pCand->right =
|
|
pddShm->ba.bounds[iExist].coord.left;
|
|
|
|
TRC_DBG((TB, "*** RECURSION ***"));
|
|
BAAddRect(&rectNew, level);
|
|
TRC_DBG((TB, "*** RETURN ***"));
|
|
|
|
if (!fRectToAdd &&
|
|
!pddShm->ba.bounds[iLastMerge].inUse) {
|
|
TRC_DBG((TB, "FINISHED - %d", iLastMerge));
|
|
DC_QUIT;
|
|
}
|
|
|
|
// After the recursion, because the candidate has
|
|
// changed, restart the comparisons to check for
|
|
// overlaps between the adjusted candidate and
|
|
// other existing rectangles.
|
|
fResetRects = TRUE;
|
|
}
|
|
}
|
|
break;
|
|
|
|
|
|
case OL_SPLIT_VERT:
|
|
// The existing overlaps the candidate, but neither can
|
|
// be merged or adjusted. Split candidate into top and
|
|
// bottom similar to OL_SPLIT_HORIZ above.
|
|
TRC_DBG((TB, "OL_SPLIT_VERT - %d", iExist));
|
|
if (pddShm->ba.rectsUsed < BA_MAX_ACCUMULATED_RECTS &&
|
|
level < ADDR_RECURSE_LIMIT) {
|
|
if (((pCand->right - pCand->left) *
|
|
(pddShm->ba.bounds[iExist].coord.bottom -
|
|
pddShm->ba.bounds[iExist].coord.top)) >
|
|
MIN_OVERLAP_BYTES) {
|
|
rectNew.left = pCand->left;
|
|
rectNew.right = pCand->right;
|
|
rectNew.top =
|
|
pddShm->ba.bounds[iExist].coord.bottom;
|
|
rectNew.bottom = pCand->bottom;
|
|
pCand->bottom =
|
|
pddShm->ba.bounds[iExist].coord.top;
|
|
|
|
TRC_DBG((TB, "*** RECURSION ***"));
|
|
BAAddRect(&rectNew, level);
|
|
TRC_DBG((TB, "*** RETURN ***"));
|
|
|
|
if (!fRectToAdd &&
|
|
!pddShm->ba.bounds[iLastMerge].inUse) {
|
|
TRC_DBG((TB, "FINISHED - %d", iLastMerge));
|
|
DC_QUIT;
|
|
}
|
|
|
|
// After the recursion, because the candidate has
|
|
// changed, restart the comparisons to check for
|
|
// overlaps between the adjusted candidate and
|
|
// other existing rectangles.
|
|
fResetRects = TRUE;
|
|
}
|
|
}
|
|
break;
|
|
|
|
|
|
case OL_SPLIT_LEFT_TOP:
|
|
// The existing overlaps the candicate at the existing
|
|
// rect's top left, but neither can be merged or adjusted.
|
|
//
|
|
// 100,100 +---------------+
|
|
// | Cand |
|
|
// | |
|
|
// | 150,150 |
|
|
// | +-------+-----+
|
|
// | | | |
|
|
// | | | |
|
|
// +-------+-------+ |
|
|
// | 200,200 |
|
|
// | |
|
|
// | Exist |
|
|
// +-------------+ 250, 250
|
|
//
|
|
// Need to split candidate into top and left pieces.
|
|
// Only do a split if there is spare room in the list -
|
|
// because both the split rectangles may need to be
|
|
// added to the list.
|
|
//
|
|
// If there is spare room, split the candidate into a
|
|
// smaller candidate on the left and a new rectangle on
|
|
// the top. Call this routine recursively to handle
|
|
// the new rectangle.
|
|
//
|
|
// 151,100
|
|
// 100,100 +-------+-------+
|
|
// | | |
|
|
// | | New |
|
|
// | | |200,149
|
|
// | +-------+-----+
|
|
// | Cand |150,150 |
|
|
// | | |
|
|
// +-------+ Exist |
|
|
// 150,200| |
|
|
// | |
|
|
// | |
|
|
// +-------------+ 250,250
|
|
TRC_DBG((TB, "OL_SPLIT_LEFT_TOP - %d", iExist));
|
|
if (pddShm->ba.rectsUsed < BA_MAX_ACCUMULATED_RECTS &&
|
|
level < ADDR_RECURSE_LIMIT) {
|
|
if (((pCand->right -
|
|
pddShm->ba.bounds[iExist].coord.left) *
|
|
(pCand->bottom -
|
|
pddShm->ba.bounds[iExist].coord.top)) >
|
|
MIN_OVERLAP_BYTES) {
|
|
rectNew.left =
|
|
pddShm->ba.bounds[iExist].coord.left;
|
|
rectNew.right = pCand->right;
|
|
rectNew.top = pCand->top;
|
|
rectNew.bottom =
|
|
pddShm->ba.bounds[iExist].coord.top;
|
|
pCand->right =
|
|
pddShm->ba.bounds[iExist].coord.left;
|
|
|
|
TRC_DBG((TB, "*** RECURSION ***"));
|
|
BAAddRect(&rectNew, level);
|
|
TRC_DBG((TB, "*** RETURN ***"));
|
|
|
|
if (!fRectToAdd &&
|
|
!pddShm->ba.bounds[iLastMerge].inUse) {
|
|
TRC_DBG((TB, "FINISHED - %d", iLastMerge));
|
|
DC_QUIT;
|
|
}
|
|
|
|
// After the recursion, because the candidate has
|
|
// changed, restart the comparisons to check for
|
|
// overlaps between the adjusted candidate and
|
|
// other existing rectangles.
|
|
fResetRects = TRUE;
|
|
}
|
|
}
|
|
break;
|
|
|
|
|
|
case OL_SPLIT_RIGHT_TOP:
|
|
// The existing overlaps the candidate, but neither can
|
|
// be merged or adjusted. Split into top and right
|
|
// pieces if there is room in the list, similar to
|
|
// OL_SPLIT_LEFT_TOP above.
|
|
TRC_DBG((TB, "OL_SPLIT_RIGHT_TOP - %d", iExist));
|
|
if (pddShm->ba.rectsUsed < BA_MAX_ACCUMULATED_RECTS &&
|
|
level < ADDR_RECURSE_LIMIT) {
|
|
if (((pddShm->ba.bounds[iExist].coord.right -
|
|
pCand->left) * (pCand->bottom -
|
|
pddShm->ba.bounds[iExist].coord.top)) >
|
|
MIN_OVERLAP_BYTES) {
|
|
rectNew.left = pCand->left;
|
|
rectNew.right =
|
|
pddShm->ba.bounds[iExist].coord.right;
|
|
rectNew.top = pCand->top;
|
|
rectNew.bottom =
|
|
pddShm->ba.bounds[iExist].coord.top;
|
|
pCand->left =
|
|
pddShm->ba.bounds[iExist].coord.right;
|
|
|
|
TRC_DBG((TB, "*** RECURSION ***"));
|
|
BAAddRect(&rectNew, level);
|
|
TRC_DBG((TB, "*** RETURN ***"));
|
|
|
|
if (!fRectToAdd &&
|
|
!pddShm->ba.bounds[iLastMerge].inUse) {
|
|
TRC_DBG((TB, "FINISHED - %d", iLastMerge));
|
|
DC_QUIT;
|
|
}
|
|
|
|
// After the recursion, because the candidate has
|
|
// changed, restart the comparisons to check for
|
|
// overlaps between the adjusted candidate and
|
|
// other existing rectangles.
|
|
fResetRects = TRUE;
|
|
}
|
|
}
|
|
break;
|
|
|
|
|
|
case OL_SPLIT_LEFT_BOTTOM:
|
|
// The existing overlaps the candidate, but neither can
|
|
// be merged or adjusted. Split into left and bottom
|
|
// pieces if there is room in the list, similar to
|
|
// OL_SPLIT_LEFT_TOP above.
|
|
TRC_DBG((TB, "OL_SPLIT_LEFT_BOTTOM - %d", iExist));
|
|
if (pddShm->ba.rectsUsed < BA_MAX_ACCUMULATED_RECTS &&
|
|
level < ADDR_RECURSE_LIMIT) {
|
|
if (((pCand->right -
|
|
pddShm->ba.bounds[iExist].coord.left) *
|
|
(pddShm->ba.bounds[iExist].coord.bottom -
|
|
pCand->top)) > MIN_OVERLAP_BYTES) {
|
|
rectNew.left =
|
|
pddShm->ba.bounds[iExist].coord.left;
|
|
rectNew.right = pCand->right;
|
|
rectNew.top =
|
|
pddShm->ba.bounds[iExist].coord.bottom;
|
|
rectNew.bottom = pCand->bottom;
|
|
pCand->right =
|
|
pddShm->ba.bounds[iExist].coord.left;
|
|
|
|
TRC_DBG((TB, "*** RECURSION ***"));
|
|
BAAddRect(&rectNew, level);
|
|
TRC_DBG((TB, "*** RETURN ***"));
|
|
|
|
if (!fRectToAdd &&
|
|
!pddShm->ba.bounds[iLastMerge].inUse) {
|
|
TRC_DBG((TB, "FINISHED - %d", iLastMerge));
|
|
DC_QUIT;
|
|
}
|
|
|
|
// After the recursion, because the candidate has
|
|
// changed, restart the comparisons to check for
|
|
// overlaps between the adjusted candidate and
|
|
// other existing rectangles.
|
|
fResetRects = TRUE;
|
|
}
|
|
}
|
|
break;
|
|
|
|
|
|
case OL_SPLIT_RIGHT_BOTTOM:
|
|
// The existing overlaps the candidate, but neither can
|
|
// be merged or adjusted. Split into right and bottom
|
|
// pieces if there is room in the list, similar to
|
|
// OL_SPLIT_LEFT_TOP above.
|
|
TRC_DBG((TB, "OL_SPLIT_RIGHT_BOTTOM - %d", iExist));
|
|
if (pddShm->ba.rectsUsed < BA_MAX_ACCUMULATED_RECTS &&
|
|
level < ADDR_RECURSE_LIMIT) {
|
|
if (((pddShm->ba.bounds[iExist].coord.right -
|
|
pCand->left) *
|
|
(pddShm->ba.bounds[iExist].coord.bottom -
|
|
pCand->top)) > MIN_OVERLAP_BYTES) {
|
|
rectNew.left = pCand->left;
|
|
rectNew.right =
|
|
pddShm->ba.bounds[iExist].coord.right;
|
|
rectNew.top =
|
|
pddShm->ba.bounds[iExist].coord.bottom;
|
|
rectNew.bottom = pCand->bottom;
|
|
pCand->left =
|
|
pddShm->ba.bounds[iExist].coord.right;
|
|
|
|
TRC_DBG((TB, "*** RECURSION ***"));
|
|
BAAddRect(&rectNew, level);
|
|
TRC_DBG((TB, "*** RETURN ***"));
|
|
|
|
if (!fRectToAdd &&
|
|
!pddShm->ba.bounds[iLastMerge].inUse) {
|
|
TRC_DBG((TB, "FINISHED - %d", iLastMerge));
|
|
DC_QUIT;
|
|
}
|
|
|
|
// After the recursion, because the candidate has
|
|
// changed, restart the comparisons to check for
|
|
// overlaps between the adjusted candidate and
|
|
// other existing rectangles.
|
|
fResetRects = TRUE;
|
|
}
|
|
}
|
|
break;
|
|
|
|
default:
|
|
TRC_ERR((TB, "Unrecognised overlap case-%d",
|
|
overlapType));
|
|
break;
|
|
}
|
|
|
|
iExist = (!fResetRects) ? pddShm->ba.bounds[iExist].iNext :
|
|
pddShm->ba.firstRect;
|
|
}
|
|
|
|
// Arriving here means that no overlap was found between the
|
|
// candidate and the existing rectangles.
|
|
// - If the candidate is the original rectangle, add it to the list.
|
|
// - If the candidate is an existing rectangle, it is already in
|
|
// the list.
|
|
if (fRectToAdd)
|
|
BAAddRectList(pCand);
|
|
|
|
// The compare and add processing above is allowed to add a
|
|
// rectangle to the list when there are already BA_MAX_NUM_RECTS
|
|
// (eg. when doing a split or when there is no overlap at all with
|
|
// the existing rectangles) - there is an extra slot for that purpose.
|
|
// If we now have more than BA_MAX_NUM_RECTS rectangles, do a
|
|
// forced merge, so that the next call to this routine has a spare
|
|
// slot.
|
|
fRectMerged = (pddShm->ba.rectsUsed > BA_MAX_ACCUMULATED_RECTS);
|
|
if (fRectMerged) {
|
|
// Start looking for merged rectangles. For each rectangle in the
|
|
// list, compare it with the others, and Determine cost of
|
|
// merging. We want to merge the two rectangles with the minimum
|
|
// area difference, ie that will produce a merged rectangle that
|
|
// covers the least superfluous screen area.
|
|
bestMergeIncrease = 0x7FFFFFFF;
|
|
|
|
// Recalculate the real areas of the current rectangles. We
|
|
// cannot rely upon the current area value since the rect
|
|
// edges may have changed during a merge and the area not
|
|
// recalculated.
|
|
for (iExist = pddShm->ba.firstRect;
|
|
iExist != BA_INVALID_RECT_INDEX;
|
|
iExist = pddShm->ba.bounds[iExist].iNext)
|
|
BARecalcArea(iExist);
|
|
|
|
for (iExist = pddShm->ba.firstRect;
|
|
iExist != BA_INVALID_RECT_INDEX;
|
|
iExist = pddShm->ba.bounds[iExist].iNext) {
|
|
for (iTmp = pddShm->ba.bounds[iExist].iNext;
|
|
iTmp != BA_INVALID_RECT_INDEX;
|
|
iTmp = pddShm->ba.bounds[iTmp].iNext) {
|
|
rectNew.left = min(pddShm->ba.bounds[iExist].coord.left,
|
|
pddShm->ba.bounds[iTmp].coord.left );
|
|
rectNew.top = min(pddShm->ba.bounds[iExist].coord.top,
|
|
pddShm->ba.bounds[iTmp].coord.top );
|
|
rectNew.right = max(pddShm->ba.bounds[iExist].coord.right,
|
|
pddShm->ba.bounds[iTmp].coord.right );
|
|
rectNew.bottom = max(pddShm->ba.bounds[iExist].coord.bottom,
|
|
pddShm->ba.bounds[iTmp].coord.bottom );
|
|
|
|
mergeIncrease = COM_SIZEOF_RECT(rectNew) -
|
|
pddShm->ba.bounds[iExist].area -
|
|
pddShm->ba.bounds[iTmp].area;
|
|
|
|
if (bestMergeIncrease > mergeIncrease) {
|
|
iBestMerge1 = iExist;
|
|
iBestMerge2 = iTmp;
|
|
bestMergeIncrease = mergeIncrease;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Now do the merge.
|
|
// We recalculate the size of the merged rectangle here -
|
|
// alternatively we could remember the size of the best so far
|
|
// in the loop above. The trade off is between calculating
|
|
// twice or copying at least once but probably more than once
|
|
// as we find successively better merges.
|
|
TRC_DBG((TB, "Merge ix %d, (%d,%d,%d,%d)", iBestMerge1,
|
|
pddShm->ba.bounds[iBestMerge1].coord.left,
|
|
pddShm->ba.bounds[iBestMerge1].coord.top,
|
|
pddShm->ba.bounds[iBestMerge1].coord.right,
|
|
pddShm->ba.bounds[iBestMerge1].coord.bottom ));
|
|
|
|
TRC_DBG((TB, "Merge ix %d, (%d,%d,%d,%d)", iBestMerge2,
|
|
pddShm->ba.bounds[iBestMerge2].coord.left,
|
|
pddShm->ba.bounds[iBestMerge2].coord.top,
|
|
pddShm->ba.bounds[iBestMerge2].coord.right,
|
|
pddShm->ba.bounds[iBestMerge2].coord.bottom ));
|
|
|
|
pddShm->ba.bounds[iBestMerge1].coord.left =
|
|
min(pddShm->ba.bounds[iBestMerge1].coord.left,
|
|
pddShm->ba.bounds[iBestMerge2].coord.left);
|
|
pddShm->ba.bounds[iBestMerge1].coord.top =
|
|
min(pddShm->ba.bounds[iBestMerge1].coord.top,
|
|
pddShm->ba.bounds[iBestMerge2].coord.top );
|
|
pddShm->ba.bounds[iBestMerge1].coord.right =
|
|
max(pddShm->ba.bounds[iBestMerge1].coord.right,
|
|
pddShm->ba.bounds[iBestMerge2].coord.right);
|
|
pddShm->ba.bounds[iBestMerge1].coord.bottom =
|
|
max(pddShm->ba.bounds[iBestMerge1].coord.bottom,
|
|
pddShm->ba.bounds[iBestMerge2].coord.bottom);
|
|
|
|
// Remove the second best merge.
|
|
BARemoveRectList(iBestMerge2);
|
|
|
|
// The best merged rectangle becomes the candidate, and we fall
|
|
// back to the head of the comparison loop to start again.
|
|
pCand = &(pddShm->ba.bounds[iBestMerge1].coord);
|
|
iLastMerge = iBestMerge1;
|
|
fRectToAdd = FALSE;
|
|
}
|
|
} while (fRectMerged);
|
|
|
|
|
|
DC_EXIT_POINT:
|
|
DC_END_FN();
|
|
return rc;
|
|
}
|
|
|
|
|
|
#ifdef DC_DEBUG
|
|
/****************************************************************************/
|
|
// BAPerformUnitTests
|
|
//
|
|
// Verifies some basic assumptions of the BA algorithms, in case it breaks
|
|
// while being changed. Performed only on init.
|
|
/****************************************************************************/
|
|
|
|
// Test data. Note that these tests are designed for BA using exclusive rects.
|
|
|
|
typedef struct
|
|
{
|
|
const char *TestName;
|
|
const RECTL *MustBePresent;
|
|
unsigned NumPresent;
|
|
} Validation;
|
|
|
|
// Start with a rect out in the middle area.
|
|
const RECTL Test1StartAdd = { 10, 10, 20, 20 };
|
|
const Validation Test1StartVerify = { "Test1Start", &Test1StartAdd, 1 };
|
|
|
|
// Add a rect of the same height 2 pixels off the right edge of rect1.
|
|
// Should not merge with rect1.
|
|
const RECTL Test1Step1Add = { 21, 10, 31, 20 };
|
|
const RECTL Test1Step1Ver[2] = { { 10, 10, 20, 20 }, { 21, 10, 31, 20 } };
|
|
const Validation Test1Step1Verify = { "Test1Step1", Test1Step1Ver, 2 };
|
|
|
|
// Add a rect of the same width immediately left of but not intersecting
|
|
// with rect1. Should be merged into one large rect.
|
|
const RECTL Test1Step2Add = { 0, 10, 10, 20 };
|
|
const RECTL Test1Step2Ver[2] = { { 0, 10, 20, 20 }, { 21, 10, 31, 20 } };
|
|
const Validation Test1Step2Verify = { "Test1Step2", Test1Step2Ver, 2 };
|
|
|
|
// Add a rect of the same width intersecting rect2 at its top.
|
|
// Should be merged into one large rect.
|
|
const RECTL Test1Step3Add = { 21, 5, 31, 15 };
|
|
const RECTL Test1Step3Ver[2] = { { 0, 10, 20, 20 }, { 21, 5, 31, 20 } };
|
|
const Validation Test1Step3Verify = { "Test1Step3", Test1Step3Ver, 2 };
|
|
|
|
// Add a rect that intersects rect1 at its bottom but is smaller in
|
|
// width and partially enclosed within rect1. Rect should be split,
|
|
// the top half absorbed into rect1, the bottom a new rect.
|
|
const RECTL Test1Step4Add = { 5, 15, 10, 25 };
|
|
const RECTL Test1Step4Ver[3] = {
|
|
{ 0, 10, 20, 20 }, { 21, 5, 31, 20 }, { 5, 20, 10, 25 }
|
|
};
|
|
const Validation Test1Step4Verify = { "Test1Step4", Test1Step4Ver, 3 };
|
|
|
|
|
|
// Worker func to verify the contents of the rects. Returns FALSE if
|
|
// the
|
|
void AddAndValidateRects(const RECTL *pAdd, const Validation *pVal)
|
|
{
|
|
BOOL rc = TRUE;
|
|
RECTL Rects[BA_MAX_ACCUMULATED_RECTS];
|
|
unsigned i, j;
|
|
unsigned NumRects;
|
|
BYTE RectFound[BA_MAX_ACCUMULATED_RECTS] = { 0 };
|
|
RECTL Add;
|
|
|
|
DC_BEGIN_FN("AddAndValidateRects");
|
|
|
|
// Make a copy of *pAdd since BAAddRect can modify it.
|
|
Add = *pAdd;
|
|
BAAddRect(&Add, 0);
|
|
BACopyBounds(Rects, &NumRects);
|
|
TRC_ASSERT((NumRects == pVal->NumPresent),
|
|
(TB,"%s failure: NumRects=%u, should be %u", pVal->TestName,
|
|
NumRects, pVal->NumPresent));
|
|
|
|
for (i = 0; i < NumRects; i++) {
|
|
for (j = 0; j < NumRects; j++) {
|
|
if (!memcmp(&Rects[i], &pVal->MustBePresent[j], sizeof(RECTL)))
|
|
RectFound[j] = TRUE;
|
|
}
|
|
}
|
|
|
|
for (i = 0; i < NumRects; i++) {
|
|
if (!RectFound[i]) {
|
|
TRC_ERR((TB,"BA validation error, rects:"));
|
|
for (j = 0; j < NumRects; j++)
|
|
TRC_ERR((TB," %u: (%u,%u,%u,%u)", j, Rects[j].left,
|
|
Rects[j].top, Rects[j].right, Rects[j].bottom));
|
|
TRC_ASSERT((RectFound[i]),(TB,"%s failure: MustBePresent rect %u "
|
|
"was not present", pVal->TestName, i));
|
|
}
|
|
}
|
|
|
|
DC_END_FN();
|
|
}
|
|
|
|
|
|
// The real function.
|
|
void BAPerformUnitTests()
|
|
{
|
|
RECTL Rect1, Rect2;
|
|
|
|
DC_BEGIN_FN("BAPerformUnitTests");
|
|
|
|
// Test1.
|
|
AddAndValidateRects(&Test1StartAdd, &Test1StartVerify);
|
|
AddAndValidateRects(&Test1Step1Add, &Test1Step1Verify);
|
|
AddAndValidateRects(&Test1Step2Add, &Test1Step2Verify);
|
|
AddAndValidateRects(&Test1Step3Add, &Test1Step3Verify);
|
|
AddAndValidateRects(&Test1Step4Add, &Test1Step4Verify);
|
|
|
|
}
|
|
#endif // DC_DEBUG
|
|
|