hg/stx-libbasic: comparison Rectangle.st

equal deleted inserted replaced

-:0719a15ae26d
+:152b525b5c63
 (aside from that, you will not see any difference from the outside)
 Instance variables:
-left           <Number>        the left coordinate (i.e origin x)
+	left           <Number>        the left coordinate (i.e origin x)
-top            <Number>        the top coordinate (i.e origin y)
+	top            <Number>        the top coordinate (i.e origin y)
-width          <Number>        the width of the rectangle
+	width          <Number>        the width of the rectangle
-height         <Number>        the height of the rectangle
+	height         <Number>        the height of the rectangle
 I am not certain, if implementing Rectangle different was a good idea -
 subclasses may expect things to be different ...
 Therefore, this may change.
 [author:]
-Claus Gittinger
+	Claus Gittinger
 [see also:]
-Point Polygon Circle EllipticalArc Spline
+	Point Polygon Circle EllipticalArc Spline
-LayoutOrigin LayoutFrame AlignmentOrigin Layout
+	LayoutOrigin LayoutFrame AlignmentOrigin Layout
-View GraphicsContext StrokingWrapper FillingWrapper
+	View GraphicsContext StrokingWrapper FillingWrapper
 "
 ! !
 !Rectangle class methodsFor:'instance creation'!
 center:centerPoint extent:extentPoint
 "return an instance of me whose center is centerPoint and width
 by height is extentPoint."
 ^ self
-origin:centerPoint - (extentPoint//2)
+	origin:centerPoint - (extentPoint//2)
-extent:extentPoint
+	extent:extentPoint
 !
 decodeFromLiteralArray:anArray
 "create & return a new instance from information encoded in anArray.
 Redefined for faster creation."
 w := (anArray at:4) - l.
 h := (anArray at:5) - t.
 ^ self left:l top:t width:w height:h
 "
 Rectangle decodeFromLiteralArray:#(Rectangle 100 200 300 500)
 "
 "Created: / 28.1.1998 / 17:46:52 / cg"
 !
 "Return a rectangle, which encompasses all of the given points."
 |topLeft bottomRight|
 topLeft := bottomRight := nil.
 listOfPoints do:[:p |
-topLeft == nil
+	topLeft == nil
-ifTrue: [topLeft := bottomRight := p]
+	    ifTrue: [topLeft := bottomRight := p]
-ifFalse: [topLeft := topLeft min: p.
+	    ifFalse: [topLeft := topLeft min: p.
-bottomRight := bottomRight max: p]
+		      bottomRight := bottomRight max: p]
 ].
 ^ topLeft corner: bottomRight
 "
 Rectangle encompassing:(Array with:10@10 with:50@0 with:0@50)
 REGISTER OBJ newRect;
 OBJ t;
 int spc;
 if (__CanDoQuickNew(OHDR_SIZE + 4*sizeof(OBJ))) {   /* OBJECT ALLOCATION */
-if (self == Rectangle) {
+	if (self == Rectangle) {
-/*
+	    /*
-* short cut - rectangles are created so often ...
+	     * short cut - rectangles are created so often ...
-*/
+	     */
-__qCheckedAlignedNew(newRect, OHDR_SIZE + 4*sizeof(OBJ));
+	    __qCheckedNew(newRect, OHDR_SIZE + 4*sizeof(OBJ));
-__InstPtr(newRect)->o_class = Rectangle;
+	    __InstPtr(newRect)->o_class = Rectangle;
-__qSTORE(newRect, Rectangle);
+	    __qSTORE(newRect, Rectangle);
-__InstPtr(newRect)->i_instvars[0] = left;
+	    __InstPtr(newRect)->i_instvars[0] = left;
-__InstPtr(newRect)->i_instvars[1] = top;
+	    __InstPtr(newRect)->i_instvars[1] = top;
-__InstPtr(newRect)->i_instvars[2] = w;
+	    __InstPtr(newRect)->i_instvars[2] = w;
-__InstPtr(newRect)->i_instvars[3] = h;
+	    __InstPtr(newRect)->i_instvars[3] = h;
-if (! (__bothSmallInteger(left, top) &&
+	    if (! (__bothSmallInteger(left, top) &&
-__bothSmallInteger(w, h))) {
+		   __bothSmallInteger(w, h))) {
-spc = __qSpace(newRect);
+		spc = __qSpace(newRect);
-__STORE_SPC(newRect, left, spc);
+		__STORE_SPC(newRect, left, spc);
-__STORE_SPC(newRect, top, spc);
+		__STORE_SPC(newRect, top, spc);
-__STORE_SPC(newRect, w, spc);
+		__STORE_SPC(newRect, w, spc);
-__STORE_SPC(newRect, h, spc);
+		__STORE_SPC(newRect, h, spc);
-}
+	    }
-RETURN ( newRect );
+	    RETURN ( newRect );
-}
+	}
 }
 %}.
 ^ (self basicNew) left:left top:top width:w height:h
 !
 Avoids creation of temp garbage."
 | topLeft bottomRight |
 topLeft := bottomRight := nil.
 listOfRects do:[:r |
-topLeft == nil ifTrue: [
+	topLeft == nil ifTrue: [
-topLeft := r topLeft.
+	    topLeft := r topLeft.
-bottomRight := r bottomRight
+	    bottomRight := r bottomRight
-] ifFalse: [
+	] ifFalse: [
-topLeft := topLeft min: r topLeft.
+	    topLeft := topLeft min: r topLeft.
-bottomRight := bottomRight max: r bottomRight
+	    bottomRight := bottomRight max: r bottomRight
-]
+	]
 ].
 ^ topLeft corner: bottomRight
 !
 origin:origin corner:corner
 REGISTER OBJ newRect;
 OBJ t;
 int spc;
 if (__CanDoQuickNew(OHDR_SIZE + 4*sizeof(OBJ))) {   /* OBJECT ALLOCATION */
-/*
+	/*
-* short cut - rectangles are created so often ...
+	 * short cut - rectangles are created so often ...
-*/
+	 */
-if (self == Rectangle) {
+	if (self == Rectangle) {
-if (__isPoint(origin) && __isPoint(extent)) {
+	    if (__isPoint(origin) && __isPoint(extent)) {
-__qCheckedAlignedNew(newRect, OHDR_SIZE + 4*sizeof(OBJ));
+		__qCheckedNew(newRect, OHDR_SIZE + 4*sizeof(OBJ));
-__InstPtr(newRect)->o_class = Rectangle;
+		__InstPtr(newRect)->o_class = Rectangle;
-__qSTORE(newRect, Rectangle);
+		__qSTORE(newRect, Rectangle);
-spc = __qSpace(newRect);
+		spc = __qSpace(newRect);
-t = __PointInstPtr(origin)->p_x;
+		t = __PointInstPtr(origin)->p_x;
-__InstPtr(newRect)->i_instvars[0] = t;
+		__InstPtr(newRect)->i_instvars[0] = t;
-__STORE_SPC(newRect, t, spc);
+		__STORE_SPC(newRect, t, spc);
-t = __PointInstPtr(origin)->p_y;
+		t = __PointInstPtr(origin)->p_y;
-__InstPtr(newRect)->i_instvars[1] = t;
+		__InstPtr(newRect)->i_instvars[1] = t;
-__STORE_SPC(newRect, t, spc);
+		__STORE_SPC(newRect, t, spc);
-t = __PointInstPtr(extent)->p_x;
+		t = __PointInstPtr(extent)->p_x;
-__InstPtr(newRect)->i_instvars[2] = t;
+		__InstPtr(newRect)->i_instvars[2] = t;
-__STORE_SPC(newRect, t, spc);
+		__STORE_SPC(newRect, t, spc);
-t = __PointInstPtr(extent)->p_y;
+		t = __PointInstPtr(extent)->p_y;
-__InstPtr(newRect)->i_instvars[3] = t;
+		__InstPtr(newRect)->i_instvars[3] = t;
-__STORE_SPC(newRect, t, spc);
+		__STORE_SPC(newRect, t, spc);
-RETURN ( newRect );
+		RETURN ( newRect );
-}
+	    }
-}
+	}
 }
 %}.
 ^ (self basicNew) origin:origin extent:extent
 !
 ^ (self basicNew) origin:origin width:w height:h
 "Created: 8.5.1996 / 20:55:53 / cg"
 !
 vertex:vertex1Point vertex:vertex2Point
 "create and return a new instance of the receiver,
 given two diagonally opposite vertices."
 ^ self
-origin: (vertex1Point min: vertex2Point)
+	origin: (vertex1Point min: vertex2Point)
-corner: (vertex1Point max: vertex2Point)
+	corner: (vertex1Point max: vertex2Point)
 "Created: 10.2.1997 / 12:14:32 / cg"
 ! !
 !Rectangle class methodsFor:'instance creation-interactive'!
 If the user presses ESC, an AbortOperationRequest is raised."
 ^ Screen current rectangleFromUser
 "
 Rectangle fromUser
 "
 !
 originFromUser:extent
 "let user specify an origin on the screen, return it"
 ^ Screen current originFromUser:extent
 "
 Rectangle originFromUser:50@50
 "
 ! !
 !Rectangle methodsFor:'Compatibility-Squeak'!
 "Answer a copy of the receiver that does not extend beyond aRectangle.  7/8/96 sw"
 ^ self translateBy: (self amountToTranslateWithin: aRectangle)
 !
 withHeight:height
 "Return a copy of me with a different height"
 |origin corner|
 origin := self origin.
 ! !
 !Rectangle methodsFor:'accessing'!
 area
 "return the area
 - for screen Rectangles this is the number of pixels"
 ^ width * height
 !
 corner
 "return the corner"
 %{  /* NOCONTEXT */
 if (self == @global(Rectangle)) {
-OBJ _tleft = __INST(left);
+	OBJ _tleft = __INST(left);
-OBJ _ttop = __INST(top);
+	OBJ _ttop = __INST(top);
-OBJ _twidth = __INST(width);
+	OBJ _twidth = __INST(width);
-OBJ _theight = __INST(height);
+	OBJ _theight = __INST(height);
-if (__bothSmallInteger(_tleft, _ttop)
+	if (__bothSmallInteger(_tleft, _ttop)
-&& __bothSmallInteger(_twidth, _theight)) {
+	 && __bothSmallInteger(_twidth, _theight)) {
-if (__CanDoQuickNew(sizeof(struct __Point))) {      /* OBJECT ALLOCATION */
+	    if (__CanDoQuickNew(sizeof(struct __Point))) {      /* OBJECT ALLOCATION */
-OBJ newPoint;
+		OBJ newPoint;
-int spc;
+		int spc;
-int cX = __intVal(_tleft) + __intVal(_twidth);
+		int cX = __intVal(_tleft) + __intVal(_twidth);
-int cY = __intVal(_ttop) + __intVal(_theight);
+		int cY = __intVal(_ttop) + __intVal(_theight);
-if (__ISVALIDINTEGER(cX) && __ISVALIDINTEGER(cY)) {
+		if (__ISVALIDINTEGER(cX) && __ISVALIDINTEGER(cY)) {
-__qCheckedAlignedNew(newPoint, sizeof(struct __Point));
+		    __qCheckedNew(newPoint, sizeof(struct __Point));
-__InstPtr(newPoint)->o_class = self; __qSTORE(newPoint, self);
+		    __InstPtr(newPoint)->o_class = self; __qSTORE(newPoint, self);
-__PointInstPtr(newPoint)->p_x = __MKSMALLINT(cX);
+		    __PointInstPtr(newPoint)->p_x = __MKSMALLINT(cX);
-__PointInstPtr(newPoint)->p_y = __MKSMALLINT(cY);
+		    __PointInstPtr(newPoint)->p_y = __MKSMALLINT(cY);
-RETURN ( newPoint );
+		    RETURN ( newPoint );
-}
+		}
-}
+	    }
-}
+	}
 }
 %}.
 ^ (left + width) @ (top + height)
 !
 "return the extent"
 %{  /* NOCONTEXT */
 if (__CanDoQuickNew(sizeof(struct __Point))) {      /* OBJECT ALLOCATION */
-if (self == @global(Rectangle)) {
+	if (self == @global(Rectangle)) {
-OBJ newPoint;
+	    OBJ newPoint;
-int spc;
+	    int spc;
-OBJ newX = __INST(width);
+	    OBJ newX = __INST(width);
-OBJ newY = __INST(height);
+	    OBJ newY = __INST(height);
-__qCheckedAlignedNew(newPoint, sizeof(struct __Point));
+	    __qCheckedNew(newPoint, sizeof(struct __Point));
-__InstPtr(newPoint)->o_class = self; __qSTORE(newPoint, self);
+	    __InstPtr(newPoint)->o_class = self; __qSTORE(newPoint, self);
-__PointInstPtr(newPoint)->p_x = newX;
+	    __PointInstPtr(newPoint)->p_x = newX;
-__PointInstPtr(newPoint)->p_y = newY;
+	    __PointInstPtr(newPoint)->p_y = newY;
-if (! __bothSmallInteger(newX, newY)) {
+	    if (! __bothSmallInteger(newX, newY)) {
-spc = __qSpace(newPoint);
+		spc = __qSpace(newPoint);
-__STORE_SPC(newPoint, newX, spc);
+		__STORE_SPC(newPoint, newX, spc);
-__STORE_SPC(newPoint, newY, spc);
+		__STORE_SPC(newPoint, newY, spc);
-}
+	    }
-RETURN ( newPoint );
+	    RETURN ( newPoint );
-}
+	}
 }
 %}.
 ^ Point x:width y:height
 !
 left:aNumber
 "set the left edge, adjust width - warning: destructive"
 left notNil ifTrue:[
-"adjust width"
+	"adjust width"
-width := width + (left - aNumber).
+	width := width + (left - aNumber).
 ].
 left := aNumber
 !
 left:newLeft right:right top:newTop bottom:bottom
 /*
 * claus: I am no longer certain, if this primitive is worth the effort
 */
 if (__CanDoQuickNew(sizeof(struct __Point))) {      /* OBJECT ALLOCATION */
-if (self == @global(Rectangle)) {
+	if (self == @global(Rectangle)) {
-OBJ newPoint;
+	    OBJ newPoint;
-int spc;
+	    int spc;
-OBJ newX = __INST(left);
+	    OBJ newX = __INST(left);
-OBJ newY = __INST(top);
+	    OBJ newY = __INST(top);
-__qCheckedAlignedNew(newPoint, sizeof(struct __Point));
+	    __qCheckedNew(newPoint, sizeof(struct __Point));
-__InstPtr(newPoint)->o_class = self; __qSTORE(newPoint, self);
+	    __InstPtr(newPoint)->o_class = self; __qSTORE(newPoint, self);
-__PointInstPtr(newPoint)->p_x = newX;
+	    __PointInstPtr(newPoint)->p_x = newX;
-__PointInstPtr(newPoint)->p_y = newY;
+	    __PointInstPtr(newPoint)->p_y = newY;
-if (! __bothSmallInteger(newX, newY)) {
+	    if (! __bothSmallInteger(newX, newY)) {
-spc = __qSpace(newPoint);
+		spc = __qSpace(newPoint);
-__STORE_SPC(newPoint, newX, spc);
+		__STORE_SPC(newPoint, newX, spc);
-__STORE_SPC(newPoint, newY, spc);
+		__STORE_SPC(newPoint, newY, spc);
-}
+	    }
-RETURN ( newPoint );
+	    RETURN ( newPoint );
-}
+	}
 }
 %}.
 ^ Point x:left y:top
 !
 |newTop newLeft|
 newLeft := aPoint x.
 newTop := aPoint y.
 left notNil ifTrue:[
-width := width + (left - newLeft).
+	width := width + (left - newLeft).
 ].
 top notNil ifTrue:[
-height := height + (top - newTop).
+	height := height + (top - newTop).
 ].
 left := newLeft.
 top := newTop
 !
 width := extent x.
 height := extent y
 !
 origin:origin width:w height:h
 "set both origin and extent;
 the extent is given as individual width and height.
 warning: destructive"
 left := origin x.
 top := origin y.
 top:aNumber
 "set the top edge, adjust height - warning: destructive"
 top notNil ifTrue:[
-"adjust height"
+	"adjust height"
-height := height + (top - aNumber).
+	height := height + (top - aNumber).
 ].
 top := aNumber
 !
 topCenter
 ^ (left + width) @ top
 !
 topRight:aPoint
 "Set the top and right edges.
 The bottom left remains unchanged.
 warning: destructive"
 |newTop|
 !
 vertices
 "return the array containing my points as a closed polygon (for Polygon compatibility)"
 ^ Array
-with:(self topLeft)
+	with:(self topLeft)
-with:(self topRight)
+	with:(self topRight)
-with:(self bottomRight)
+	with:(self bottomRight)
-with:(self bottomLeft)
+	with:(self bottomLeft)
-with:(self topLeft)
+	with:(self topLeft)
 "
 (Rectangle origin:100@100 extent:20@30) vertices
 (Rectangle origin:100@100 extent:20@30) asPolygon vertices
 "
 "Modified: / 16-07-2010 / 16:59:16 / cg"
 !
 %{  /* NOCONTEXT */
 /*
 * because rectangles are often compared in the graphics code,
 * handle the common case quickly
 */
 if (__isNonNilObject(aRectangle)
 && __qClass(aRectangle) == Rectangle) {
 	if ((__InstPtr(self)->i_instvars[0] == __InstPtr(aRectangle)->i_instvars[0])
 	 && (__InstPtr(self)->i_instvars[1] == __InstPtr(aRectangle)->i_instvars[1])
 	 && (__InstPtr(self)->i_instvars[2] == __InstPtr(aRectangle)->i_instvars[2])
 	 && (__InstPtr(self)->i_instvars[3] == __InstPtr(aRectangle)->i_instvars[3])) {
 	topFraction:(self top);
 	bottomFraction:(self bottom).
 ^ l
 "
 (0.5@0.5 corner:0.75@0.75) asFractionalLayout
 (0.5@0.5 corner:0.75@0.75) asOffsetLayout
 (0.5@0.5 corner:0.75@0.75) asLayout
 "
 !
 asLayout
 "return a layoutFrame in which offsets (top, left, bottom, right)
 b := (self bottom).
 ((l between:0.0 and:1.0)
 and:[(r between:0.0 and:1.0)
 and:[(t between:0.0 and:1.0)
 and:[(b between:0.0 and:1.0)]]]) ifTrue:[
-newLayout
+	newLayout
-leftFraction:l;
+	    leftFraction:l;
-rightFraction:r;
+	    rightFraction:r;
-topFraction:t;
+	    topFraction:t;
-bottomFraction:b.
+	    bottomFraction:b.
 ] ifFalse:[
-newLayout
+	newLayout
-leftOffset:l;
+	    leftOffset:l;
-rightFraction:0 offset:r;
+	    rightFraction:0 offset:r;
-topOffset:t;
+	    topOffset:t;
-bottomFraction:0 offset:b.
+	    bottomFraction:0 offset:b.
 ].
 ^ newLayout
 "
 (0.5@0.5 corner:0.75@0.75) asFractionalLayout
 (0.5@0.5 corner:0.75@0.75) asOffsetLayout
 (0.5@0.5 corner:0.75@0.75) asLayout
 (0@0 corner:1@1) asLayout
 (0@0 corner:1@1) asFractionalLayout
 (0@0 corner:1@1) asOffsetLayout
 "
 "Modified: 5.6.1996 / 00:45:46 / cg"
 !
 	topOffset:(self top);
 	bottomFraction:0 offset:(self bottom).
 ^ newLayout
 "
 (0.5@0.5 corner:0.75@0.75) asFractionalLayout
 (0.5@0.5 corner:0.75@0.75) asOffsetLayout
 (0.5@0.5 corner:0.75@0.75) asLayout
 (10@10 corner:20@20) asFractionalLayout
 (10@10 corner:20@20) asOffsetLayout
 (10@10 corner:20@20) asLayout
 "
 !
 asPointArray
 ^ Array with:(org := self origin)
 	    with:self topRight
 	    with:self corner
 	    with:self bottomLeft
 	    with:org
 "
 (10@10 corner:100@100) asPointArray
 "
 !
 asPolygon
 "return a polygon from the receiver"
 width := (encoding at:4) - left.
 height := (encoding at:5) - top
 "
 Rectangle new fromLiteralArrayEncoding:#(Rectangle 100 200 300 500)
 "
 !
 literalArrayEncoding
 "encode myself as an array, from which a copy of the receiver
 can be reconstructed with #decodeAsLiteralArray.
 The encoding is: (Rectangle orgX orgY cornX cornY)"
 ^ Array
-with:#Rectangle
+	with:#Rectangle
-with:left
+	with:left
-with:top
+	with:top
-with:(left + width)
+	with:(left + width)
-with:(top + height)
+	with:(top + height)
 "
 Rectangle new fromLiteralArrayEncoding:#(Rectangle 100 200 300 500)
 (100@200 corner:300@500) literalArrayEncoding
 "
 "Modified: 1.9.1995 / 02:16:54 / claus"
 "Modified: 22.4.1996 / 13:00:36 / cg"
 !
 rectangleRelativeTo:aRectangle preferred:prefRectHolder
 "compute a displayRectangle, treating the receiver like a
 layoutFrame.
 This allows rectangles to be used interchangable with Layouts."
 ^ (self asLayout) rectangleRelativeTo:aRectangle preferred:prefRectHolder
 "
 (10@20 corner:20@30) rectangleRelativeTo:(0@0 corner:100@100) preferred:(0@0 corner:50@50)
 (0.5@0.5) rectangleRelativeTo:(0@0 corner:100@100) preferred:(0@0 corner:50@50)
 "
 "Modified: / 27.5.1998 / 10:20:20 / cg"
 ! !
 self origin:aPoint corner:self corner + diff
 !
 scaleBy:scale
 "scale the receiver rectangle by scale (a Number or Point).
 This is destructive (modifies the receiver, not a copy) and
 should only be used if you know, that you are the exclusive owner
 of the receiver. (use scaledBy if in doubt)"
 |scalePoint sx sy|
 (scale isMemberOf:Point) ifTrue:[  "type hint to stc"
 height := height * sy.
 left := left * sx.
 top := top * sy
 "
 (Rectangle origin:10@10 corner:50@50) scaleBy:2
 "
 "its destructive:"
 "
 |r1 r2|
 r1 := Rectangle origin:10@10 corner:50@50.
 r2 := r1 scaleBy:2.
 r1
 "
 !
 translateBy:amount
 "translate (i.e. move) the receiver rectangle
 by amount, a Point or Number.
 This is destructive (modifies the receiver, not a copy) and
 should only be used if you know, that you are the exclusive owner
 of the receiver. (use translatedBy if in doubt)"
 |amountPoint|
 (amount isMemberOf:Point) ifTrue:[  "type hint to stc"
 "
 |r1 r2|
 r1 := Rectangle origin:10@10 corner:50@50.
 r2 := r1 translateBy:10.
 r1
 "
 ! !
 !Rectangle methodsFor:'displaying'!
 displayFilledOn:aGC
 "display a filled rectangle as represented by the receiver in
 the graphicsContext, aGC"
 aGC fillRectangleX:left y:top width:width height:height
 "
 "Modified: 8.5.1996 / 14:40:42 / cg"
 !
 displayStrokedOn:aGC
 "display an unfilled rectangle as represented by the receiver in
 the graphicsContext, aGC"
 aGC displayRectangleX:left y:top width:width height:height
 "
 * speeds that up by almost a factor of 2 ...
 */
 OBJ slf = self;
 OBJ rct = aRectangle;
 if (__isNonNilObject(rct)
 && __qClass(rct) == Rectangle) {
-OBJ r_l, r_w, r_t, r_h, l, w, t, h;
+	OBJ r_l, r_w, r_t, r_h, l, w, t, h;
-INT r_ir, r_il, r_ib, r_it;
+	INT r_ir, r_il, r_ib, r_it;
-INT il, it, ir, ib, iw, ih;
+	INT il, it, ir, ib, iw, ih;
-r_l = __OINST(rct, left);
+	r_l = __OINST(rct, left);
-l = __OINST(slf, left);
+	l = __OINST(slf, left);
-if (__bothSmallInteger(r_l, l)) {
+	if (__bothSmallInteger(r_l, l)) {
 #ifndef POSITIVE_ADDRESSES      /* tag in low-bit */
-il = (INT)(l);
+	    il = (INT)(l);
-r_il = (INT)(r_l);
+	    r_il = (INT)(r_l);
 #else
-il = __intVal(l);
+	    il = __intVal(l);
-r_il = __intVal(r_l);
+	    r_il = __intVal(r_l);
 #endif
-if (il > r_il) { RETURN (false); }   /* left > aRectangle left */
+	    if (il > r_il) { RETURN (false); }   /* left > aRectangle left */
-r_t = __OINST(rct, top);
+	    r_t = __OINST(rct, top);
-t = __OINST(slf, top);
+	    t = __OINST(slf, top);
-if (__bothSmallInteger(r_t, t)) {
+	    if (__bothSmallInteger(r_t, t)) {
 #ifndef POSITIVE_ADDRESSES      /* tag in low-bit */
-it = (INT)(t);
+		it = (INT)(t);
-r_it = (INT)(r_t);
+		r_it = (INT)(r_t);
 #else
-it = __intVal(t);
+		it = __intVal(t);
-r_it = __intVal(r_t);
+		r_it = __intVal(r_t);
 #endif
-if (it > r_it) { RETURN (false); }   /* top > aRectangle top */
+		if (it > r_it) { RETURN (false); }   /* top > aRectangle top */
-r_w = __OINST(rct, width);
+		r_w = __OINST(rct, width);
-w = __OINST(slf, width);
+		w = __OINST(slf, width);
-if (__bothSmallInteger(r_w, w)) {
+		if (__bothSmallInteger(r_w, w)) {
 #ifndef POSITIVE_ADDRESSES      /* tag in low-bit */
-ir = il + (INT)(w);
+		    ir = il + (INT)(w);
-r_ir = r_il + (INT)(r_w);
+		    r_ir = r_il + (INT)(r_w);
 #else
-ir = il + __intVal(w);
+		    ir = il + __intVal(w);
-r_ir = r_il + __intVal(r_w);
+		    r_ir = r_il + __intVal(r_w);
 #endif
-if (ir < r_ir) { RETURN (false); }   /* (left + width) < aRectangle right */
+		    if (ir < r_ir) { RETURN (false); }   /* (left + width) < aRectangle right */
-r_h = __OINST(rct, height);
+		    r_h = __OINST(rct, height);
-h = __OINST(slf, height);
+		    h = __OINST(slf, height);
-if (__bothSmallInteger(r_h, h)) {
+		    if (__bothSmallInteger(r_h, h)) {
 #ifndef POSITIVE_ADDRESSES      /* tag in low-bit */
-ib = it + (INT)(h);
+			ib = it + (INT)(h);
-r_ib = r_it + (INT)(r_h);
+			r_ib = r_it + (INT)(r_h);
 #else
-ib = it + __intVal(h);
+			ib = it + __intVal(h);
-r_ib = r_it + __intVal(r_h);
+			r_ib = r_it + __intVal(r_h);
 #endif
-if (ib < r_ib) { RETURN (false); }   /* (top + height) < aRectangle bottom */
+			if (ib < r_ib) { RETURN (false); }   /* (top + height) < aRectangle bottom */
-RETURN (true);
+			RETURN (true);
-}
+		    }
-}
+		}
-}
+	    }
-}
+	}
 }
 %}.
 (left <= aRectangle left) ifTrue:[
 ((left + width) >= aRectangle right) ifTrue:[
-(top <= aRectangle top) ifTrue:[
+	(top <= aRectangle top) ifTrue:[
-((top + height) >= aRectangle bottom) ifTrue:[
+	  ((top + height) >= aRectangle bottom) ifTrue:[
-^ true
+	    ^ true
-]
+	  ]
-]
+	]
 ]
 ].
 ^ false
 "
 (0@0 corner:100@100) contains:(10@10 corner:90@90)
 (0@0 corner:100@100) contains:(10@10 corner:100@100)
 (0@0 corner:100@100) contains:(10@10 corner:110@100)
 (0@0 corner:100@100) contains:(10@10 corner:100@110)
 (10@10 corner:100@100) contains:(0@10 corner:100@100)
 "
 !
 containsPoint:aPoint
 "return true, if the argument, aPoint is contained in the receiver"
 corners
 "Return an array of corner points"
 ^ Array
-with: self topLeft
+	with: self topLeft
-with: self bottomLeft
+	with: self bottomLeft
-with: self bottomRight
+	with: self bottomRight
-with: self topRight
+	with: self topRight
 !
 innerCorners
 Added for Aqueak compatibility."
 ^ (self topLeft corner:(self bottomRight - (1@1))) corners
 "
 (10@10 corner:100@100) corners
 (10@10 corner:100@100) innerCorners
 "
 !
 intersects:aRectangle
 "return true, if the intersection between the argument, aRectangle
 * speeds up drawing by almost a factor of 2 ...
 */
 OBJ slf = self;
 OBJ rct = aRectangle;
 if (__isNonNilObject(rct)
 && __qClass(rct) == Rectangle) {
-OBJ r_l, r_w, r_t, r_h, l, w, t, h;
+	OBJ r_l, r_w, r_t, r_h, l, w, t, h;
-INT r_ir, r_il, r_ib, r_it;
+	INT r_ir, r_il, r_ib, r_it;
-INT il, it, ir, ib, iw, ih;
+	INT il, it, ir, ib, iw, ih;
-r_l = __OINST(rct, left);
+	r_l = __OINST(rct, left);
-r_w = __OINST(rct, width);
+	r_w = __OINST(rct, width);
-if (__bothSmallInteger(r_l, r_w)) {
+	if (__bothSmallInteger(r_l, r_w)) {
-r_t = __OINST(rct, top);
+	    r_t = __OINST(rct, top);
-r_h = __OINST(rct, height);
+	    r_h = __OINST(rct, height);
-l = __OINST(slf, left);
+	    l = __OINST(slf, left);
-w = __OINST(slf, width);
+	    w = __OINST(slf, width);
-if (__bothSmallInteger(l, w)) {
+	    if (__bothSmallInteger(l, w)) {
-t = __OINST(slf, top);
+		t = __OINST(slf, top);
-h = __OINST(slf, height);
+		h = __OINST(slf, height);
 #ifndef POSITIVE_ADDRESSES      /* tag in low-bit */
-r_il = (INT)(r_l);
+		r_il = (INT)(r_l);
-r_ir = r_il + (INT)(r_w) - 1;
+		r_ir = r_il + (INT)(r_w) - 1;
-il = (INT)(l);
+		il = (INT)(l);
-if (r_ir < il) { RETURN (false); }
+		if (r_ir < il) { RETURN (false); }
-ir = il + (INT)(w) - 1;
+		ir = il + (INT)(w) - 1;
-if (r_il > ir) { RETURN (false); }
+		if (r_il > ir) { RETURN (false); }
 #else                           /* tag in hi-bit */
-r_il = __intVal(r_l);
+		r_il = __intVal(r_l);
-r_ir = r_il + __intVal(r_w);        /* aRectangle right */
+		r_ir = r_il + __intVal(r_w);        /* aRectangle right */
-il = __intVal(l);
+		il = __intVal(l);
-if (r_ir < il) { RETURN (false); }  /* (aRectangle right) < left */
+		if (r_ir < il) { RETURN (false); }  /* (aRectangle right) < left */
-ir = il + __intVal(w);
+		ir = il + __intVal(w);
-if (r_il > ir) { RETURN (false); }   /* (aRectangle left) > r */
+		if (r_il > ir) { RETURN (false); }   /* (aRectangle left) > r */
 #endif
-if (__bothSmallInteger(r_t, r_h)) {
+		if (__bothSmallInteger(r_t, r_h)) {
-if (__bothSmallInteger(t, h)) {
+		    if (__bothSmallInteger(t, h)) {
 #ifndef POSITIVE_ADDRESSES
-r_it = (INT)(r_t);
+			r_it = (INT)(r_t);
-r_ib = r_it + (INT)(r_h) - 1; /* aRectangle bottom */
+			r_ib = r_it + (INT)(r_h) - 1; /* aRectangle bottom */
-it = (INT)(t);
+			it = (INT)(t);
-if (r_ib < it) { RETURN (false); } /* (aRectangle bottom) < top */
+			if (r_ib < it) { RETURN (false); } /* (aRectangle bottom) < top */
-ib = it + (INT)(h) - 1;
+			ib = it + (INT)(h) - 1;
-if (r_it > ib) { RETURN (false); } /* (aRectangle top) > b */
+			if (r_it > ib) { RETURN (false); } /* (aRectangle top) > b */
 #else
-r_it = __intVal(r_t);
+			r_it = __intVal(r_t);
-r_ib = r_it + __intVal(r_h); /* aRectangle bottom */
+			r_ib = r_it + __intVal(r_h); /* aRectangle bottom */
-it = __intVal(t);
+			it = __intVal(t);
-if (r_ib < it) { RETURN (false); } /* (aRectangle bottom) < top */
+			if (r_ib < it) { RETURN (false); } /* (aRectangle bottom) < top */
-ib = it + __intVal(h);
+			ib = it + __intVal(h);
-if (r_it > ib) { RETURN (false); } /* (aRectangle top) > b */
+			if (r_it > ib) { RETURN (false); } /* (aRectangle top) > b */
 #endif
-RETURN (true);
+			RETURN (true);
-}
+		    }
-}
+		}
-}
+	    }
-}
+	}
 }
 %}.
 (aRectangle right)  < left ifTrue:[^ false].
 (aRectangle bottom) < top  ifTrue:[^ false].
 r := left + width.
 (aRectangle top)    > b    ifTrue:[^ false].
 ^ true
 !
 isContainedIn:aRectangle
 "return true, if the receiver is fully contained within
 the argument, aRectangle"
 (aRectangle left <= left) ifTrue:[
 (aRectangle right >= (left + width)) ifTrue:[
-(aRectangle top <= top) ifTrue:[
+	(aRectangle top <= top) ifTrue:[
-(aRectangle bottom >= (top + height)) ifTrue:[
+	  (aRectangle bottom >= (top + height)) ifTrue:[
-^ true
+	    ^ true
-]
+	  ]
-]
+	]
 ]
 ].
 ^ false
 "
 origin translated by the argument, aPoint"
 |amountPoint|
 (aPoint isMemberOf:SmallInteger) ifTrue:[
-"/ this is an stc optimization
+	"/ this is an stc optimization
-^ Rectangle
+	^ Rectangle
-left:(left + aPoint)
+	    left:(left + aPoint)
-top:(top + aPoint)
+	    top:(top + aPoint)
-width:width
+	    width:width
-height:height
+	    height:height
 ].
 amountPoint := aPoint asPoint.
 ^ Rectangle left:(left + amountPoint x)
-top:(top + amountPoint y)
+		 top:(top + amountPoint y)
-width:width
+	       width:width
-height:height
+	      height:height
 "Modified: 25.1.1997 / 17:29:53 / cg"
 !
 - aPoint
 origin translated by the argument, aPoint"
 |amountPoint|
 (aPoint isMemberOf:SmallInteger) ifTrue:[
-"/ this is an stc optimization
+	"/ this is an stc optimization
-^ Rectangle
+	^ Rectangle
-left:(left - aPoint)
+	    left:(left - aPoint)
-top:(top - aPoint)
+	    top:(top - aPoint)
-width:width
+	    width:width
-height:height
+	    height:height
 ].
 amountPoint := aPoint asPoint.
 ^ Rectangle left:(left - amountPoint x)
-top:(top - amountPoint y)
+		 top:(top - amountPoint y)
-width:width
+	       width:width
-height:height
+	      height:height
 "Modified: 25.1.1997 / 17:29:53 / cg"
 "Created: 25.1.1997 / 17:30:21 / cg"
 !
 areasOutside: aRectangle
 "Answer an Array of Rectangles comprising the parts of the receiver not
 intersecting aRectangle."
 | areas yOrigin yCorner origin corner|
 origin := self origin.
 corner := self corner.
 "Make sure the intersection is non-empty"
 (origin <= aRectangle corner and: [aRectangle origin <= corner])
-ifFalse: [^ Array with: self].
+	    ifFalse: [^ Array with: self].
 areas := OrderedCollection new.
 aRectangle origin y > origin y
-ifTrue: [areas addLast: (origin corner: corner x @ (yOrigin := aRectangle origin y))]
+	    ifTrue: [areas addLast: (origin corner: corner x @ (yOrigin := aRectangle origin y))]
-ifFalse: [yOrigin := origin y].
+	    ifFalse: [yOrigin := origin y].
 aRectangle corner y < corner y
-ifTrue: [areas addLast: (origin x @ (yCorner := aRectangle corner y) corner: corner)]
+	    ifTrue: [areas addLast: (origin x @ (yCorner := aRectangle corner y) corner: corner)]
-ifFalse: [yCorner := corner y].
+	    ifFalse: [yCorner := corner y].
 aRectangle origin x > origin x
-ifTrue: [areas addLast: (origin x @ yOrigin corner: aRectangle origin x @ yCorner)].
+	    ifTrue: [areas addLast: (origin x @ yOrigin corner: aRectangle origin x @ yCorner)].
 aRectangle corner x < corner x
-ifTrue: [areas addLast: (aRectangle corner x @ yOrigin corner: corner x @ yCorner)].
+	    ifTrue: [areas addLast: (aRectangle corner x @ yOrigin corner: corner x @ yCorner)].
 ^areas
 "/ cg: the old code below was wrong ...
 "/    "----------------------------------------------------------------
 "/    | added for GNU-ST compatibility
 "/    |
 "/    | author: Doug McCallum <uunet!!ico.isc.com!!dougm>
 "/    |
 "/    |areasOutside: aRectangle
 "/    | most complicated of the Rectangle primitives
 "/    | The basic methodology is to first determine that there is an
 "/    | intersection by finding the overlapping rectangle.  From the
 "/    | overlapping rectangle, first determine if it runs along an edge.
 "/    | If it doesn't, extend the rectangle up to the top edge and add
 "/    | the new rectangle to the collection and start the rest of the
 "/    | process.  If the left edge does not touch the left edge of self,
 "/    | extend it to the edge saving the new rectangle.  Then do the
 "/    | same to the right edge.  Then check top and bottom edges.  Most
 "/    | of the time only 2 or 3 rectangles get formed, occasionally 4.
 "/    | It should be possible to never get more than 3 but requires more
 "/    | work.
 "/     ----------------------------------------------------------------"
 "/    iRect := self intersect: aRectangle.
 "/    iRect isNil ifTrue: [^nil]. "case of no intersection"
 "/                                "the collect collection gathers Rectangles"
 "/    collect := OrderedCollection new: 4.
 "/                                "is it floating or on the edge?"
 "/    (((((iRect top) ~= self top)
 "/         and: [ (iRect bottom) ~= self bottom ])
 "/         and: [ (iRect left) ~= self left ])
 "/         and: [ (iRect right) ~= self right ] )
 "/        ifTrue: "entirely in the center."
 "/            [tmp := Rectangle origin: (Point x: iRect left y: self top)
 "/            [tmp := Rectangle origin: iRect bottomLeft corner: self corner.
 "/                 collect add: tmp].
 "/    ^collect
 !
 encompass:aPoint
 "return a Rectangle that contains both the receiver and aPoint."
 ^ Rectangle
-origin: (self origin min: aPoint)
+	origin: (self origin min: aPoint)
-corner: (self corner max: aPoint)
+	corner: (self corner max: aPoint)
 !
 expandedBy:delta
 "return a new rectangle which is expanded in all directions
 ^ self copy expandBy:delta
 "
 |r|
 r := Rectangle origin:10@10 corner:100@100.
 r expandedBy:5.
 r expandedBy:(5 @ 0).
 r expandedBy:(10 @ 10).
 r expandedBy:( 10@10 corner:20@20 )
 "
 !
 insetBy: delta
 "return a new rectangle which is inset in all directions
 r insetBy:( 10@10 corner:20@20 )
 "
 !
 insetOriginBy:originDelta cornerBy:cornerDelta
 "return a new rectangle which is inset by originDelta
 and cornerDelta; both may be instances of Point or Number"
 ^ Rectangle
 	origin:(left @ top) + originDelta asPoint
 	corner:(self corner - cornerDelta asPoint)
 "
 |r|
 r := Rectangle origin:10@10 corner:100@100.
 r insetOriginBy:5 cornerBy:10.
 r insetOriginBy:10@5 cornerBy:10.
 r insetOriginBy:10 cornerBy:10@5.
 r insetOriginBy:10@10 cornerBy:20@20.
 "
 !
 intersect:aRectangle
 "return a new rectangle covering the intersection of the receiver
 and the argument, aRectangle (i.e. the area covered by both).
 the rectangles must intersect for a valid return"
 ^ Rectangle left:(left max:(aRectangle left))
-right:((left + width) min:(aRectangle right))
+	       right:((left + width) min:(aRectangle right))
-top:(top max:(aRectangle top))
+		 top:(top max:(aRectangle top))
-bottom:((top + height) min:(aRectangle bottom))
+	      bottom:((top + height) min:(aRectangle bottom))
 "
 |r1 r2|
 r1 := Rectangle origin:10@10 corner:100@100.
 r1 intersect:r2
 "
 !
 merge:aRectangle
 "return a new rectangle covering both the receiver
 and the argument, aRectangle"
 ^ Rectangle left:(left min:(aRectangle left))
-right:((left + width) max:(aRectangle right))
+	       right:((left + width) max:(aRectangle right))
-top:(top min:(aRectangle top))
+		 top:(top min:(aRectangle top))
-bottom:((top + height) max:(aRectangle bottom))
+	      bottom:((top + height) max:(aRectangle bottom))
 "
 (Rectangle origin:10@10 corner:100@100)
-merge:(Rectangle origin:20@20 corner:110@110)
+	 merge:(Rectangle origin:20@20 corner:110@110)
 (Rectangle origin:10@10 corner:100@100)
-merge:(Rectangle origin:20@20 corner:100@100)
+	 merge:(Rectangle origin:20@20 corner:100@100)
 "
 !
 nonIntersections:aRectangle
 "this is the same as areasOutside: - for ST/V compatibility only"
 ^ self areasOutside:aRectangle
 !
 quickMerge: aRectangle
 "return the receiver if it encloses the given rectangle,
 or the merge of the two rectangles if it doesn't.
 This method is an optimized version of merge: to reduce extra rectangle creations."
 | useRcvr rLeft rTop rRight rBottom minX maxX minY maxY |
 useRcvr := true.
 rTop < minY ifTrue: [useRcvr := false. minY := rTop].
 maxY := self bottom.
 rBottom > maxY ifTrue: [useRcvr := false. maxY := rBottom].
 useRcvr ifTrue: [
-^ self
+	^ self
 ].
 minX = rLeft ifTrue:[
-maxX = rRight ifTrue:[
+	maxX = rRight ifTrue:[
-minY = rTop ifTrue:[
+	    minY = rTop ifTrue:[
-maxY = rBottom ifTrue:[
+		maxY = rBottom ifTrue:[
-^ aRectangle
+		    ^ aRectangle
-].
+		].
-].
+	    ].
-].
+	].
 ].
 ^ Rectangle left:minX top:minY right:maxX bottom:maxY.
 "
-(Rectangle origin:10@10 corner:100@100)
-quickMerge:(Rectangle origin:20@20 corner:110@110)
 (Rectangle origin:10@10 corner:100@100)
-quickMerge:(Rectangle origin:20@20 corner:100@100)
+	 quickMerge:(Rectangle origin:20@20 corner:110@110)
+(Rectangle origin:10@10 corner:100@100)
+	 quickMerge:(Rectangle origin:20@20 corner:100@100)
 "
 !
 scaledBy:scale
 "return a new rectangle which is the receiver
 scaled by scale"
 |scalePoint sx sy|
 (scale isMemberOf:SmallInteger) ifTrue:[
-"/ this is an stc optimization
+	"/ this is an stc optimization
-^ Rectangle left:left * scale
+	^ Rectangle left:left * scale
-top:top * scale
+		     top:top * scale
-width:width * scale
+		   width:width * scale
-height:height * scale
+		  height:height * scale
 ].
 scalePoint := scale asPoint.
 sx := scalePoint x.
 sy := scalePoint y.
 ^ Rectangle left:left * sx
-top:top * sy
+		 top:top * sy
-width:width * sx
+	       width:width * sx
-height:height * sy
+	      height:height * sy
 "
 (Rectangle origin:10@10 corner:50@50) scaledBy:2
 "
 "it is NOT destructive:"
 "
 |r1 r2|
 r1 := Rectangle origin:10@10 corner:50@50.
 r2 := r1 scaledBy:2.
 r1
 "
 !
 scaledBy:scale translatedBy:translation
 "return a new rectangle which is translated (i.e. moved)
 by translation, aPoint or Number and scaled by scale, aPoint or number."
 |x y w h translationPoint scalePoint sx sy|
 (translation isNil and:[scale isNil]) ifTrue:[
-^ self.
+	^ self.
 ].
 x := left.
 y := top.
 w := width.
 h := height.
 scale notNil ifTrue:[
-(scale isMemberOf:SmallInteger) ifTrue:[
+	(scale isMemberOf:SmallInteger) ifTrue:[
-"/ this is an stc optimization
+	    "/ this is an stc optimization
-x := x * scale.
+	    x := x * scale.
-y := y * scale.
+	    y := y * scale.
-w := w * scale.
+	    w := w * scale.
-h := h * scale.
+	    h := h * scale.
-] ifFalse:[
+	] ifFalse:[
-scalePoint := scale asPoint.
+	    scalePoint := scale asPoint.
-sx := scalePoint x.
+	    sx := scalePoint x.
-sy := scalePoint y.
+	    sy := scalePoint y.
-x := x * sx.
+	    x := x * sx.
-y := y * sy.
+	    y := y * sy.
-w := w * sx.
+	    w := w * sx.
-h := h * sy.
+	    h := h * sy.
-].
+	].
 ].
 translation notNil ifTrue:[
-(translation isMemberOf:SmallInteger) ifTrue:[
+	(translation isMemberOf:SmallInteger) ifTrue:[
-"/ this is an stc optimization
+	    "/ this is an stc optimization
-x := x + translation.
+	    x := x + translation.
-y := y + translation.
+	    y := y + translation.
-] ifFalse:[
+	] ifFalse:[
-translationPoint := translation asPoint.
+	    translationPoint := translation asPoint.
-x := x + translationPoint x.
+	    x := x + translationPoint x.
-y := y + translationPoint y.
+	    y := y + translationPoint y.
-].
+	].
 ].
 ^ Rectangle left:x top:y width:w height:h.
 "
 (Rectangle origin:10@10 corner:50@50) scaledBy:2 translatedBy:10
 "
 !
 translatedBy:amount
 "return a new rectangle which is translated (i.e. moved)
 by amount, aPoint or Number"
 |amountPoint|
 (amount isMemberOf:SmallInteger) ifTrue:[
-"/ this is an stc optimization
+	"/ this is an stc optimization
-^ Rectangle
+	^ Rectangle
-left:(left + amount)
+	    left:(left + amount)
-top:(top + amount)
+	    top:(top + amount)
-width:width
+	    width:width
-height:height
+	    height:height
 ].
 amountPoint := amount asPoint.
 ^ Rectangle left:(left + amountPoint x)
-top:(top + amountPoint y)
+		 top:(top + amountPoint y)
-width:width
+	       width:width
-height:height
+	      height:height
 "
 (Rectangle origin:10@10 corner:50@50) translatedBy:10
 "
 "its NOT destructive:"
 "
 |r1 r2|
 r1 := Rectangle origin:10@10 corner:50@50.
 r2 := r1 translatedBy:10.
 r1
 "
 ! !
 !Rectangle methodsFor:'testing'!
 rounded
 "return a copy of the receiver with rounded coordinates.
 Return the receiver if its coordinates are already integral."
 (left isInteger
 and:[top isInteger
 and:[width isInteger
 and:[height isInteger]]])
-ifTrue: [^ self].
+	ifTrue: [^ self].
 ^ Rectangle left:(left rounded)
-top:(top rounded)
+		 top:(top rounded)
-width:(width rounded)
+	       width:(width rounded)
-height:(height rounded)
+	      height:(height rounded)
 !
 truncated
 "return a Rectangle whose origin and corner have any fractional parts removed.
 Return the receiver if its coordinates are already integral."
 (left isInteger
 and:[top isInteger
 and:[width isInteger
 and:[height isInteger]]])
-ifTrue: [^ self].
+	ifTrue: [^ self].
 ^ Rectangle
-left:left truncated
+	left:left truncated
-top:top truncated
+	top:top truncated
-width:width truncated
+	width:width truncated
-height:height truncated.
+	height:height truncated.
 ! !
 !Rectangle class methodsFor:'documentation'!
 version

branch	jv
changeset 20344	152b525b5c63
parent 20079	8d884971c2ed
parent 20308	9110f117d260
child 20727	fb8c5591428b