DocRect Class Reference

This class is used to represent a rectangular region. It uses a union to enable the client to access the rectangle as two DocCoords (lo and hi) or as four INT32s (lox, loy, hix, hiy). An anonymous union is used, which is a defined C++ feature and so portable. More...

#include <docrect.h>

List of all members.

Public Member Functions
	DocRect ()
	To construct an empty DocRect.
	DocRect (INT32 LowX, INT32 LowY, INT32 HighX, INT32 HighY)
	To construct a DocRect with an inclusive lower left hand corner position of (Left, Lower) and an exclusive upper right hand corner position of (Right, Upper).
	DocRect (const DocCoord &Low, UINT32 Width, UINT32 Height)
	To construct a rectangle with an inclusive lower left hand corner position of Low and a width and height as specified.
	DocRect (const DocCoord &Low, const DocCoord &High)
	To construct a rectangle with an inclusive lower left hand corner position of Low and an exclusive upper right hand corner position of High.
	DocRect (const DocRect &DocRect)
	Copy constructor.
DocRect &	operator= (const DocRect &DocRect)
	Equals operator.
INT32	Width () const
	To find the width of the DocRect.
INT32	Height () const
	To find the height of the DocRect.
DocCoord	LowCorner () const
	To find the lower left hand coordinates of the DocRect.
DocCoord	HighCorner () const
	To find the upper right hand coordinates of the DocRect.
DocCoord	Centre () const
	To find the centre of the DocRect It calculates DocCoord(lox+(width/2),loy+(height/2)).
BOOL	IsIntersectedWith (const DocRect &) const
	To check for rectangle intersection.
DocRect	Intersection (const DocRect &) const
	Compute intersection of two rectangles.
DocRect	Union (const DocRect &) const
	Compute union of two rectangles.
INT32	SplitRect (const DocRect &R, DocRect *SubRects)
	Splits a rectangle into sub-rectangles which all exclude the interecting rectangle R. The number of sub-rects generated depends on how the rectangles intersect. _______________________ ___________________ | | | | | *this A | | *this A | |_ _ _ ________ _ _ _ | |_ _ _ _ _ ________|__________ | | | | | | | | | B | R | C | | B | | | |_ _ _ |________| _ _ _ | |__________|________| R | | | | | | D Index=4 | | Index=2 | |_______________________| |___________________|.
BOOL	ContainsCoord (const DocCoord &) const
	To check for coordinate containment.
BOOL	ContainsRectCoord (const DocCoord &) const
	To check for coordinate containment. This will work for coordinates which have been extracted from other rectangles (i.e. the top right corner is considered inclusive for this operation, not exclusive).
BOOL	ContainsRect (const DocRect &) const
	To check for rectangle containment.
BOOL	IsAdjacent (const DocRect &, MILLIPOINT Fuzzy) const
	To check for adjacent rectangles.
void	MakeEmpty ()
	Make the rectangle an empty one (all coordinates are set to 0).
BOOL	IsEmpty () const
	To check for empty rectangle.
BOOL	IsValid () const
	To check for a valid rectangle.
void	Inflate (INT32 XInc, INT32 YInc)
	Inflate a rectangle by given amounts. Negative values will deflate the rectangle.
void	Inflate (INT32 XInc)
	Inflate a rectangle by given amount. Negative values will deflate the rectangle.
void	Translate (INT32 XOfs, INT32 YOfs)
	Translate a rectangle by given offset.
void	IncludePoint (const DocCoord &)
	Expand a rectangle so that it includes the given point.
INT32	operator== (const DocRect &) const
	Test for equality of two rectangles. As all invalid rectangles have the same results when used for Union/Intersection, any two invalid rectangles are considered equal.
INT32	operator!= (const DocRect &) const
	Test for inequality of two rectangles. As all invalid rectangles have the same results when used for Union/Intersection, any two invalid rectangles are considered equal.
DocRect	ToSpread (Spread *pSpread, View *pView)
	Convert a DocRect to a SpreadRect (AKA DocRect).
DocRect	ToDoc (Spread *pSpread, View *pView)
	Convert a SpreadRect (AKA DocRect) to a DocRect.
UserRect	ToUser (Spread *pSpread)
	Convert a SpreadRect (AKA DocRect) to a UserRect.
OilRect	ToOil (Spread *pSpread, View *pView)
	Convert a SpreadRect (AKA DocRect) to an OilRect.
Public Attributes
DocCoord	lo
DocCoord	hi

---

Detailed Description

This class is used to represent a rectangular region. It uses a union to enable the client to access the rectangle as two DocCoords (lo and hi) or as four INT32s (lox, loy, hix, hiy). An anonymous union is used, which is a defined C++ feature and so portable.

Author:

Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 11/5/93

The lo coordinates are inclusive, whilst the hi coordinates are exclusive. In the document space, lo.y <= hi.y and lo.x <= hi.x (the inequalities are not strict because rectangles can have zero width and/or height - such rectangles are considered perfectly valid).

The inclusivity can be explained as follows:

A point at (lo.x, lo.y) is inside the rectangle A point at (hi.x, hi.y) is outside the rectangle

Any rectangle that does not obey the inequalites lo.y <= hi.y and lo.x <= hi.x is deemed to be 'invalid'. Invalid rectangles have special properties. They will cause errors when used in some operations, but not in others. The general rule is that if the rectangle is used as an entity, then the operation will succeed (taking account of the 'invalidity' of the rectangle). If, however, the actual coordinates of the invalid rectangle must be used/changed in the operation, then an error (usually an assertion failure) will occur.

For example, using invalid rectangles in Unions and Intersections is ok, because the invalid rectangle is ignored, and the 'other' rectangle is returned as the result. This means that if both rectangles are invalid, then an invalid rectangle is returned.

Conversely, trying to use operations like Translate(), Inflate(), Width() or Height() on invalid rectangles is considered to be an error, and will cause an assertion failure.

See the individual function descriptions for more details.

Returns:

Errors: -

See also:

DocCoord

Rect

DocRect

WorkRect

OSRect

Definition at line 165 of file docrect.h.

---

Constructor & Destructor Documentation

DocRect::DocRect (   )  [inline]

To construct an empty DocRect. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 13/5/93 Parameters: None  [INPUTS] -  [OUTPUTS] Returns: - Errors: Definition at line 411 of file docrect.h. { // An empty rectangle hi.x = hi.y = lo.x = lo.y = 0; }

DocRect::DocRect (  INT32  LowX, INT32  LowY, INT32  HighX, INT32  HighY )  [inline]

To construct a DocRect with an inclusive lower left hand corner position of (Left, Lower) and an exclusive upper right hand corner position of (Right, Upper). Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 13/5/93 Parameters: LowX  : Lower X coord of rectangle (inclusive) [INPUTS] HighX: Higher X coord of rectangle (exclusive) LowY : Lower Y coord of rectangle (inclusive) HighY: Higher Y coord of rectangle (exclusive) -  [OUTPUTS] Returns: - Errors: An assertion failure will occur if the lower left hand coordinates are not lower than and to the left of the upper right coordinate. Definition at line 442 of file docrect.h. { // Defensive programming, detect an invalid rectangle ENSURE((LowX <= HighX) && (LowY <= HighY), "DocRect::DocRect(INT32, INT32, INT32, INT32) was\n passed invalid coordinates"); lo.x = LowX; lo.y = LowY; hi.x = HighX; hi.y = HighY; }

DocRect::DocRect (  const DocCoord &  Low, UINT32  Width, UINT32  Height )  [inline]

To construct a rectangle with an inclusive lower left hand corner position of Low and a width and height as specified. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 17/5/93 Parameters: Low,:  DocCoordinates of the inclusive lower left hand corner. [INPUTS] Width, Height : Desired dimensions of the rectangle. -  [OUTPUTS] Returns: - Errors: None. Definition at line 507 of file docrect.h. { lo = Low; hi.x = lo.x + Width; hi.y = lo.y + Height; }

DocRect::DocRect (  const DocCoord &  Low, const DocCoord &  High )  [inline]

To construct a rectangle with an inclusive lower left hand corner position of Low and an exclusive upper right hand corner position of High. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 13/5/93 Parameters: Low  : DocCoordinates of the lower left hand corner (inclusive) [INPUTS] High: DocCoordinates of the upper right hand corner (exclusive) -  [OUTPUTS] Returns: - Errors: An assertion failure will occur if the lower left hand coordinates are not lower than and to the left of the upper right coordinates. Definition at line 477 of file docrect.h. { // Defensive programming, detect an invalid rectangle ENSURE((Low.x <= High.x) && (Low.y <= High.y), "DocRect::DocRect(DocCoord, DocCoord) was passed invalid coordinates"); lo = Low; hi = High; }

DocRect::DocRect (  const DocRect &  R  )  [inline]

Copy constructor. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 13/5/93 Parameters: R,:  The copy of the DocRect [INPUTS] -  [OUTPUTS] Returns: - Definition at line 532 of file docrect.h. { lo = R.lo; hi = R.hi; }

---

Member Function Documentation

DocCoord DocRect::Centre (   )  const [inline]

To find the centre of the DocRect It calculates DocCoord(lox+(width/2),loy+(height/2)). Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 19/5/99 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: The centre coord of this DocRect Errors: Assertion failure if the rectangle is invalid. Definition at line 680 of file docrect.h. { // Detect an invalid rectangle ENSURE(IsValid(), "DocRect::Centre() was called on\nan invalid rectangle."); return DocCoord(lo.x + Width() / 2, lo.y + Height() / 2); }

BOOL DocRect::ContainsCoord (  const DocCoord &  Point  )  const [inline]

To check for coordinate containment. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 17/5/93 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE if the coordinate is within the rectangle, FALSE otherwise. Errors: Assertion failure if the rectangle is invalid. See also: ContainsRectCoord; ContainsRect Definition at line 738 of file docrect.h. { // Check for an an empty rectangle if (IsEmpty()) return FALSE; // Detect an invalid rectangle ENSURE(IsValid(), "DocRect::ContainsCoord() was called on\nan invalid rectangle."); return ((Point.x >= lo.x) && (Point.x < hi.x) && (Point.y >= lo.y) && (Point.y < hi.y)); }

BOOL DocRect::ContainsRect (  const DocRect &  Rect  )  const [inline]

To check for rectangle containment. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 17/5/93 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE if the rectangle 'Rect' is within the rectangle, FALSE otherwise. Errors: Assertion failure if the rectangle is invalid. See also: ContainsRectCoord; ContainsCoord Definition at line 808 of file docrect.h. { // Check for an an empty rectangle if (IsEmpty()) return FALSE; // Detect an invalid rectangle ENSURE(IsValid(), "DocRect::ContainsRect() was called on\nan invalid rectangle."); return ((Rect.lo.x >= lo.x) && (Rect.hi.x <= hi.x) && (Rect.lo.y >= lo.y) && (Rect.hi.y <= hi.y)); }

BOOL DocRect::ContainsRectCoord (  const DocCoord &  Point  )  const [inline]

To check for coordinate containment. This will work for coordinates which have been extracted from other rectangles (i.e. the top right corner is considered inclusive for this operation, not exclusive). Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 17/5/93 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE if the coordinate is within the rectangle, FALSE otherwise. Errors: Assertion failure if the rectangle is invalid. See also: ContainsCoord; ContainsRect Definition at line 774 of file docrect.h. { // Check for an an empty rectangle if (IsEmpty()) return FALSE; // Detect an invalid rectangle ENSURE(IsValid(), "DocRect::ContainsRectCoord() was called on\nan invalid rectangle."); return ((Point.x >= lo.x) && (Point.x <= hi.x) && (Point.y >= lo.y) && (Point.y <= hi.y)); }

INT32 DocRect::Height (   )  const [inline]

To find the height of the DocRect. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 13/5/93 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: The height of the DocRect Definition at line 602 of file docrect.h. { // Detect an invalid rectangle ENSURE(IsValid(), "DocRect::Height() was called on\nan invalid rectangle."); return(hi.y - lo.y); }

DocCoord DocRect::HighCorner (   )  const [inline]

To find the upper right hand coordinates of the DocRect. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 13/5/93 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: The exclusive upper right hand coordinates of the DocRect Errors: Assertion failure if the rectangle is invalid. Definition at line 653 of file docrect.h. { // Detect an invalid rectangle ENSURE(IsValid(), "DocRect::HighCorner() was called on\nan invalid rectangle."); return(hi); }

void DocRect::IncludePoint (  const DocCoord &  Point  )

Expand a rectangle so that it includes the given point. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 27/5/93 Parameters: Point  - coordinate to include into this rectangle. [INPUTS] -  [OUTPUTS] Returns: - Errors: An assertion failure if the rectangle is invalid. See also: - Definition at line 388 of file docrect.cpp. { // Detect an invalid rectangle ENSURE(IsValid(), "DocRect::IncludePoint() was called on an \ninvalid rectangle."); // Extend lower corner to include point if necessary lo.x = min(lo.x, Point.x); lo.y = min(lo.y, Point.y); // Extend upper corner to include point if necessary // (remember upper corner is exclusive) hi.x = max(hi.x, (INT32)(Point.x + 1L)); hi.y = max(hi.y, (INT32)(Point.y + 1L)); }

void DocRect::Inflate (  INT32  Inc  )  [inline]

Inflate a rectangle by given amount. Negative values will deflate the rectangle. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 17/5/93 Parameters: Inc  - the amount to inflate (or deflate) the rectangle by. [INPUTS] -  [OUTPUTS] Returns: N/A. Errors: An assertion failure if the rectangle is invalid. Definition at line 380 of file docrect.h. { // Detect an invalid rectangle ENSURE(IsValid(), "DocRect::Inflate(INT32) was called on an \ninvalid rectangle."); lo.x -= Inc; lo.y -= Inc; hi.x += Inc; hi.y += Inc; }

void DocRect::Inflate (  INT32  XInc, INT32  YInc )  [inline]

Inflate a rectangle by given amounts. Negative values will deflate the rectangle. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 17/5/93 Parameters: XInc,YInc  - the amount to inflate (or deflate) the rectangle by. [INPUTS] -  [OUTPUTS] Returns: N/A. Errors: An assertion failure if the rectangle is invalid. Definition at line 348 of file docrect.h. { // Detect an invalid rectangle ENSURE(IsValid(), "DocRect::Inflate(INT32, INT32) was called on an \ninvalid rectangle."); lo.x -= XInc; lo.y -= YInc; hi.x += XInc; hi.y += YInc; }

DocRect DocRect::Intersection (  const DocRect &  R  )  const

Compute intersection of two rectangles. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 17/5/93 Parameters: R  - the rectangle to intersect with. [INPUTS] -  [OUTPUTS] Returns: The intersection. If one of the rectangles involved is invalid, the other is returned as the result. In the case of both being invalid, one of the invalid rectangles is returned as the result. It is undefined which rectangle is returned in this case. Returns: Errors: None. Definition at line 293 of file docrect.cpp. { // Special cases for invalid rectangles... if (!IsValid()) return R; if (!R.IsValid()) return *this; // Special cases when empty rectangles if (IsEmpty()) return *this; if (R.IsEmpty()) return R; // Return the result DocRect I; I.lo.x = max(lo.x, R.lo.x); I.lo.y = max(lo.y, R.lo.y); I.hi.x = min(hi.x, R.hi.x); I.hi.y = min(hi.y, R.hi.y); return I; }

BOOL DocRect::IsAdjacent (  const DocRect &  Rect, MILLIPOINT  Fuzzy )  const

To check for adjacent rectangles. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 14/7/93 Parameters: The  Fuzzy limit in MILLIPOINTS. [INPUTS] -  [OUTPUTS] Returns: TRUE if the rectangles are adjacent within a Fuzzy limit. Errors: Definition at line 188 of file docrect.cpp. { // Check for an an empty rectangle if (IsEmpty()) return FALSE; // Detect an invalid rectangle ENSURE(IsValid(), "DocRect::IsAdjacent() was called on\nan invalid rectangle."); #if 0 // This is the expansion of the rampant return statement below // Near top or bottom BOOL NearBot = (ABS(Rect.hi.y - lo.y)) <= Fuzzy; BOOL NearTop = (ABS(Rect.lo.y - hi.y)) <= Fuzzy; // Near left or right BOOL NearLeft = (ABS(Rect.hi.x - lo.x)) <= Fuzzy; BOOL NearRight = (ABS(Rect.lo.x - hi.x)) <= Fuzzy; // Overlaps BOOL OverLeft = (ABS(Rect.lo.x - lo.x)) <= Fuzzy; BOOL OverRight = (ABS(Rect.hi.x - hi.x)) <= Fuzzy; BOOL OverTop = (ABS(Rect.hi.y - hi.y)) <= Fuzzy; BOOL OverBot = (ABS(Rect.lo.y - lo.y)) <= Fuzzy; // Adjacent to the top or bottom? BOOL TopOrBot = (NearTop || NearBot) && OverLeft && OverRight; BOOL LeftOrRight = (NearLeft || NearRight) && OverTop && OverBot; return (TopOrBot || LeftOrRight); #endif // This is explained more carefully in the section above that is excluded from the build return (( ((ABS(Rect.lo.x - lo.x))<=Fuzzy) && ((ABS(Rect.hi.x - hi.x))<=Fuzzy) && (((ABS(Rect.hi.y - lo.y))<=Fuzzy) || ((ABS(Rect.lo.y - hi.y))<=Fuzzy)) ) || ( ((ABS(Rect.lo.y - lo.y))<=Fuzzy) && ((ABS(Rect.hi.y - hi.y))<=Fuzzy) && (((ABS(Rect.hi.x - lo.x))<=Fuzzy) || ((ABS(Rect.lo.x - hi.x))<=Fuzzy)) )); }

BOOL DocRect::IsEmpty (   )  const [inline]

To check for empty rectangle. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 17/5/93 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE if the rectangle is empty. Errors: Definition at line 858 of file docrect.h. { return ((lo.x == hi.x) || (lo.y == hi.y)); }

BOOL DocRect::IsIntersectedWith (  const DocRect &  R  )  const [inline]

To check for rectangle intersection. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 17/5/93 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE if the rectangles intersect, FALSE otherwise. Errors: Definition at line 707 of file docrect.h. { // Detect an invalid rectangle if ((!IsValid()) || (!R.IsValid())) return FALSE; return ((hi.x > R.lo.x) && (lo.x < R.hi.x) && (hi.y > R.lo.y) && (lo.y < R.hi.y)); }

BOOL DocRect::IsValid (   )  const [inline]

To check for a valid rectangle. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 9/6/93 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE if the rectangle is valid. Errors: Definition at line 882 of file docrect.h. { return ((lo.x <= hi.x) && (lo.y <= hi.y)); }

DocCoord DocRect::LowCorner (   )  const [inline]

To find the lower left hand coordinates of the DocRect. Returns: Errors: Assertion failure if the rectangle is invalid. Definition at line 627 of file docrect.h. { // Detect an invalid rectangle ENSURE(IsValid(), "DocRect::LowCorner() was called on\nan invalid rectangle."); return(lo); }

void DocRect::MakeEmpty (   )  [inline]

Make the rectangle an empty one (all coordinates are set to 0). Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 03/03/94 See also: DocRect::MakeEmpty Definition at line 834 of file docrect.h. { lo.x = lo.y = hi.x = hi.y = 0; }

INT32 DocRect::operator!= (  const DocRect &  R  )  const [inline]

Test for inequality of two rectangles. As all invalid rectangles have the same results when used for Union/Intersection, any two invalid rectangles are considered equal. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 17/5/93 Parameters: R  - the rectangle to compare against. [INPUTS] -  [OUTPUTS] Returns: TRUE if R does not describe the same rectangle as the object. Friend: DocRect Returns: Errors: None. Definition at line 318 of file docrect.h. { // Invalid rectangles are equal if ((!IsValid()) && (!R.IsValid())) return FALSE; return ((lo.x != R.lo.x) || (lo.y != R.lo.y) || (hi.x != R.hi.x) || (hi.y != R.hi.y)); }

DocRect & DocRect::operator= (  const DocRect &  DocRect  )  [inline]

Equals operator. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 13/5/93 Parameters: DocRect,:  DocRect to copy [INPUTS] -  [OUTPUTS] Returns: Reference to this DocRect Definition at line 554 of file docrect.h. { lo = DocRect.lo; hi = DocRect.hi; return *this; }

INT32 DocRect::operator== (  const DocRect &  R  )  const [inline]

Test for equality of two rectangles. As all invalid rectangles have the same results when used for Union/Intersection, any two invalid rectangles are considered equal. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 17/5/93 Parameters: R  - the rectangle to compare against. [INPUTS] -  [OUTPUTS] Returns: TRUE if R is describes the same rectangle as the object. Friend: DocRect Returns: Errors: None. Definition at line 283 of file docrect.h. { // Invalid rectangles are equal if ((!IsValid()) && (!R.IsValid())) return TRUE; // Could use structure compare? Would it be portable? Probably not... return ((lo.x == R.lo.x) && (lo.y == R.lo.y) && (hi.x == R.hi.x) && (hi.y == R.hi.y)); }

INT32 DocRect::SplitRect (  const DocRect &  R, DocRect *  SubRects )

Splits a rectangle into sub-rectangles which all exclude the interecting rectangle R. The number of sub-rects generated depends on how the rectangles intersect. _______________________ ___________________ | | | | | *this A | | *this A | |_ _ _ ________ _ _ _ | |_ _ _ _ _ ________|__________ | | | | | | | | | B | R | C | | B | | | |_ _ _ |________| _ _ _ | |__________|________| R | | | | | | D Index=4 | | Index=2 | |_______________________| |___________________|. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 14/7/93 Parameters: R  is the rectangle to intersect with, SubRects is an array of DocRect to fill. [INPUTS] Puts  any sub-rects into SubRects. [OUTPUTS] Returns: The number of subrectangles found. 0 for no intersection. Errors: Definition at line 346 of file docrect.cpp. { if (!this->IsIntersectedWith(R)) return 0; // No intersection INT32 Index = 0; if (R.hi.y < hi.y) SubRects[Index++] = DocRect(lo.x, R.hi.y, hi.x, hi.y); // Sub-Rect A if (R.lo.y > lo.y) SubRects[Index++] = DocRect(lo.x, lo.y, hi.x, R.lo.y); // Sub-Rect D INT32 Ry0 = max(R.lo.y, lo.y); INT32 Ry1 = min(R.hi.y, hi.y); if (R.lo.x > lo.x) SubRects[Index++] = DocRect(lo.x, Ry0, R.lo.x, Ry1); // Sub-Rect B if (R.hi.x < hi.x) SubRects[Index++] = DocRect(R.hi.x, Ry0, hi.x, Ry1); // Sub-Rect C return Index; }

DocRect DocRect::ToDoc (  Spread *  pSpread, View *  pView )

Convert a SpreadRect (AKA DocRect) to a DocRect. Author: Ed_Cornes (Xara Group Ltd) <camelotdev@xara.com> Date: 6/9/95 Parameters: pSpread  - [INPUTS] pView - Returns: DocRect Definition at line 447 of file docrect.cpp. { return DocRect( this->lo.ToDoc(pSpread,pView), this->hi.ToDoc(pSpread,pView) ); }

OilRect DocRect::ToOil (  Spread *  pSpread, View *  pView )

Convert a SpreadRect (AKA DocRect) to an OilRect. Author: Ed_Cornes (Xara Group Ltd) <camelotdev@xara.com> Date: 6/9/95 Parameters: pSpread  - [INPUTS] pView - Returns: DocRect Definition at line 480 of file docrect.cpp. { return OilRect( this->lo.ToOil(pSpread,pView), this->hi.ToOil(pSpread,pView) ); }

DocRect DocRect::ToSpread (  Spread *  pSpread, View *  pView )

Convert a DocRect to a SpreadRect (AKA DocRect). Author: Ed_Cornes (Xara Group Ltd) <camelotdev@xara.com> Date: 6/9/95 Parameters: pSpread  - [INPUTS] pView - Returns: DocRect Definition at line 430 of file docrect.cpp. { return DocRect( this->lo.ToSpread(pSpread,pView), this->hi.ToSpread(pSpread,pView) ); }

UserRect DocRect::ToUser (  Spread *  pSpread  )

Convert a SpreadRect (AKA DocRect) to a UserRect. Author: Ed_Cornes (Xara Group Ltd) <camelotdev@xara.com> Date: 11/9/95 Parameters: pSpread  - [INPUTS] Returns: UserRect Definition at line 463 of file docrect.cpp. { return UserRect( this->lo.ToUser(pSpread), this->hi.ToUser(pSpread) ); }

void DocRect::Translate (  INT32  XOfs, INT32  YOfs )  [inline]

Translate a rectangle by given offset. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 17/5/93 Parameters: (XOfs,YOfs)  - the offset to translate the rectangle by. [INPUTS] -  [OUTPUTS] Returns: N/A. Errors: An assertion failure if the rectangle is invalid. Definition at line 248 of file docrect.h. { // Detect an invalid rectangle ENSURE(IsValid(), "DocRect::Translate() was called on an \ninvalid rectangle."); lo.x += XOfs; lo.y += YOfs; hi.x += XOfs; hi.y += YOfs; }

DocRect DocRect::Union (  const DocRect &  R  )  const

Compute union of two rectangles. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 17/5/93 Parameters: R  - the rectangle to join with the object. [INPUTS] -  [OUTPUTS] Returns: The simple union (bounding box). If one of the rectangles involved is invalid, the other is returned as the result. In the case of both being invalid, one of the invalid rectangles is returned as the result. It is undefined which rectangle is returned in this case. Returns: Errors: None. Definition at line 252 of file docrect.cpp. { // Special cases for invalid rectangles... if (!IsValid() || IsEmpty()) return R; if (!R.IsValid() || R.IsEmpty()) return *this; // Return the result DocRect U; U.lo.x = min(lo.x, R.lo.x); U.lo.y = min(lo.y, R.lo.y); U.hi.x = max(hi.x, R.hi.x); U.hi.y = max(hi.y, R.hi.y); return U; }

INT32 DocRect::Width (   )  const [inline]

To find the width of the DocRect. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 13/5/93 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: The width of the DocRect Definition at line 578 of file docrect.h. { // Detect an invalid rectangle ENSURE(IsValid(), "DocRect::Width() was called on\nan invalid rectangle."); return (hi.x - lo.x); }

---

Member Data Documentation

DocCoord DocRect::hi

Definition at line 169 of file docrect.h.

DocCoord DocRect::lo

Definition at line 168 of file docrect.h.

---

The documentation for this class was generated from the following files:

• Kernel/docrect.h (r1785/r1285)
• Kernel/docrect.cpp (r1785/r1282)

---