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


       Component - base class for objects that model domain-specific elements


       #include <Unidraw/Components/component.h>


       Component  is an abstract base class for objects that are created, edited, and composed to
       form domain-specific drawings.  Components represent the objects of interest in an editing
       domain,  encapsulating  their appearance and semantics.  Components are partitioned into a
       subject and zero or more views: the subject encapsulates the context-independent state and
       operations  of a component, and each view supports a context-dependent presentation of the
       subject.  A subject notifies its views whenever its state is modified  to  allow  them  to
       change their state or appearance to reflect the modification.  The Component class defines
       the protocol for component subjects,  while  ComponentView  is  the  abstract  base  class
       defining  the protocol for component views.  See ComponentView(3U) for more information on
       the component view class.


       virtual void Interpret(Command*)
       virtual void Uninterpret(Command*)
              Interpret performs a component-specific operation based  on  the  type  of  command
              passed.   Uninterpret reverses the effects of a preceding Interpret.  The component
              is responsible for storing enough state (either in itself or  in  the  command)  to
              carry out the Uninterpret operation.

       virtual void Attach(ComponentView*)
       virtual void Detach(ComponentView*)
              Attach  adds  a  component  view  to  the  component's list of views.  Note that by
              default these operations do not check to ensure that the view  is  compatible  with
              the subject.  Detach removes the argument from the component's list of views.

       virtual void Notify()
              Notify  the  component's  views  that  its state has changed.  This operation calls
              Update on each view in the component's list of attached views.

       virtual void Update()
              Other classes may use this operation to notify the component subject of a  possible
              change  in  state  that  the component depends upon. This operation does nothing by

       virtual Component* GetParent()
       virtual TransferFunct* GetTransferFunct()
              Return the component's parent and transfer  function,  if  any.   These  operations
              return nil by default.

       virtual Component* GetRoot()
              Return  the  root component in this hierarchy.  GetRoot calls GetParent recursively
              and returns the last non-nil parent, if any.

       virtual StateVar* GetState(const char*)
              The component may maintain a string-to-state variable mapping to  provide  external
              access  to  any state variables it defines.  The GetState operation returns a state
              variable given an identifying string.  Defining such a mapping lets  other  objects
              (typically  commands)  query  the  component for state variables that it may define
              without extending the  component  protocol,  potentially  allowing  interchange  of
              components from different applications.  This operation returns nil by default.

       virtual void First(Iterator&)
       virtual void Last(Iterator&)
       virtual void Next(Iterator&)
       virtual void Prev(Iterator&)
       virtual boolean Done(Iterator)
              Operations  for iterating over the component subject's children, if any.  First and
              Last initialize an iterator to point to the  beginning  and  end  of  the  list  of
              children,  respectively.   Next  increments  the iterator to point to the following
              child, while Prev decrements the iterator to point to the  preceding  child.   Done
              returns  whether  or  not the iterator points beyond the first or last child in the

       virtual Component* Copy()
              Return a copy of the component.   Subclasses  should  redefine  this  operation  to
              return an instance of their type.

       virtual void Read(istream&)
       virtual void Write(ostream&)
              Read  and write the component's contents to a stream to support catalog operations.
              Read and write typically call first the corresponding operations defined  by  their
              parent  class,  and  then they read or write their class-specific state.  Note that
              you must ensure that the objects are read in the same order they are written.

       virtual ClassId GetClassId()
       virtual boolean IsA(ClassId)
              GetClassId returns the unique class identifier for the  Component  subclass,  while
              IsA  returns  whether  the  instance is of a class or subclass corresponding to the
              given identifier.  IsA typically checks the given identifier against the instance's
              own  (as  defined  by its GetClassId operation) and, failing that, calls its parent
              classes' IsA operation.  All subclasses must redefine GetClassId and IsA to  ensure
              that their identifiers are unique and that instances are written and read properly.

       virtual ClassId GetSubstId(const char*& delim)
              A  Component  subclasses  can  redefine  GetSubstId to specify a component that can
              substitute for it.   This  lets  applications  that  do  not  define  a  particular
              component subclass still read in a substitute that is compatible with the subclass.
              The substitute class should be one of the  predefined  components  in  the  Unidraw
              library.  This guarantees that all applications can instantiate the substitute.

              GetSubstId  returns  the  class  identifier  for  the  substitute.  When an another
              Unidraw application's catalog reads this object, it can create an instance  of  the
              substitute (which it is guaranteed to define) instead of the original (which it may
              not define).

              The original should read and write  a  superset  of  the  substitute's  data.   The
              catalog  will  read to the end of the substitute's data and then advance the stream
              to the point following the sequence of characters specified by  delim,  saving  the
              extra  characters between the two points in the stream.  When the substitute object
              is saved subsequently, the original class identifier will be written along with the
              substitute's  data  plus  the  extra characters saved previously.  Thus information
              needn't be lost as a result  of  being  read  and  written  by  an  unsophisticated

       ComponentView* Create(ClassId)
              Create  a  view instance that is appropriate for the component subject given a view
              category.  The relationship between subjects, views, and view categories is encoded
              in  their  class  identifiers.   See  classes(3U)  for  more  information  on class
              identifiers and view categories.


       void Component()
              The Component class is abstract; therefore the constructor is protected.

       ComponentView* View(UList*)
              Each component maintains a list of its  views,  implemented  with  a  UList.   This
              operation returns the component view associated with a given entry in the UList.

       virtual void SetParent(Component* child, Component* parent)
              Notify  a  child  component  that it has a new or different parent.  This operation
              does nothing by default.  Composite components should call this function  in  their
              structure-modifying  operations,  and  components that keep information about their
              parents should redefine it to update this information.


       Catalog(3U),  Command(3U),  ComponentView(3U),  Creator(3U),  Iterator(3U),   StatVar(3U),
       TransferFunct(3U), UList(3U), classes(3U), istream(3C++), ostream(3C++)