Rubband(3I)

okay so bestie, we're reading Rubband(3I), straight from the InterViews Reference Manual, and it's lowkey giving "base class of a whole squad" and I'm obsessed 💖

✨ NAME ✨

Rubband — rubberbanding graphical objects 🎀

✨ SYNOPSIS ✨

#include <InterViews/rubband.h>
#include <InterViews/rubcurve.h>
#include <InterViews/rubgroup.h>
#include <InterViews/rubline.h>
#include <InterViews/rubrect.h>
#include <InterViews/rubverts.h>

🌈 DESCRIPTION 🌈

So Rubband is the base class for a whole little family of classes that hand the user some graphical feedback while they're mid-interaction — think sizing a rectangle, dragging stuff around, all that ✨. A rubberband's whole look changes as its tracking point moves, which is the entire point of it fr fr.

Important vibe check: a rubberband is not an interactor itself 🙅‍♀️. Interactors are the ones that use rubberbands to make animated effects happen. And because rubberbands aren't interactors, their constructors have to be handed the painter and canvas they should draw with. No painter, no canvas, no drawing, periodt.

💅 PUBLIC OPERATIONS 💅

• RubberLine(Painter*, Canvas*, Coord fx, fy, mx, my, offx = 0, offy = 0) — a rubber line stretches out to follow the tracking point, while its other endpoint stays tied down 🔗
• RubberAxis(Painter*, Canvas*, Coord fx, fy, mx, my, offx = 0, offy = 0) — a rubber axis stretches horizontally or vertically to follow the tracking point while its other endpoint stays tied down. One endpoint stays fixed, and the other one moves along either the horizontal or the vertical axis — whichever one is closer to the tracking point 👑
• SlidingLine(Painter*, Canvas*, Coord x0, y0, x1, y1, rfx, rfy, Coord offx = 0, offy = 0) — a sliding line just slides around, and it does not change its length or its angle as the tracking point moves around a reference point 🛝
• RotatingLine(Painter*, Canvas*, Coord x0, y0, x1, y1, rfx, rfy, Coord offx = 0, offy = 0) — a rotating line spins around (cx, cy), based on the angle between the radius from (cx, cy) to (rfx, rfy) and the radius from (cx, cy) to the tracking point 🌀
• RubberRect(Painter*, Canvas*, Coord fx, fy, mx, my, offx = 0, offy = 0) — a rubber rectangle stretches to follow the tacking point while its opposite corner stays tied down 📐
• SlidingRect(Painter*, Canvas*, Coord x1, y1, x2, y2, rfx, rfy, Coord offx = 0, offy = 0) — a sliding rectangle slides around the screen without changing its side or its orientation as the tracking point moves around a reference point 🧊
• ScalingRect(Painter*, Canvas*, Coord x1, y1, x2, y2, cx, cy, Coord offx = 0, offy = 0) — a scaling rectangle scales equally in both dimensions about (cx, cy), so that one edge keeps intersecting the tracking point 📏
• RotatingRect(Painter*, Canvas*, Coord x1, y1, x2, y2, cx, cy, rfx, rfy, Coord offx = 0, offy = 0) — a rotating rectangle rotates about (cx, cy), based on the radius from (cx, cy) to (rfx, rfy) and the radius from (cx, cy) to the tracking point 🔄
• StretchingRect(Painter*, Canvas*, Coord x1, y1, x2, y2, Side ts, Coord offx = 0, offy = 0) — a stretching rectangle's tracking side follows the tracking point while the opposite side stays fixed. That side can be one of LeftSide, RightSide, BottomSide, or TopSide 🫱
• RubberCircle(Painter*, Canvas*, Coord cx, cy, rx, ry, offx = 0, offy = 0) — a rubber circle's radius varies with the magnitude of the tracking point's distance from (cx, cy) ⭕
• RubberEllipse(Painter*, Canvas*, Coord cx, cy, rx, ry, offx = 0, offy = 0) — a rubber ellipse's horizontal and vertical radii vary with the magnitude of the tracking point's distance from (cx, cy) 🥚
• RubberSpline(Painter*, Canvas*, Coord x[], y[], int n, pt, Coord offx = 0, offy = 0)
• RubberClosedSpline(Painter*, Canvas*, Coord x[], y[], int n, pt, Coord offx = 0, offy = 0) — a rubber spline is the section of a B-spline defined by n control points, and it changes shape as the control point indexed by pt gets set to the tracking point 🪢
• RubberHandles(Painter*, Canvas*, Coord x[], y[], int n, pt, size, Coord offx = 0, offy = 0) — a rubber handles object is a set of filled squares centered about each point in the list. The point indexed by pt is the one that follows the tracking point 🟨
• SlidingPointList(Painter*, Canvas*, Coord x[], y[], int n, pt, Coord rfx, rfy, Coord offx = 0, offy = 0) — a sliding point list slides around the screen without changing its appearance as the tracking point moves around a reference point 🛷
• SlidingLineList(Painter*, Canvas*, Coord x[], y[], int n, pt, Coord rfx, rfy, Coord offx = 0, offy = 0) — a sliding line list slides around the screen without changing the appearance of its connected lines as the tracking point moves around (rfx, rfy) 🧵
• ScalingLineList(Painer*, Canvas*, Coord x[], Coord y[], int n, Coord cx, cy, rfx, rfy, offx = 0, offy = 0) — a scaling line list scales a list of lines about (cx, cy) to keep the line list's bounding box intersecting the tracking point 📦
• RotatingLineList(Painer*, Canvas*, Coord x[], Coord y[], int n, Coord cx, cy, rfx, rfy, offx = 0, offy = 0) — a rotating line list rotates a list of lines about (cx, cy), based on the angle between the radius from (cx, cy) to (rfx, rfy) and the radius from (cx, cy) to the tracking point 🌪️
• GrowingVertices(Painter*, Canvas*, Coord x[], y[], int n, int pt = -1, int handleSize = -1)
• GrowingMultiLine(Painter*, Canvas*, Coord x[], y[], int n, int pt = -1, int handleSize = -1)
• GrowingPolygon(Painter*, Canvas*, Coord x[], y[], int n, int pt = -1, int handleSize = -1)
• GrowingBSpline(Painter*, Canvas*, Coord x[], y[], int n, int pt = -1, int handleSize = -1)
• GrowingClosedBSpline(Painter*, Canvas*, Coord x[], y[], int n, int pt = -1, int handleSize = -1)
• virtual void AddVertex(Coord, Coord)
• virtual void RemoveVertex() — GrowingVertices is an abstract rubberband holding a list of vertices that grows or shrinks dynamically 🌱

The pt parameter says which vertex index will follow the tracking point; a value of -1 means a vertex after the last one in the list. The handleSize parameter says how big the handle drawn at each vertex is (same deal as RubberHandles above); a value of -1 means no handles get drawn at all.

The AddVertex operation adds a brand-new vertex at the tracking point to the list, and makes the next (or last) vertex in the list follow the tracking point. RemoveVertex removes the vertex at the tracking point and makes the previous (or first) vertex the new tracking point. GrowingMultiLine, GrowingPolygon, GrowingBSpline, and GrowingClosedBSpline are GrowingVertices subclasses that draw a multiline, polygon, B-spline, and closed B-spline, respectively 🎨

• RubberGroup(Painter*, Canvas*)
• void Append(Rubberband*, Rubberband* = nil, Rubberband* = nil, Rubberband* = nil)
• void Remove(Rubberband*)
• void RemoveCur()
• void SetCurrent(Rubberband*)
• Rubberband* GetCurrent()
• Rubberband* First()
• Rubberband* Last()
• Rubberband* Next()
• Rubberband* Prev()
• boolean IsEmpty()
• boolean AtEnd() — a RubberGroup composes other rubberbands together, handing you operations for including, excluding, and traversing its children 👯‍♀️. RubberGroups are useful for combining the behavior of several rubberbands into one, which means you don't have to call Track on a bunch of rubberbands separately. The RubberGroup's SetCanvas and SetPainter operations set the children's canvas and painter as well as the RubberGroup's own — but other than that, the children do not inherit the group's canvas and painter. The Track operation calls Track on each child with the same parameters.
• virtual void Draw()
• void Redraw()
• virtual void Erase() — explicitly draw, redraw, and erase the rubberband ✏️. Multiple calls to Draw without an intervening Erase will only draw the rubberband once. Redraw forces the rubberband to actually be drawn. And since rubberbands are drawn in XOR mode, Redraw will erase the rubberband every other time it's called 😭. These functions are used only on occasion — for example, when part of the screen gets erased while a rubberband is visible. Track is normally what you use to draw the rubberband in response to mouse input.
• virtual void Track(Coord x, Coord y) — erase the rubberband and redraw it using the new tracking point 🖱️
• void GetOriginal(Coord& x1, Coord& y2, Coord& x2, Coord& y2)
• void GetCurrent(Coord& x1, Coord& y2, Coord& x2, Coord& y2) — GetOriginal obtains the original points specified for the rubberband. GetCurrent obtains the current points based on the most recent call to Track. What those points mean depends on the kind of rubberband: for lines, the points are the endpoints; for rectangles, the points are opposite corners; for curves, (x1, y1) is the center and x2 and y2 are the radii 📍
• virtual void SetPainter(Painter*)
• Painter* GetPainter() — explicitly set and get the painter the rubberband uses 🎨. By default, rubberbands use a copy of the painter passed to their constructor. You can specify a particular painter to use by passing a nil painter to the constructor and later calling SetPainter.

N.B.: the rubberband may alter the painter specified via SetPainter 😳

• virtual void SetCanvas(Canvas*)
• Canvas* GetCanvas() — explicitly set and get the canvas the rubberband uses 🖼️

👀 SEE ALSO 👀

Canvas(3I), Painter(3I) — go read those too, bestie, iykyk 💖

and that's the whole page!! InterViews, dated 15 June 1987 — iconic vintage behavior, no cap 🎀✨💅🦋