Ubuntu Manpage: GraphicComp, GraphicComps - base classes for graphical component subjects

name
synopsis
description
graphiccomp public operations
graphiccomp protected operations
graphiccomps public operations
graphiccomps protected operations
see also

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

NAME

       GraphicComp, GraphicComps - base classes for graphical component subjects

SYNOPSIS

       #include <Unidraw/Components/grcomp.h>

DESCRIPTION

       GraphicComp  is  an  abstract  base  class  for  components that store graphical information in a Graphic
       object.  GraphicComp is derived from  Component  and  adds  operations  for  manipulating  its  graphical
       attributes.   GraphicComps  is  a  non-abstract subclass of GraphicComp for composite graphical component
       subjects.

GRAPHICCOMP PUBLIC OPERATIONS

       virtual ~GraphicComp()
              The destructor deletes the GraphicComp's graphic, if any.

       virtual void Interpret(Command*)
       virtual void Uninterpret(Command*)
              GraphicComp objects can (un)interpret the following commands:

              AlignCmd aligns the GraphicComp's graphic with respect to the graphic in the GraphicComp  returned
              by  AlignCmd::GetReference.   The alignment's sense is defined by the alignments that the AlignCmd
              specifies:  The  first  Alignment  parameter  returned  by  AlignCmd::GetAlignment  specifies  the
              alignment  with  respect  to the reference graphic, while the second Alignment parameter specifies
              the alignment with respect to this's graphic.

              BrushCmd sets the graphic's brush to the BrushCmd's value.

              ColorCmd sets the graphic's foreground and background colors.

              FontCmd sets the graphic's font.

              MobilityCmd sets the GraphicComp's mobility to the MobilityCmd's value.

              MoveCmd translates the GraphicComp's graphic by the amounts in the MoveCmd.

              PatternCmd sets the graphic's pattern.

              RotateCmd rotates the GraphicComp's graphic by the amount in the RotateCmd.

              ScaleCmd scales the GraphicComp's graphic by the amounts in the ScaleCmd.

       virtual Graphic* GetGraphic()
              Return the GraphicComp's graphic.  GraphicComp subclass normally redefine this operation to return
              the graphic that defines their appearance.

       virtual Component* GetParent()
              GraphicComp  redefines  GetParent  to  return  its  parent.  However, GraphicComp does not store a
              pointer to the parent explicitly; instead,  it  obtains  its  graphic's  parent  and  obtains  the
              GraphicComp  associated with the parent graphic.  The graphic stores the GraphicComp that contains
              it in its tag (see SetGraphic below).

       GraphicComp* GetComp(Iterator)
       void SetComp(GraphicComp*, Iterator&)
              These operations do nothing by default.  Subclasses that contain children should redefine them  as
              follows:  GetComp  should  return  the  GraphicComp  to  which an iterator points.  SetComp should
              initialize the iterator to point to a particular GraphicComp in the list of  children;  it  should
              initialize the iterator to point to a nil instance if the given GraphicComp is not a child.

       void Append(GraphicComp*)
       void Prepend(GraphicComp*)
       void InsertAfter(Iterator, GraphicComp*)
       void InsertBefore(Iterator, GraphicComp*)
       void Remove(GraphicComp*)
       void Remove(Iterator&)
              Unimplemented  operations  that  composite  subclasses  should  redefine  for  modifying the their
              (conceptual) list of children.  Note that subclasses needn't necessarily store their children in a
              list data structure, but a list maps closely to the semantics of these operations.

              Append  and  Prepend  add  a  GraphicComp  to the end and the beginning of the list, respectively.
              InsertAfter and InsertBefore insert a GraphicComp after and before the GraphicComp pointed  to  by
              the  iterator,  respectively.   The Remove operations remove a view from the list without deleting
              it.  You can remove a view instance by referring to it explicitly or by  specifying  an  iterator.
              If  an iterator is supplied, the Remove operation should advance it to point to the following view
              as a side effect.

       virtual void Bequeath()
              Modify the GraphicComp's graphic state by calling  Bequeath  on  its  Graphic.   Graphic::Bequeath
              propagates  this's graphic state to its immediate children, nullifying its own graphics state; see
              Graphic(3U) for a more complete description.

       virtual Mobility GetMobility()
       virtual void SetMobility(Mobility)
              Get and set the GraphicComp's mobility.  GetMobility returns Undef  by  default,  and  SetMobility
              does nothing.

GRAPHICCOMP PROTECTED OPERATIONS

       GraphicComp(Graphic* = nil)
              The  Graphic  instance that defines the GraphicComp's graphical attributes can be specified in the
              constructor, which is protected to guard against instantiation.

       virtual void SetGraphic(Graphic*)
       virtual GraphicComp* GetGraphicComp(Graphic*)
              SetGraphic sets the GraphicComp's graphic to the given one, and store this in  the  graphic  using
              Graphic::SetTag.   This makes it possible to obtain the GraphicComp that owns the graphic from the
              graphic itself.  GetGraphicComp returns the GraphicComp associated with the given graphic.

       void Skip(istream&)
       void Mark(ostream&)
              Convenience functions that simply call their Catalog counterparts.

       int ReadBgFilled(istream&)
       PSBrush* ReadBrush(istream&)
       PSColor* ReadColor(istream&)
       PSFont* ReadFont(istream&)
       PSPattern* ReadPattern(istream&)
       PSTransformer* ReadTransformer(istream&)
       char* ReadString(istream&)
       Bitmap* ReadBitmap(istream&)
       Raster* ReadGraymap(istream&)
       Raster* ReadRaster(istream&)
       void ReadVertices(istream&, Coord*&, Coord*&, int&)

       void WriteBgFilled(boolean, ostream&)
       void WriteBrush(PSBrush*, ostream&)
       void WriteColor(PSColor*, ostream&)
       void WriteFont(PSFont*, ostream&)
       void WritePattern(PSPattern*, ostream&)
       void WriteTransformer(PSTransformer*, ostream&)
       void WriteString(const char*, ostream&)
       void WriteBitmap(Bitmap*, ostream&)
       void WriteGraymap(Raster*, ostream&)
       void WriteRaster(Raster*, ostream&)
       void WriteVertices(const Coord*, const Coord*, int, ostream&)
              Convenience functions for reading and writing common GraphicComp  information.   These  operations
              are  most  often  used  in  the  Read  and  Write  calls  of GraphicComp subclasses.  The Write...
              operations send a stream of bytes characterizing  their  first  parameter  to  the  ostream.   The
              Read... operations reconstruct the object(s) from the bytes that the istream supplies.

GRAPHICCOMPS PUBLIC OPERATIONS

GraphicComps()
GraphicComps(Graphic*)
virtual ~GraphicComps()
The parameterless constructor sets the GraphicComps' graphic to a new Picture instance, while the
other lets you specify the graphic explicitly. The destructor deletes its children.

virtual void Interpret(Command*)
virtual void Uninterpret(Command*)
GraphicComps can (un)interpret the following commands in addition to those that GraphicComp
objects (un)interpret:

BackCmd and FrontCmd change the position of the GraphicComps' children that are in the command's
clipboard object. If the command has no clipboard, it will create one and fill it with the
subjects of GraphicViews that are selected currently in the command's editor. Interpreting a
BackCmd will move the children on the clipboard so that they appear behind the others, preserving
their relative order; the opposite occurs when interpreting a FrontCmd.

CutCmd removes the components in the CutCmd's clipboard from the GraphicComps and places them in
the catalog's global clipboard. Interpret will create a clipboard containing the subjects of
selected GraphicViews if the CutCmd has no clipboard initially.

DeleteCmd removes the components in the DeleteCmd's clipboard from the GraphicComps and destroys
them when the DeleteCmd is destroyed if it has not been uninterpreted. Interpret will create a
clipboard containing the subjects of selected GraphicViews if the DeleteCmd has no clipboard
initially.

DupCmd duplicates the components in the DupCmd's clipboard, appending them to the list of
children. Interpret will create a clipboard containing the subject of selected GraphicViews if
the DupCmd has no clipboard initially.

GroupCmd removes the components in the GroupCmd's clipboard from the GraphicComps and inserts them
into the destination GraphicComp returned by GroupCmd::GetGroup. The destination is inserted at
the position formerly occupied by the last component in the clipboard. If the GroupCmd has no
clipboard initially, interpret will create a clipboard containing the subjects of selected
GraphicViews. If GroupCmd does not define a destination, Interpret will create a GraphicComps
instance and set the GroupCmd's destination explicitly. Interpret does nothing if the clipboard
contains less than two components.

UngroupCmd extracts the children from components in the UngroupCmd's clipboard and inserts them in
order immediately after their parents. The parents are then removed from the GraphicComps. The
parents are destroyed along with the UngroupCmd if it has not been Uninterpreted.

PasteCmd appends copies of the components in the PasteCmd's clipboard to the GraphicComps. If the
PasteCmd has no clipboard initially, it will use the global clipboard from the catalog.

GRAPHICCOMPS PROTECTED OPERATIONS

       GraphicComp* Comp(UList*)
       UList* Elem(Iterator)
              Convenience  functions  for  extracting  a  GraphicComp  from  a UList element and a UList from an
              iterator.

       void SelectViewsOf(GraphicComp*, Editor*)
              A convenience function for selecting all the views of the given GraphicComp  that  appear  in  the
              given editor.  SelectViewsOf clears the original contents of the selection.

       void SelectClipboard(Clipboard*, Editor)
              A  convenience  function  for selecting all the views of all the components in the given Clipboard
              that appear in the given editor.  SelectViewsOf clears the original contents of the selection.

       void StorePosition(GraphicComp*, Command*)
              Store the given child's position into the given Command with Command::Store.

       void RestorePosition(GraphicComp*, Command*)
              Insert the given GraphicComp into this based on position information stored in the given  command.
              The position information must have been stored with StorePosition.

       void Group(Clipboard*, GraphicComp* destination, Command*)
       void Ungroup(GraphicComp* parent, Clipboard*, Command*)
              Helper  functions  used  in  the  interpretation  of GroupCmd and UngroupCmd, respectively.  Group
              inserts the components in the clipboard  into  destination  and  inserts  destination  into  this,
              storing  undo  information in the command.  Ungroup removes all children from parent, puts them on
              the clipboard, and then removes parent from this.  Ungroup also stores  undo  information  in  the
              command.