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


       Viewer - displays a graphical component view hierarchy


       #include <Unidraw/viewer.h>


       A  Viewer  displays  a graphical component view and provides an interface to scrolling and
       zooming it.  The viewer also processes user input events  and  generates  the  appropriate
       calls  on  Unidraw  objects in response.  The Viewer class is a derived from GraphicBlock;
       thus it can draw the structured graphics hierarchy embodied in GraphicView's  graphic.   A
       viewer uses a damage object to keep the screen up to date.  Viewer's sensor catches up and
       down events, and its Handle implements implements the tool manipulation loop.


           Editor*, GraphicView*, Page*, Grid* = nil,
           Coord width = 0, Coord height = 0, Orientation = Normal,
           Alignment = Center, Zooming = Binary

           const char*, Editor*, GraphicView*, Page*, Grid* = nil,
           Coord width = 0, Coord height = 0
           Alignment = Center, Zooming = Binary
              Both constructors take the enclosing editor, the GraphicView object that the viewer
              will  display,  a  page  object, and optionally a grid, a natural width and height,
              initial page orientation, alignment, and zooming specifications.  The  second  form
              adds a parameter for specifying the Viewer's instance name.

       virtual void Update()
              Viewer  augments  GraphicBlock's  Update semantics by repairing any damage that has
              been accumulated.  In addition, Update will  replace  its  graphical  view  if  its
              subject  differs  from  the  editor's  component;  in  that  case, it will create a
              graphical view of the editor's component, delete its own view, and replace it  with
              the new one.

       virtual void Adjust(Perspective&)
              Viewer's  Adjust  operation will automatically update the editor's MagnifVar (if it
              defines one) to reflect the current magnification.

       virtual void Handle(Event&)
              By default, Handle employs the editor's current tool on a LEFTMOUSE down event.  On
              MIDDLEMOUSE or RIGHTMOUSE down events, it momentarily engages the editor's MoveTool
              or SelectTool, respectively, allowing the  user  to  move  or  select  a  graphical
              component  without  changing  the  current tool explicitly.  Nothing happens if the
              editor does not define a keyboard equivalent for engaging these tools.  The  Handle
              function  calls  either  the UseTool or MomentaryUseTool protected member functions
              (described below) in response to these events.

       virtual void SetGraphicView(GraphicView*)
       virtual void SetPage(Page*)
       virtual void SetGrid(Grid*)
       virtual GraphicView* GetGraphicView()
       virtual Page* GetPage()
       virtual Grid* GetGrid()
       virtual Editor* GetEditor()
              Explicitly set or get a constructor-specified parameter.  The Set operations delete
              the value they replace if it is different from the given one.

       virtual void SetMagnification(float)
              Viewer's  SetMagnification  operation  amends GraphicBlock::SetMagnification to set
              the value of the enclosing editor's MagnifVar, if it defines one.

       virtual void SetOrientation(Orientation)
       virtual Orientation GetOrientation()
              Set and get  the  viewer's  orientation  parameter,  which  specifies  whether  the
              graphical  view,  page,  and  grid  will  appear in portrait or landscape mode.  No
              transformation will be applied in portrait mode, while landscape mode  will  rotate
              the page -90 degrees and translate it vertically by an amount equal to the width of
              the page's bounding box.

       virtual Selection* GetSelection()
              Return the enclosing  editor's  selection  object;  it  is  equivalent  to  calling
              GetEditor and then calling GetSelection on the result.

       virtual Damage* GetDamage()
              Return the viewer's damage object.

       virtual void InitRubberband(Rubberband*)
       virtual void InitTextDisplay(TextDisplay*, Painter*)
              These  operations  let  Rubberband  and  TextDisplay  instances appear to work in a
              viewer by allowing them to draw on the viewer's canvas.   InitRubberband  sets  the
              rubberband's   canvas  to  the  viewer's  and  initializes  its  painter  as  well.
              InitTextDisplay likewise sets the TextDisplay's canvas to the  viewer's.   It  also
              modifies  the  given  painter's background color to match the viewer's and supplies
              the painter to the TextDisplay for its use.

       virtual void IncurTextDisplayDamage(TextDisplay*, Painter*)
              Incur minimal damage on the viewer's damage object to account for the TextDisplay's
              current size.  The TextDisplay's painter must be passed explicitly.

       virtual void CenterOp()
       virtual void Magnify(Coord, Coord, Coord, Coord)
       virtual void ReduceToFit()
              Convenience functions for adjusting the viewer's perspective.  CenterOp centers the
              page in the viewer's canvas without changing the  magnification.   Magnify  scrolls
              and  magnifies the given area (in canvas coordinates) so that it fills the viewer's
              canvas.  Magnify ensures that the area will remain fully  visible  in  the  viewer.
              ReduceToFit scrolls and reduces the view so that the entire page is visible.

       virtual void Constrain(Coord&, Coord&)
              Constrain  the supplied coordinates to fall on the nearest grid point if the viewer
              defines a grid and if the enclosing editor defines an active GravityVar.

       virtual void UseTool(Tool*)
              Commence direct-manipulation with the given tool without an explicit action on  the
              user's  part.   Normally,  direct  manipulation with the currently engaged tool (as
              returned by the editor's GetCurTool operation) starts automatically when  the  user
              clicks in the viewer.

       virtual void Align(GraphicComp*, Alignment)
              Align  the  graphical component with respect to viewer's canvas, assuming a view of
              the component appears in the viewer.  For  example,  a  ``Center''  alignment  will
              align  the  component's  center  with  the canvas'; a ``BottomLeft'' alignment will
              align the component's bottom-left corner to the canvas'.


       void Init(
           Editor*, GraphicView*, Page*, Grid*,
           Coord, Coord, Orientation

       void Init(Editor*, GraphicView*, Page*, Grid*)
              Initialize the viewer's  member  variables.   The  first  form  of  this  operation
              initializes  all  parameters  that  can be passed to a constructor.  The first form
              calls the second form, which initializes a subset of the attributes that may change
              independently of the others.

       Tool* CurTool()
              A  convenience  function  equivalent to calling the same operation on the enclosing

       Transformer* GetTransformer()
              Return the transformer that the viewer uses to implement scrolling and zooming.

       virtual void Manipulate(Manipulator*, Event&)
              This operation  implements  a  direct  manipulation  loop  governed  by  the  given
              manipulator.   First  it calls Grasp on the manipulator with the given event.  Then
              it reads events in a loop, calling the manipulator's  Manipulating  operation  with
              each  new  event.   When  Manipulating  returns  false,  it  calls  Effect  on  the
              manipulator with the event read last.

       virtual void UseTool(Tool*, Event&)
       virtual void MomentaryUseTool(Tool*, Event&)
              Helper functions for initiating direct manipulation with tools and executing  their
              effect.   UseTool  first instructs the given tool to create a manipulator, and then
              it calls Manipulate to carry the manipulation through to completion.  Next it  asks
              the  tool  to  interpret  the  manipulator,  which  in  turn may produce a command.
              Finally, UseTool executes and logs the command produced.   MomentaryUseTool  simply
              engages the given tool, calls UseTool, and re-engages the original tool.

       virtual void Reorient()
              A  helper  function  that  rotates  the  viewer's  graphic  to  reflect its current

       virtual void UpdateMagnifVar()
              A helper function  used  in  SetMagnification  to  notify  the  enclosing  viewer's
              MagnifVar (if it defines one) of the change in magnification.

       virtual ClassId ViewCategory()
              Returns  the  view  category (see classes(3U)) the viewer will use to instantiate a
              view if it is not given one explicitly.   ViewCategory  returns  COMPONENT_VIEW  by


       Damage(3U),   Editor(3U),   Event(3I),   Graphic(3U),  GraphicBlock(3U),  GraphicComp(3U),
       GraphicView(3U),  Grid(3U),  Manipulator(3U),  MoveTool(3U),  Page(3U),   Perspective(3I),
       Rubband(3I),   SelectTool(3U),   Selection(3U),   Sensor(3I),  TextDisplay(3I),  Tool(3U),
       classes(3U), globals(3U), statevars(3U)