Connector, ConnectorView - base classes for connector subjects and views
Connector is an abstract base class for graphical component subjects that
enforce different connectivity semantics depending on the particular connector
subclass. ConnectorView is the abstract base class for views of connector
subjects. A connector can be connected to one or more other connectors. Once
connected, two connectors can affect each other's position in specific ways as
defined by the semantics of the connection.
Connectors also participate in the propagation of state variable values during
dataflow. Two connected connectors with bound state variables will assign the
value of one state variable to other, and the direction of transfer depends on
the connectors' transmission method. For example, if the transmission method
of connector C1 with bound state variable S1 is In, and if the transmission
method of connector C2 with bound state variable S2 is Out, and if C1 and C2
are connected, then S1 will be assigned the value of S2 during dataflow.
- virtual void Interpret(Command*)
- virtual void Uninterpret(Command*)
- In addition to (un)interpreting the commands GraphicComp
(un)interprets, connectors also (un)interpret DeleteCmd and CutCmd to
sever and restore any connections to them.
- virtual void Connect(Connector*, CGlue* = nil);
- Connect this connector to the given one, optionally with a
piece of CGlue interposed. This operation allows redundant connections by
- virtual void Disconnect(Connector*)
- void DisconnectAll()
- Disconnect the given connector from this one, if they are
connected. DisconnectAll calls Disconnect on all connected connectors
until no connections remain.
- virtual boolean ConnectedTo(Connector*)
- Return whether this connector is connected to the given
- virtual void GetCenter(float&, float&)
- Return the coordinates of the connector's center, which
defines its position.
- virtual void SetBinding(StateVar*)
- virtual StateVar* GetBinding()
- Assign and return the state variable bound to the
connector, if any. Only one state variable can be bound to a connector at
- virtual void SetTransMethod(TransMethod)
- virtual TransMethod GetTransMethod()
- Assign and return the connector's transmission method.
- virtual void Transmit(Path* = nil)
- Initiate dataflow originating from this connector,
optionally based on information supplied in the given path object. Other
Unidraw or application objects call this operation whenever data
modifications should be propagated.
- Connector(Graphic* = nil)
- Initialize the connector instance, optionally with a
graphic whose center defines the connector's position.
- virtual void ConnectMe(Connector*)
- virtual void DisconnectMe(Connector*)
- Connectors maintain a list of the connectors to which they
are connected. The Connect and Disconnect operations update this
connector's list, while the ConnectMe and DisconnectMe operations inform
their argument to update their lists.
- void Retransmit(Path*)
- void Retransmit(Connector* peer, Path*)
- boolean Transferable(Connector* peer)
- The Transmit operation uses these operations to propagate
state variable values. The first Retransmit function calls the second one
on each of the connector's peers (i.e., the connectors to which it is
connected) if the path records that this connector has not already been
visited (otherwise propagation ceases). The first Retransmit copies the
path if necessary to avoid accumulating visit information from multiple
branches. The second Retransmit calls Transferable, which returns whether
the value of this connector's state variable can be transferred to the
given peer's state variable based on the two connectors' transmission
methods. If the values are transferable, then the Transferable operation
carries out the assignment to the peer's state variable as a side-effect.
The second Retransmit also enables further propagation by evaluating the
transfer function of the peer's parent and by calling the first Retransmit
operation on the peer.
- Connector* GetConnector()
- Return the view's subject, if any.
- ConnectorView(Connector* = nil)
- The constructor takes a subject as an optional argument.
The view will attach itself to the subject if one is specified.
CGlue(3U), GraphicComp(3U), GraphicView(3U), Path(3U), StateVar(3U), edit(3U0,