Aren/haiku
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

* complete reimplementation of BRegion and it's backend

Browse Source 
I "ported" the region implementation from XOrg to work on BRegion data.

This resulted in pretty much the same code structure as before, with 
RegionSupport.cpp containing the messy details. Only now it _is_ really messy
from a code beauty point of view. I didn't exactly feel like cleaning it
up right now... but I guess I will have to.

So what does this mean - our BRegion implementation was very slow (no offense!),
and on top of that it scaled very badly with more and more rects. The new
implementation seems to be on par with the very fast R5 implementation and
the data looks exactly the same too. BRegion is very performance critical
for the app_server, and I cannot wait to try this on my slow computer...

Some changes are noteworthy: The right and bottom coordinates of
BRegion internal data are now exclusive! I inherited that from the
XOrg implementation and didn't feel like changing the code, seeing it
is probably tested quite well. The conversion is handled transparently.

Secondly, constructing a BRegion with just one rect is not invoking
malloc anymore for the member data, this makes it much more efficient
to use temporary BRegions with just one rect, both externally and internally
in the BRegion implementation.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@21665 a95241bf-73f2-0310-859d-f6bbb57e9c96
This commit is contained in:
Stephan Aßmus 2007-07-19 17:06:28 +00:00
parent 89369ed1ab
commit 582da17386
9 changed files with 1974 additions and 1250 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

111
headers/os/interface/Region.h
View File

@ -1,13 +1,7 @@
/*******************************************************************************
/
/ File: Region.h
/
/ Description: BRegion represents an area that's composed of individual
/ rectangles.
/
/ Copyright 1992-98, Be Incorporated, All Rights Reserved
/
*******************************************************************************/
/*
* Copyright 2007, Haiku. All rights reserved.
* Distributed under the terms of the MIT License.
*/
#ifndef _REGION_H
#define _REGION_H
@ -30,57 +24,70 @@ typedef struct {
} clipping_rect;
/*----- BRegion class --------------------------------------------*/
class BRegion {
public:
BRegion();
BRegion(const BRegion &region);
BRegion(const BRect rect);
virtual ~BRegion();
public:
BRegion();
BRegion(const BRegion& region);
BRegion(const BRect rect);
virtual ~BRegion();
BRegion &operator=(const BRegion &from);
BRegion &operator=(const BRegion &from);
BRect Frame() const;
clipping_rect FrameInt() const;
BRect RectAt(int32 index);
clipping_rect RectAtInt(int32 index);
int32 CountRects();
void Set(BRect newBounds);
void Set(clipping_rect newBounds);
bool Intersects(BRect r) const;
bool Intersects(clipping_rect r) const;
bool Contains(BPoint pt) const;
bool Contains(int32 x, int32 y);
void PrintToStream() const;
void OffsetBy(int32 dh, int32 dv);
void MakeEmpty();
void Include(BRect r);
void Include(clipping_rect r);
void Include(const BRegion*);
void Exclude(BRect r);
void Exclude(clipping_rect r);
void Exclude(const BRegion*);
void IntersectWith(const BRegion*);
void Set(BRect newBounds);
void Set(clipping_rect newBounds);
/*----- Private or reserved -----------------------------------------*/
class Support;
BRect Frame() const;
clipping_rect FrameInt() const;
private:
friend class BView;
BRect RectAt(int32 index) /*const*/;
clipping_rect RectAtInt(int32 index) /*const*/;
int32 CountRects() /*const*/;
bool Intersects(BRect rect) const;
bool Intersects(clipping_rect rect) const;
bool Contains(BPoint point) const;
bool Contains(int32 x, int32 y) /*const*/;
void PrintToStream() const;
void OffsetBy(int32 x, int32 y);
void MakeEmpty();
void Include(BRect rect);
void Include(clipping_rect rect);
void Include(const BRegion*);
void Exclude(BRect r);
void Exclude(clipping_rect r);
void Exclude(const BRegion* region);
void IntersectWith(const BRegion* region);
private:
friend class BDirectWindow;
friend class Support;
friend class BPrivate::ServerLink;
friend class BPrivate::LinkReceiver;
void _AddRect(clipping_rect r);
void set_size(long new_size);
class Support;
friend class Support;
private:
long count;
long data_size;
clipping_rect bound;
clipping_rect *data;
private:
BRegion(const clipping_rect& rect);
void _AdoptRegionData(BRegion& region);
bool _SetSize(long newSize);
clipping_rect _Convert(const BRect& rect) const;
clipping_rect _ConvertToInternal(const BRect& rect) const;
private:
long fCount;
long fDataSize;
clipping_rect fBounds;
clipping_rect* fData;
};
#endif /* _REGION_H */
#endif // _REGION_H

12
src/kits/app/LinkReceiver.cpp
View File

@ -402,12 +402,16 @@ err:
status_t
LinkReceiver::ReadRegion(BRegion* region)
{
status_t status = Read(&region->count, sizeof(int32));
status_t status = Read(&region->fCount, sizeof(int32));
if (status >= B_OK)
status = Read(&region->bound, sizeof(clipping_rect));
status = Read(&region->fBounds, sizeof(clipping_rect));
if (status >= B_OK) {
region->set_size(region->count);
status = Read(region->data, region->count * sizeof(clipping_rect));
if (!region->_SetSize(region->fCount))
status = B_NO_MEMORY;
else {
status = Read(region->fData,
region->fCount * sizeof(clipping_rect));
}
if (status < B_OK)
region->MakeEmpty();
}

17
src/kits/app/ServerLink.cpp
View File

@ -34,19 +34,22 @@ ServerLink::~ServerLink()
status_t
ServerLink::ReadRegion(BRegion *region)
{
fReceiver->Read(&region->count, sizeof(long));
fReceiver->Read(&region->bound, sizeof(clipping_rect));
region->set_size(region->count + 1);
return fReceiver->Read(region->data, region->count * sizeof(clipping_rect));
fReceiver->Read(&region->fCount, sizeof(long));
fReceiver->Read(&region->fBounds, sizeof(clipping_rect));
if (!region->_SetSize(region->fCount))
return B_NO_MEMORY;
return fReceiver->Read(region->fData,
region->fCount * sizeof(clipping_rect));
}
status_t
ServerLink::AttachRegion(const BRegion &region)
{
fSender->Attach(&region.count, sizeof(long));
fSender->Attach(&region.bound, sizeof(clipping_rect));
return fSender->Attach(region.data, region.count * sizeof(clipping_rect));
fSender->Attach(&region.fCount, sizeof(long));
fSender->Attach(&region.fBounds, sizeof(clipping_rect));
return fSender->Attach(region.fData,
region.fCount * sizeof(clipping_rect));
}

11
src/kits/game/DirectWindow.cpp
View File

@ -303,11 +303,14 @@ BDirectWindow::GetClippingRegion(BRegion *region, BPoint *origin) const
// Otherwise, we would need to call BRegion::Include(clipping_rect)
// for every clipping_rect in our clip_list, and that would be much
// more overkill than this (tested ).
region->set_size(fBufferDesc->clip_list_count);
region->count = fBufferDesc->clip_list_count;
region->bound = fBufferDesc->clip_bounds;
if (!region->_SetSize(fBufferDesc->clip_list_count)) {
UnlockDirect();
return B_NO_MEMORY;
}
region->fCount = fBufferDesc->clip_list_count;
region->fBounds = fBufferDesc->clip_bounds;
for (uint32 c = 0; c < fBufferDesc->clip_list_count; c++)
region->data[c] = fBufferDesc->clip_list[c];
region->fData[c] = fBufferDesc->clip_list[c];
// adjust bounds by the given origin point
region->OffsetBy(-originX, -originY);

606
src/kits/interface/Region.cpp
View File

@ -1,90 +1,50 @@
//------------------------------------------------------------------------------
// Copyright (c) 2003-2005, Haiku, Inc.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the "Software"),
// to deal in the Software without restriction, including without limitation
// the rights to use, copy, modify, merge, publish, distribute, sublicense,
// and/or sell copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
// DEALINGS IN THE SOFTWARE.
//
// File Name: Region.cpp
// Author: Stefano Ceccherini (burton666@libero.it)
// Description: Region class consisting of multiple rectangles
//
//------------------------------------------------------------------------------
/*
* Copyright 2003-2007, Haiku. All rights reserved.
* Distributed under the terms of the MIT License.
*
* Authors:
* Stefano Ceccherini (burton666@libero.it)
* Stephan Aßmus <superstippi@gmx.de>
*/
// Notes: As now, memory is always allocated and never freed (except on destruction,
// or sometimes when a copy is made).
// This let us be a bit faster since we don't do many reallocations.
// But that means that even an empty region could "waste" much space, if it contained
// many rects before being emptied.
// I.E: a region which contains 24 rects allocates more than 24 * 4 * sizeof(int32)
// = 96 * sizeof(int32) bytes. If we call MakeEmpty(), that region will contain no rects,
// but it will still keep the allocated memory.
// This shouldnt' be an issue, since usually BRegions are just used for calculations,
// and don't last so long.
// Anyway, we can change that behaviour if we want, but BeOS's BRegion seems to behave exactly
// like this.
#include <cstdlib>
#include <cstring>
#include <Debug.h>
#include <Region.h>
#include <clipping.h>
#include <RegionSupport.h>
#include <malloc.h>
#include <string.h>
#include <Debug.h>
#include "clipping.h"
#include "RegionSupport.h"
const static int32 kInitialDataSize = 8;
const static int32 kDataBlockSize = 8;
/*! \brief Initializes a region. The region will have no rects,
and its bound will be invalid.
and its fBounds will be invalid.
*/
BRegion::BRegion()
:
data_size(0),
data(NULL)
: fCount(0)
, fDataSize(0)
, fBounds((clipping_rect){ 0, 0, 0, 0 })
, fData(NULL)
{
data = (clipping_rect *)malloc(kInitialDataSize * sizeof(clipping_rect));
if (data != NULL)
data_size = kInitialDataSize;
Support::ZeroRegion(*this);
_SetSize(kDataBlockSize);
}
/*! \brief Initializes a region to be a copy of another.
\param region The region to copy.
*/
BRegion::BRegion(const BRegion &region)
:
data_size(0),
data(NULL)
BRegion::BRegion(const BRegion& region)
: fCount(0)
, fDataSize(0)
, fBounds((clipping_rect){ 0, 0, 0, 0 })
, fData(NULL)
{
const int32 size = region.data_size > 0 ? region.data_size : 1;
data = (clipping_rect *)malloc(size * sizeof(clipping_rect));
if (data != NULL) {
data_size = size;
bound = region.bound;
count = region.count;
memcpy(data, region.data, count * sizeof(clipping_rect));
} else
Support::ZeroRegion(*this);
*this = region;
}
@ -92,16 +52,28 @@ BRegion::BRegion(const BRegion &region)
\param rect The BRect to set the region to.
*/
BRegion::BRegion(const BRect rect)
:
data_size(0),
data(NULL)
: fCount(0)
, fDataSize(1)
, fBounds((clipping_rect){ 0, 0, 0, 0 })
, fData(&fBounds)
{
if (!rect.IsValid())
return;
fBounds = _ConvertToInternal(rect);
fCount = 1;
}
// NOTE: private constructor
/*! \brief Initializes a region to contain a clipping_rect.
\param rect The BRect to set the region to.
*/
BRegion::BRegion(const clipping_rect& rect)
: fCount(1)
, fDataSize(1)
, fBounds(rect)
, fData(&fBounds)
{
data = (clipping_rect *)malloc(kInitialDataSize * sizeof(clipping_rect));
if (data != NULL) {
data_size = kInitialDataSize;
Set(rect);
} else
Support::ZeroRegion(*this);
}
@ -109,68 +81,34 @@ BRegion::BRegion(const BRect rect)
*/
BRegion::~BRegion()
{
free(data);
if (fData != &fBounds)
free(fData);
}
/*! \brief Returns the bounds of the region.
\return A BRect which represents the bounds of the region.
// #pragma mark -
/*! \brief Modifies the region to be a copy of the given BRegion.
\param region the BRegion to copy.
\return This function always returns \c *this.
*/
BRect
BRegion::Frame() const
BRegion &
BRegion::operator=(const BRegion &region)
{
return to_BRect(bound);
}
if (&region == this)
return *this;
// handle reallocation if we're too small to contain
// the other region
if (_SetSize(region.fDataSize)) {
memcpy(fData, region.fData, region.fCount * sizeof(clipping_rect));
/*! \brief Returns the bounds of the region as a clipping_rect (which has integer coordinates).
\return A clipping_rect which represents the bounds of the region.
*/
clipping_rect
BRegion::FrameInt() const
{
return bound;
}
/*! \brief Returns the regions's BRect at the given index.
\param index The index (zero based) of the wanted rectangle.
\return If the given index is valid, it returns the BRect at that index,
otherwise, it returns an invalid BRect.
*/
BRect
BRegion::RectAt(int32 index)
{
if (index >= 0 && index < count)
return to_BRect(data[index]);
fBounds = region.fBounds;
fCount = region.fCount;
}
return BRect(); //An invalid BRect
}
/*! \brief Returns the regions's clipping_rect at the given index.
\param index The index (zero based) of the wanted rectangle.
\return If the given index is valid, it returns the clipping_rect at that index,
otherwise, it returns an invalid clipping_rect.
*/
clipping_rect
BRegion::RectAtInt(int32 index)
{
if (index >= 0 && index < count)
return data[index];
clipping_rect rect = { 1, 1, 0, 0 };
return rect;
}
/*! \brief Counts the region rects.
\return An int32 which is the total number of rects in the region.
*/
int32
BRegion::CountRects()
{
return count;
return *this;
}
@ -180,7 +118,7 @@ BRegion::CountRects()
void
BRegion::Set(BRect newBounds)
{
Set(to_clipping_rect(newBounds));
Set(_Convert(newBounds));
}
@ -190,17 +128,93 @@ BRegion::Set(BRect newBounds)
void
BRegion::Set(clipping_rect newBounds)
{
ASSERT(data_size > 0);
_SetSize(1);
if (valid_rect(newBounds)) {
count = 1;
data[0] = newBounds;
bound = newBounds;
if (valid_rect(newBounds) && fData) {
fCount = 1;
// cheap convert to internal rect format
newBounds.right++;
newBounds.bottom++;
fData[0] = fBounds = newBounds;
} else
Support::ZeroRegion(*this);
MakeEmpty();
}
// #pragma mark -
/*! \brief Returns the bounds of the region.
\return A BRect which represents the bounds of the region.
*/
BRect
BRegion::Frame() const
{
return BRect(fBounds.left, fBounds.top,
fBounds.right - 1, fBounds.bottom - 1);
}
/*! \brief Returns the bounds of the region as a clipping_rect (which has integer coordinates).
\return A clipping_rect which represents the bounds of the region.
*/
clipping_rect
BRegion::FrameInt() const
{
return (clipping_rect){ fBounds.left, fBounds.top,
fBounds.right - 1, fBounds.bottom - 1 };
}
/*! \brief Returns the regions's BRect at the given index.
\param index The index (zero based) of the wanted rectangle.
\return If the given index is valid, it returns the BRect at that index,
otherwise, it returns an invalid BRect.
*/
BRect
BRegion::RectAt(int32 index) /*const*/
{
if (index >= 0 && index < fCount) {
const clipping_rect& r = fData[index];
return BRect(r.left, r.top, r.right - 1, r.bottom - 1);
}
return BRect();
// an invalid BRect
}
/*! \brief Returns the regions's clipping_rect at the given index.
\param index The index (zero based) of the wanted rectangle.
\return If the given index is valid, it returns the clipping_rect at that index,
otherwise, it returns an invalid clipping_rect.
*/
clipping_rect
BRegion::RectAtInt(int32 index) /*const*/
{
if (index >= 0 && index < fCount) {
const clipping_rect& r = fData[index];
return (clipping_rect){ r.left, r.top, r.right - 1, r.bottom - 1 };
}
return (clipping_rect){ 1, 1, 0, 0 };
// an invalid clipping_rect
}
/*! \brief Counts the region rects.
\return An int32 which is the total number of rects in the region.
*/
int32
BRegion::CountRects() /*const*/
{
return fCount;
}
// #pragma mark -
/*! \brief Check if the region has any area in common with the given BRect.
\param rect The BRect to check the region against to.
\return \ctrue if the region has any area in common with the BRect, \cfalse if not.
@ -208,7 +222,7 @@ BRegion::Set(clipping_rect newBounds)
bool
BRegion::Intersects(BRect rect) const
{
return Intersects(to_clipping_rect(rect));
return Intersects(_Convert(rect));
}
@ -219,15 +233,13 @@ BRegion::Intersects(BRect rect) const
bool
BRegion::Intersects(clipping_rect rect) const
{
if (!rects_intersect(rect, bound))
return false;
// cheap convert to internal rect format
rect.right ++;
rect.bottom ++;
for (long c = 0; c < count; c++) {
if (rects_intersect(data[c], rect))
return true;
}
return false;
int result = Support::XRectInRegion(this, rect);
return result > Support::RectangleOut;
}
@ -236,18 +248,9 @@ BRegion::Intersects(clipping_rect rect) const
\return \ctrue if the region contains the BPoint, \cfalse if not.
*/
bool
BRegion::Contains(BPoint pt) const
BRegion::Contains(BPoint point) const
{
// If the point doesn't lie within the region's bounds,
// don't even try it against the region's rects.
if (!point_in(bound, pt))
return false;
for (long c = 0; c < count; c++) {
if (point_in(data[c], pt))
return true;
}
return false;
return Support::XPointInRegion(this, (int)point.x, (int)point.y);
}
@ -257,17 +260,9 @@ BRegion::Contains(BPoint pt) const
\return \ctrue if the region contains the point, \cfalse if not.
*/
bool
BRegion::Contains(int32 x, int32 y)
BRegion::Contains(int32 x, int32 y) /*const*/
{
// see above
if (!point_in(bound, x, y))
return false;
for (long c = 0; c < count; c++) {
if (point_in(data[c], x, y))
return true;
}
return false;
return Support::XPointInRegion(this, x, y);
}
@ -277,30 +272,35 @@ void
BRegion::PrintToStream() const
{
Frame().PrintToStream();
for (long c = 0; c < count; c++) {
clipping_rect *rect = &data[c];
printf("data = BRect(l:%ld.0, t:%ld.0, r:%ld.0, b:%ld.0)\n",
rect->left, rect->top, rect->right, rect->bottom);
}
for (long i = 0; i < fCount; i++) {
clipping_rect *rect = &fData[i];
printf("data[%ld] = BRect(l:%ld.0, t:%ld.0, r:%ld.0, b:%ld.0)\n",
i, rect->left, rect->top, rect->right - 1, rect->bottom - 1);
}
}
// #pragma mark -
/*! \brief Offsets all region's rects, and bounds by the given values.
\param dh The horizontal offset.
\param dv The vertical offset.
*/
void
BRegion::OffsetBy(int32 dh, int32 dv)
BRegion::OffsetBy(int32 x, int32 y)
{
if (dh == 0 && dv == 0)
if (x == 0 && y == 0)
return;
if (count > 0) {
for (long c = 0; c < count; c++)
offset_rect(data[c], dh, dv);
if (fCount > 0) {
if (fData != &fBounds) {
for (long i = 0; i < fCount; i++)
offset_rect(fData[i], x, y);
}
offset_rect(bound, dh, dv);
offset_rect(fBounds, x, y);
}
}
@ -310,17 +310,21 @@ BRegion::OffsetBy(int32 dh, int32 dv)
void
BRegion::MakeEmpty()
{
Support::ZeroRegion(*this);
fBounds= (clipping_rect){ 0, 0, 0, 0 };
fCount = 0;
}
// #pragma mark -
/*! \brief Modifies the region, so that it includes the given BRect.
\param rect The BRect to be included by the region.
*/
void
BRegion::Include(BRect rect)
{
Include(to_clipping_rect(rect));
Include(_Convert(rect));
}
@ -330,13 +334,17 @@ BRegion::Include(BRect rect)
void
BRegion::Include(clipping_rect rect)
{
BRegion region;
BRegion newRegion;
// convert to internal rect format
rect.right ++;
rect.bottom ++;
region.Set(rect);
Support::OrRegion(*this, region, newRegion);
Support::CopyRegion(newRegion, *this);
// use private clipping_rect constructor which avoids malloc()
BRegion t(rect);
BRegion result;
Support::XUnionRegion(this, &t, &result);
_AdoptRegionData(result);
}
@ -344,22 +352,25 @@ BRegion::Include(clipping_rect rect)
\param region The region to be included.
*/
void
BRegion::Include(const BRegion *region)
BRegion::Include(const BRegion* region)
{
BRegion newRegion;
Support::OrRegion(*this, *region, newRegion);
Support::CopyRegion(newRegion, *this);
BRegion result;
Support::XUnionRegion(this, region, &result);
_AdoptRegionData(result);
}
// #pragma mark -
/*! \brief Modifies the region, excluding the area represented by the given BRect.
\param rect The BRect to be excluded.
*/
void
BRegion::Exclude(BRect rect)
{
Exclude(to_clipping_rect(rect));
Exclude(_Convert(rect));
}
@ -369,152 +380,125 @@ BRegion::Exclude(BRect rect)
void
BRegion::Exclude(clipping_rect rect)
{
BRegion region;
BRegion newRegion;
region.Set(rect);
// convert to internal rect format
rect.right ++;
rect.bottom ++;
Support::SubRegion(*this, region, newRegion);
Support::CopyRegion(newRegion, *this);
// use private clipping_rect constructor which avoids malloc()
BRegion t(rect);
BRegion result;
Support::XSubtractRegion(this, &t, &result);
_AdoptRegionData(result);
}
/*! \brief Modifies the region, excluding the area contained in the given BRegion.
/*! \brief Modifies the region, excluding the area contained in the given
BRegion.
\param region The BRegion to be excluded.
*/
void
BRegion::Exclude(const BRegion *region)
BRegion::Exclude(const BRegion* region)
{
BRegion newRegion;
Support::SubRegion(*this, *region, newRegion);
Support::CopyRegion(newRegion, *this);
BRegion result;
Support::XSubtractRegion(this, region, &result);
_AdoptRegionData(result);
}
/*! \brief Modifies the region, so that it will contain just the area in common with the given BRegion.
// #pragma mark -
/*! \brief Modifies the region, so that it will contain just the area
in common with the given BRegion.
\param region the BRegion to intersect to.
*/
void
BRegion::IntersectWith(const BRegion *region)
BRegion::IntersectWith(const BRegion* region)
{
BRegion newRegion;
Support::AndRegion(*this, *region, newRegion);
Support::CopyRegion(newRegion, *this);
BRegion result;
Support::XIntersectRegion(this, region, &result);
_AdoptRegionData(result);
}
/*! \brief Modifies the region to be a copy of the given BRegion.
\param region the BRegion to copy.
\return This function always returns \c *this.
*/
BRegion &
BRegion::operator=(const BRegion &region)
{
if (&region != this) {
bound = region.bound;
count = region.count;
// handle reallocation if we're too small to contain
// the other region
set_size(region.data_size);
// TODO: what is this supposed to do??
if (data_size <= 0)
data_size = 1;
if (data)
memcpy(data, region.data, count * sizeof(clipping_rect));
}
return *this;
}
// #pragma mark -
/*! \brief Adds a rect to the region.
\param rect The clipping_rect to be added.
Adds the given rect to the region, merging it with another already contained in the region,
if possible. Recalculate the region's bounds if needed.
/*! \brief Takes over the data of a region and marks that region empty.
\param region The region to adopt the data from.
*/
void
BRegion::_AddRect(clipping_rect rect)
BRegion::_AdoptRegionData(BRegion& region)
{
ASSERT(count >= 0);
ASSERT(data_size >= 0);
ASSERT(valid_rect(rect));
fCount = region.fCount;
fDataSize = region.fDataSize;
fBounds = region.fBounds;
if (fData != &fBounds)
free(fData);
if (region.fData != &region.fBounds)
fData = region.fData;
else
fData = &fBounds;
// Should we just reallocate the memory and
// copy the rect ?
bool addRect = true;
if (count > 0) {
// Wait! We could merge the rect with one of the
// existing rectangles, if it's adiacent.
// We just check it against the last rectangle, since
// we are keeping them sorted by their "top" coordinates.
long last = count - 1;
if (rect.left == data[last].left && rect.right == data[last].right
&& rect.top == data[last].bottom + 1) {
data[last].bottom = rect.bottom;
addRect = false;
} else if (rect.top == data[last].top && rect.bottom == data[last].bottom) {
if (rect.left == data[last].right + 1) {
data[last].right = rect.right;
addRect = false;
} else if (rect.right == data[last].left - 1) {
data[last].left = rect.left;
addRect = false;
}
}
}
// We weren't lucky.... just add the rect as a new one
if (addRect) {
if (data_size <= count)
set_size(count + 16);
data[count] = rect;
count++;
}
// Recalculate bounds
if (rect.top < bound.top)
bound.top = rect.top;
if (rect.left < bound.left)
bound.left = rect.left;
if (rect.right > bound.right)
bound.right = rect.right;
if (rect.bottom > bound.bottom)
bound.bottom = rect.bottom;
// NOTE: MakeEmpty() is not called since _AdoptRegionData is only
// called with internally allocated regions, so they don't need to
// be left in a valid state.
region.fData = NULL;
// region.MakeEmpty();
}
/*! \brief Reallocate the memory in the region.
\param new_size The amount of rectangles that the region could contain.
\param newSize The amount of rectangles that the region should be
able to hold.
*/
void
BRegion::set_size(long new_size)
bool
BRegion::_SetSize(long newSize)
{
if (new_size <= 0)
new_size = data_size + 16;
// we never shrink the size
newSize = max_c(fDataSize, newSize);
if (newSize == fDataSize)
return true;
// align newSize to multiple of kDataBlockSize
newSize = ((newSize + kDataBlockSize - 1) / kDataBlockSize) * kDataBlockSize;
if (newSize > 0) {
if (fData == &fBounds) {
fData = (clipping_rect*)malloc(newSize * sizeof(clipping_rect));
fData[0] = fBounds;
} else if (fData)
fData = (clipping_rect*)realloc(fData, newSize * sizeof(clipping_rect));
else
fData = (clipping_rect*)malloc(newSize * sizeof(clipping_rect));
}
data = (clipping_rect *)realloc(data, new_size * sizeof(clipping_rect));
if (data == NULL)
debugger("BRegion::set_size realloc error\n");
data_size = new_size;
ASSERT(count <= data_size);
if (!fData || newSize <= 0) {
fDataSize = 0;
MakeEmpty();
return false;
}
fDataSize = newSize;
return true;
}
clipping_rect
BRegion::_Convert(const BRect& rect) const
{
return (clipping_rect){ (int)floorf(rect.left), (int)floorf(rect.top),
(int)ceilf(rect.right), (int)ceilf(rect.bottom) };
}
clipping_rect
BRegion::_ConvertToInternal(const BRect& rect) const
{
return (clipping_rect){ (int)floorf(rect.left), (int)floorf(rect.top),
(int)ceilf(rect.right) + 1, (int)ceilf(rect.bottom) + 1 };
}

2461
src/kits/interface/RegionSupport.cpp
View File

File diff suppressed because it is too large Load Diff

2
src/servers/app/ServerWindow.cpp
View File

@ -1671,7 +1671,7 @@ ServerWindow::_DispatchViewMessage(int32 code,
// invalidate view - but only if this is a non-overlay switch
if (bitmap == NULL || bitmap->Overlay() == NULL || !wasOverlay) {
BRegion dirty(fCurrentLayer->Bounds());
BRegion dirty((BRect)fCurrentLayer->Bounds());
fWindowLayer->InvalidateView(fCurrentLayer, dirty);
}

2
src/servers/app/ViewLayer.cpp
View File

@ -107,7 +107,7 @@ ViewLayer::ViewLayer(IntRect frame, IntPoint scrollingOffset, const char* name,
fCursor(NULL),
fPicture(NULL),
fLocalClipping(Bounds()),
fLocalClipping((BRect)Bounds()),
fScreenClipping(),
fScreenClippingValid(false)
{

2
src/servers/app/WorkspacesLayer.cpp
View File

@ -288,7 +288,7 @@ WorkspacesLayer::_DarkenColor(RGBColor& color) const
void
WorkspacesLayer::_Invalidate() const
{
BRegion region(Frame());
BRegion region((BRect)Frame());
Window()->MarkContentDirty(region);
}