Component - base class for objects that model domain-specific elements
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
- 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
- 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 default.
- 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 list.
- 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
- virtual ClassId GetSubstId(const char*&
- 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 application.
- 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
- void Component()
- The Component class is abstract; therefore the constructor
- 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*
- 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++),