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


       AlignCmd, AlignToGridCmd - commands for aligning interactors to each other and to a grid


       #include <Unidraw/Commands/align.h>


       AlignCmd is a purely interpretive command for aligning selected components with respect to
       one another. For example, it can align the left sides of selected components so that  they
       coincide.   AlignToGridCmd  is  interpreted  by  selected  GraphicView  objects  to  align
       themselves to the grid (if any) associated with the viewer in  which  they  appear.   Each
       component can thus define what it means to align itself to the grid.


           Alignment reference = Left, Alignment affected = Left

       AlignCmd(Editor* = nil, Alignment = Left, Alignment = Left)
              The  constructor takes optional arguments for specifying the alignment desired. The
              reference parameter specifies a point on a fixed reference component.  The affected
              parameter  specifies a point on components that will move to realize the alignment.
              The defaults for these parameters specify that all affected components should align
              their left sides to reference's left side.

       void GetAlignment(Alignment&, Alignment&)
              Return the alignment parameters specified in the constructor.

       GraphicComp* GetReference(GraphicComp* affected)
              Return the reference component given a potentially affected component.  If affected
              appears in the AlignCmd's clipboard,  then  GetReference  returns  the  GraphicComp
              preceding it in the clipboard.  If affected is the first component in the clipboard
              or if it is not on the clipboard, then GetReference returns the first component  on
              the clipboard.


       AlignToGridCmd(Editor* = nil)
              Construct an AlignToGridCmd.

       virtual void Execute()
       virtual void Unexecute()
              AlignToGridCmd  redefines Execute to let the selected GraphicView objects interpret
              the command the first time.  This lets the components  determine  the  proper  grid
              with  which  to  align  themselves  and  the  amount of movement required.  Execute
              assumes that GraphicView objects will use the Align operation (described below)  to
              compute  the amount of movement, store it in a MoveData object, and finally issue a
              MoveCmd  to  the  subject  for  interpretation.   Unexecute  simply  calls   Unmove
              (described below) to reverse the Align's effects.

       virtual void Align(GraphicView*, float, float)
       virtual void Unalign(GraphicView*)
              GraphicView  objects interpreting the AlignToGridCmd should use the Align operation
              to specify a point to align to the grid that affects them.  Align will  effectively
              move  the  component so that the given point falls on the grid.  It will also store
              the amount of movement in this by calling Store with a MoveData  object.   Finally,
              Align  calls  Move  (described  below)  to actually move the component that amount.
              Unalign provides a public interface to reversing the effects  of  Align  by  simply
              calling Unmove with its argument's subject.


       void Move(GraphicComp*)
       void Unmove(GraphicComp*)
              Move  produces a MoveCmd based on the MoveData stored for the given GraphicComp and
              tells the GraphicComp to interpret the  MoveCmd.   Conversely,  Unmove  produces  a
              MoveCmd  based on the the same information and tells the GraphicComp to uninterpret


       Command(3U),   GraphicComp(3U),   GraphicView(3U),   Grid(3U),   Viewer(3U),    datas(3U),