Provided by: ivtools-dev_1.2.11a1-11_amd64 bug

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

       Rubband  is  the base class for a set of classes that provide graphical feedback to a user
       during an interactive operation such as  sizing  a  rectangle.   A  rubberband  varies  in
       appearance  as  its  tracking  point  changes.   A rubberband is not an interactor itself;
       interactors use rubberbands to provide animated  effects.   Because  rubberbands  are  not
       interactors,  rubberband  constructors  must  be  passed the painter and canvas to use for
       drawing.

PUBLIC OPERATIONS

       RubberLine(
           Painter*, Canvas*, Coord fx, fy, mx, my, offx = 0, offy = 0
       )
              A rubber line stretches 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 either horizontally or vertically to follow the tracking
              point while its other endpoint stays tied down.  One endpoint stays fixed while the
              other  moves  along  either the horizontal or vertical axis, whichever is closer to
              the tracking point.

       SlidingLine(
           Painter*, Canvas*, Coord x0, y0, x1, y1, rfx, rfy,
           Coord offx = 0, offy = 0
       )
              A sliding line slides around without changing its length or 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 rotates 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
              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)  to  keep  one
              edge 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.  The 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  that
              changes shape as the control point indexed by pt is 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 index by pt 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 containing a list of vertices that grows
              or shrinks dynamically.  The pt parameter specifies the index of  the  vertex  that
              will follow the tracking point; a value of -1 specifies a vertex after the last one
              in the list.  The handleSize parameter specifies the size of the  handle  drawn  at
              each vertex (as in RubberHandles above); a value of -1 specifies that no handles be
              drawn.

              The AddVertex operation adds a 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,  providing  operations for including,
              excluding, and traversing its children. RubberGroups are useful for  combining  the
              behavior  of  several  rubberbands  into one, eliminating the need to call Track on
              multiple rubberbands. The RubberGroup's SetCanvas and SetPainter operations set the
              children's canvas and painter as well as the RubberGroup's, but the children do not
              otherwise 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 be drawn.  Since rubberbands are drawn in XOR mode, Redraw will erase
              the rubberband every other time it is called.  These functions  are  used  only  on
              occasion,  for  example,  when  part  of the screen is erased while a rubberband is
              visible.  The Track function is normally used 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.  The meaning  of
              the  points  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 used by the rubberband.  By default, rubberbands
              use a copy of the painter passed to their constructor.   The  user  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 used by the rubberband.

SEE ALSO

       Canvas(3I), Painter(3I)