Tray  -  compose interactors into arbitrary or constrained
       layouts

SYNOPSIS

       #include <InterViews/tray.h>

DESCRIPTION

       A tray is a scene of interactors that  overlap,  tile,  or
       have other constraints on their alignment relative to each
       other.  One of the interactors in a tray can  serve  as  a
       background for the other interactors.

       Constraints  on  the  layout  of  interactors  are made by
       aligning interactors to each other.  Two  interactors  are
       aligned  by specifying which edges coincide.  For example,
       the lower left corner of one interactor may be aligned  to
       the  upper right of another.  TGlue objects can be used to
       introduce transparent space between  aligned  interactors.
       TGlue  has a natural size, shrinkability, and stretchabil-
       ity (though TGlue objects  are  not  interactors).   Trays
       stretch  or shrink the TGlue along with the aligned inter-
       actors to satisfy the alignment constraints.

       The tray adopts the shape of the background interactor  if
       there  is  one; otherwise, the tray's shape depends on the
       shapes of its components and potentially on  their  align-
       ments.  By default, a tray without a background takes on a
       width and height equal to the largest of  the  widths  and
       heights  of its components.  However, alignments involving
       the tray can in effect override this default.

       For example, if the left and right sides of  a  particular
       component  are aligned to the tray's left and right sides,
       respectively, then the tray's  sides  are  constrained  to
       coincide  with  the component's sides.  Thus the tray will
       adopt the width, horizontal shrinkability, and  horizontal
       stretchability  of  that  component.   Another example: To
       ensure that a tray circumscribes a collection of (mutually
       aligned)  components,  align the outer edges of the compo-
       nents on the periphery of  the  collection  to  the  outer
       edges of the tray, thereby constraining the tray to assume
       the shape of the collection.

TGLUE PUBLIC OPERATIONS

       TGlue(int w = 0, int h = 0, int hstretch = hfil, int
              vstretch  = vfil);
              Define TGlue of a  minimum  size.   The  TGlue  can
              stretch from the given size but cannot shrink.

       TGlue(int,  int,  int  hshrink,  int  hstretch,  int
              vshrink, int vstretch);
              Define  general  TGlue  with  a  given natural size

TRAY PUBLIC OPERATIONS

       Tray(Interactor* background = nil)
              Create  a new tray, optionally having an interactor
              as a background.

       void Align(Alignment, Interactor*, TGlue* = nil)
       void Align(Alignment, Interactor*, Alignment, Interactor*,
              TGlue* = nil)
              Align an interactor to another interactor (the tray
              itself  by  default), optionally with TGlue between
              them.  Align operations insert interactors into the
              tray if they have not been inserted already.

       void Align(Alignment, Interactor*, ..., Interactor* = nil)
              Apply an alignment to a set of  interactors.   This
              operation is shorthand for aligning the interactors
              to each other explicitly.  For example, Align(Left,
              i1,  i2,  i3, i4) aligns the left sides of interac-
              tors i1 through i4.  Two to seven  interactors  can
              be aligned at once.

       void HBox(Interactor*, ..., Interactor* = nil)
       void VBox(Interactor*, ..., Interactor* = nil)
              The  HBox  and  VBox operations align the specified
              interactors such that they tile  left-to-right  and
              top-to-bottom,   respectively.    These  operations
              align in one dimension only.  Two to seven interac-
              tors  can  be aligned at once.  If the first (last)
              component is the tray or the background interactor,
              then  the  leftmost  (rightmost)  component will be
              aligned with the left (right) side of the tray.

       void Insert(Interactor*)
              Insert an  interactor  into  the  tray  without  an
              alignment.  The interactor will appear in the lower
              left corner of the tray.

       void Change(Interactor*)
              Notify the tray that the given  interactor's  shape
              has changed.  The tray will recompute the layout of
              its component interactors  to  satisfy  any  align-
              ments.   If the tray does not contain a background,
              then a change in the shape of one of its components
              may  in  turn change the tray's shape.  If the tray
              has a background, then the tray's shape will change
              only if the shape of the background changes.

       void Remove(Interactor*)
              Take  an interactor out of a tray and eliminate any
              alignments that have been made to it.

       Interactor(3I), Scene(3I), Shape(3I)