"{ Encoding: utf8 }"

"

 COPYRIGHT (c) 1989 by Claus Gittinger

	      All Rights Reserved

 This software is furnished under a license and may be used

 only in accordance with the terms of that license and with the

 inclusion of the above copyright notice.   This software may not

 be provided or otherwise made available to, or used by, any

 other person.  No title to or ownership of the software is

 hereby transferred.

"

"{ Package: 'stx:libbasic' }"

"{ NameSpace: Smalltalk }"

Geometric subclass:#Rectangle

	instanceVariableNames:'left top width height'

	classVariableNames:''

	poolDictionaries:''

	category:'Graphics-Geometry-Objects'

!

!Rectangle class methodsFor:'documentation'!

copyright

"

 COPYRIGHT (c) 1989 by Claus Gittinger

	      All Rights Reserved

 This software is furnished under a license and may be used

 only in accordance with the terms of that license and with the

 inclusion of the above copyright notice.   This software may not

 be provided or otherwise made available to, or used by, any

 other person.  No title to or ownership of the software is

 hereby transferred.

"

!

documentation

"

    Rectangles represent a rectangular area in 2D space.

    notice, my implementation does not use origin/corner as instance objects

    but left/top/width/height to save space and allocations. This means, that my

    Rectangles cannot be used to represent Rectangles in a higher than 2D

    space. (i.e. only valid if origin/corner are 2D Points)

    (aside from that, you will not see any difference from the outside)

    Instance variables:

	left           <Number>        the left coordinate (i.e origin x)

	top            <Number>        the top coordinate (i.e origin y)

	width          <Number>        the width 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

    [see also:]

	Point Polygon Circle EllipticalArc Spline

	LayoutOrigin LayoutFrame AlignmentOrigin Layout

	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)

	extent:extentPoint

!

decodeFromLiteralArray:anArray

    "create & return a new instance from information encoded in anArray.

     Redefined for faster creation."

    |l t w h|

    l := anArray at:2.

    t := anArray at:3.

    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"

!

encompassing:listOfPoints

    "Return a rectangle, which encompasses all of the given points."

    |topLeft bottomRight|

    topLeft := bottomRight := nil.

    listOfPoints do:[:p |

        topLeft isNil

            ifTrue: [topLeft := bottomRight := p]

            ifFalse: [topLeft := topLeft min: p.

                      bottomRight := bottomRight max: p]

    ].

    ^ topLeft corner: bottomRight

    "

     Rectangle encompassing:(Array with:10@10 with:50@0 with:0@50)

    "

!

left:left right:right top:top bottom:bottom

    "create and return a new Rectangle giving left, top, right and bottom coordinates"

    ^ (self basicNew) left:left right:right top:top bottom:bottom

!

left:left top:top extent:extent

    "create and return a new Rectangle giving left, top, and

     an extent point."

    ^ (self basicNew) left:left top:top extent:extent

    "Created: 8.5.1996 / 20:56:29 / cg"

!

left:left top:top right:right bottom:bottom

    "create and return a new Rectangle giving left, top, right and bottom coordinates"

    ^ (self basicNew) left:left top:top right:right bottom:bottom

!

left:left top:top width:w height:h

    "create and return a new Rectangle giving left and top coordinates

     and width, height"

%{  /* NOCONTEXT */

    REGISTER OBJ newRect;

    OBJ t;

    int spc;

    if (__CanDoQuickNew(OHDR_SIZE + 4*sizeof(OBJ))) {   /* OBJECT ALLOCATION */

	if (self == Rectangle) {

	    /*

	     * short cut - rectangles are created so often ...

	     */

	    __qCheckedNew(newRect, OHDR_SIZE + 4*sizeof(OBJ));

	    __InstPtr(newRect)->o_class = Rectangle;

	    __qSTORE(newRect, Rectangle);

	    __InstPtr(newRect)->i_instvars[0] = left;

	    __InstPtr(newRect)->i_instvars[1] = top;

	    __InstPtr(newRect)->i_instvars[2] = w;

	    __InstPtr(newRect)->i_instvars[3] = h;

	    if (! (__bothSmallInteger(left, top) &&

		   __bothSmallInteger(w, h))) {

		spc = __qSpace(newRect);

		__STORE_SPC(newRect, left, spc);

		__STORE_SPC(newRect, top, spc);

		__STORE_SPC(newRect, w, spc);

		__STORE_SPC(newRect, h, spc);

	    }

	    RETURN ( newRect );

	}

    }

%}.

    ^ (self basicNew) left:left top:top width:w height:h

!

merging: listOfRects

    "return the merge of a number of rectangles.

     Avoids creation of temp garbage."

    | topLeft bottomRight |

    topLeft := bottomRight := nil.

    listOfRects do:[:r |

        topLeft isNil ifTrue: [

            topLeft := r topLeft.

            bottomRight := r bottomRight

        ] ifFalse: [

            topLeft := topLeft min: r topLeft.

            bottomRight := bottomRight max: r bottomRight

        ]

    ].

    ^ topLeft corner: bottomRight

!

origin:origin corner:corner

    "create and return a new Rectangle giving top-left and bottom-right points"

    ^ (self basicNew) origin:origin corner:corner

!

origin:origin extent:extent

    "create and return a new Rectangle giving top-left point and extent point"

%{  /* NOCONTEXT */

    REGISTER OBJ newRect;

    OBJ t;

    int spc;

    if (__CanDoQuickNew(OHDR_SIZE + 4*sizeof(OBJ))) {   /* OBJECT ALLOCATION */

	/*

	 * short cut - rectangles are created so often ...

	 */

	if (self == Rectangle) {

	    if (__isPoint(origin) && __isPoint(extent)) {

		__qCheckedNew(newRect, OHDR_SIZE + 4*sizeof(OBJ));

		__InstPtr(newRect)->o_class = Rectangle;

		__qSTORE(newRect, Rectangle);

		spc = __qSpace(newRect);

		t = __PointInstPtr(origin)->p_x;

		__InstPtr(newRect)->i_instvars[0] = t;

		__STORE_SPC(newRect, t, spc);

		t = __PointInstPtr(origin)->p_y;

		__InstPtr(newRect)->i_instvars[1] = t;

		__STORE_SPC(newRect, t, spc);

		t = __PointInstPtr(extent)->p_x;

		__InstPtr(newRect)->i_instvars[2] = t;

		__STORE_SPC(newRect, t, spc);

		t = __PointInstPtr(extent)->p_y;

		__InstPtr(newRect)->i_instvars[3] = t;

		__STORE_SPC(newRect, t, spc);

		RETURN ( newRect );

	    }

	}

    }

%}.

    ^ (self basicNew) origin:origin extent:extent

!

origin:origin width:w height:h

    "create and return a new Rectangle giving top-left and extent

     as individual width/height"

    ^ (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)

	corner: (vertex1Point max: vertex2Point)

    "Created: 10.2.1997 / 12:14:32 / cg"

! !

!Rectangle class methodsFor:'instance creation-interactive'!

fromUser

    "let user specify a rectangle on the screen, return it.

     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'!

amountToTranslateWithin: aRectangle

    "Answer a Point, delta, such that self + delta is forced within aRectangle."

    "Altered so as to prefer to keep self topLeft inside when all of self

     cannot be made to fit 7/27/96 di"

    | dx dy |

    dx := 0.  dy := 0.

    self right > aRectangle right ifTrue: [dx := aRectangle right - self right].

    self bottom > aRectangle bottom ifTrue: [dy := aRectangle bottom - self bottom].

    (self left + dx) < aRectangle left ifTrue: [dx := aRectangle left - self left].

    (self top + dy) < aRectangle top ifTrue: [dy := aRectangle top - self top].

    ^ dx@dy

!

containsRect:aRect

    "Answer whether aRect is within the receiver (OK to coincide)."

    ^ self contains:aRect

!

isTall

    "return true, if the receiver is higher then its width"

    ^ self height > self width

!

isWide

    "return true, if the receiver is wider then its height"

    ^ self width > self height

!

translatedToBeWithin: aRectangle

    "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.

    corner := self corner.

    ^ origin corner:(corner x @ (origin y + height))

! !

!Rectangle methodsFor:'accessing'!

area

    "return the area

     - for screen Rectangles this is the number of pixels"

    ^ width * height

!

bottom

    "return the y coordinate of the bottom"

    ^ (top + height)

!

bottom:aNumber

    "set the bottom edge - warning: destructive"

    height := aNumber - top

!

bottomCenter

    "return the bottom center point"

    ^ (left + (width / 2)) @ (top + height)

    "Modified: 4.6.1996 / 16:04:08 / cg"

!

bottomLeft

    "return the bottom-left point"

    ^ left @ (top + height)

!

bottomRight

    "return the bottom-right point"

    ^ (left + width) @ (top + height)

!

center

    "return the point in the center of the receiver"

    ^ (left + (width / 2)) @ (top + (height / 2))

    "Modified: 4.6.1996 / 16:03:53 / cg"

!

corner

    "return the corner"

%{  /* NOCONTEXT */

    if (__qClass(self) == @global(Rectangle)) {

        OBJ _tleft = __INST(left);

        OBJ _ttop = __INST(top);

        OBJ _twidth = __INST(width);

        OBJ _theight = __INST(height);

        if (__bothSmallInteger(_tleft, _ttop)

         && __bothSmallInteger(_twidth, _theight)) {

            if (__CanDoQuickNew(sizeof(struct __Point))) {      /* OBJECT ALLOCATION */

                OBJ newPoint;

                int spc;

                int cX = __intVal(_tleft) + __intVal(_twidth);

                int cY = __intVal(_ttop) + __intVal(_theight);

                if (__ISVALIDINTEGER(cX) && __ISVALIDINTEGER(cY)) {

                    __qCheckedNew(newPoint, sizeof(struct __Point));

                    __InstPtr(newPoint)->o_class = @global(Point); __qSTORE(newPoint, @global(Point));

                    __PointInstPtr(newPoint)->p_x = __MKSMALLINT(cX);

                    __PointInstPtr(newPoint)->p_y = __MKSMALLINT(cY);

                    RETURN ( newPoint );

                }

            }

        }

    }

%}.

    ^ (left + width) @ (top + height)

    "

        (self origin:0@0 corner:100@100)   corner

        (self origin:0@0 corner:100@100)   origin

        (self origin:5@5 corner:100@100)   extent

    "

!

corner:aPoint

    "set the bottom-right corner - warning: destructive"

    width := aPoint x - left.

    height := aPoint y - top

!

extent

    "return the extent"

%{  /* NOCONTEXT */

    if (__CanDoQuickNew(sizeof(struct __Point))) {      /* OBJECT ALLOCATION */

        if (__qClass(self) == @global(Rectangle)) {

            OBJ newPoint;

            int spc;

            OBJ newX = __INST(width);

            OBJ newY = __INST(height);

            __qCheckedNew(newPoint, sizeof(struct __Point));

            __InstPtr(newPoint)->o_class = @global(Point); __qSTORE(newPoint, @global(Point));

            __PointInstPtr(newPoint)->p_x = newX;

            __PointInstPtr(newPoint)->p_y = newY;

            if (! __bothSmallInteger(newX, newY)) {

                spc = __qSpace(newPoint);

                __STORE_SPC(newPoint, newX, spc);

                __STORE_SPC(newPoint, newY, spc);

            }

            RETURN ( newPoint );

        }

    }

%}.

    ^ Point x:width y:height

!

extent:aPoint

    "set the extent from the argument, aPoint 

     with width taken from aPoint x and height taken from aPoint y.

     warning: destructive"

    width := aPoint x.

    height := aPoint y

    "Modified (comment): / 27-11-2017 / 10:57:46 / cg"

!

height

    "return the height of the rectangle"

    ^ height

!

height:aNumber

    "change the height of the rectangle.

     logically, this changes the corner to get the given height.

     warning: destructive"

    height := aNumber