NAME

       ConnectCmd,  CopyCmd,  CutCmd, DeleteCmd, DupCmd, MobilityCmd, PasteCmd, RedoCmd, ReplaceCmd, SlctAllCmd,
       UndoCmd - editing commands

SYNOPSIS

       #include <Unidraw/Commands/edit.h>

DESCRIPTION

       The Unidraw  library  defines  several  commands  that  offer  common  component  editing  functionality.
       ConnectCmd  is  a  non-interpretive  command  that  connects  two  connectors.   CopyCmd  copies selected
       components onto its clipboard (if it defines one) or  onto  the  global  clipboard.   CutCmd,  DeleteCmd,
       DupCmd,  and  PasteCmd  are  purely  interpretive  commands that are always interpreted by their editor's
       component. MobilityCmd gives selected components the opportunity to set their mobility based on the value
       it provides.  UndoCmd and RedoCmd are non-interpretive commands  that  simply  undo  and  redo  the  last
       command  that  affected  their  editor's  component.   ReplaceCmd  replaces  selected components with the
       component it stores.  Finally, SlctAllCmd is a non-interpretive command that selects all  the  components
       displayed in its editor.

CONNECTCMD PUBLIC OPERATIONS

       ConnectCmd(
           ControlInfo*,
           Connector* source = nil, Connector* target = nil
       )

       ConnectCmd(Editor* = nil, Connector* = nil, Connector* = nil)
              The  ConnectCmd  constructor  optionally  takes  two  connectors as parameters, the source and the
              target.  When executed, it will call Connect on source with target as its argument.  It will  also
              set the source's mobility to floating.

       void GetConnectors(Connector*& source, Connector*& target)
              Return the connectors supplied in the constructor.

COPYCMD PUBLIC OPERATIONS

       CopyCmd(ControlInfo*, Clipboard* = nil)
       CopyCmd(Editor* = nil, Clipboard* = nil)
              Create a CopyCmd instance, optionally specifying a clipboard in which to store copied components.

       virtual void Execute()
              Execute  does  nothing  if  no  components  are  selected. Otherwise, Execute places a copy of the
              selected components onto the CopyCmd's clipboard if is non-nil or else onto the  global  clipboard
              (obtained from the catalog).

       virtual boolean Reversible()
              CopyCmd is not reversible.

CUTCMD PUBLIC OPERATIONS

       CutCmd(ControlInfo*, Clipboard* = nil)
       CutCmd(Editor* = nil, Clipboard* = nil)
              Create  a CutCmd instance, optionally specifying a clipboard in which to store the components that
              were cut.

       virtual void Execute()
       virtual void Unexecute()
              CutCmd redefines these operations to let the editor's component interpret it.   Execute  will  set
              the  value  of  the  _executed  protected  member  variable  to true as a side effect.  Similarly,
              Unexecute will reset the value to false as a side effect.

DELETECMD PUBLIC OPERATIONS

       DeleteCmd(ControlInfo*, Clipboard* = nil)
       DeleteCmd(Editor* = nil, Clipboard* = nil)
              Create a DeleteCmd instance, optionally specifying a clipboard in which to  store  the  components
              that were deleted.

       virtual void Execute()
       virtual void Unexecute()
              DeleteCmd  redefines these operations to let the editor's component interpret it. Execute will set
              the value of the _executed protected member  variable  to  true  as  a  side  effect.   Similarly,
              Unexecute will reset the value to false as a side effect.

DUPCMD PUBLIC OPERATIONS

       DupCmd(ControlInfo*, Clipboard* = nil)
       DupCmd(Editor* = nil, Clipboard* = nil)
              Create  a DupCmd instance, optionally specifying a clipboard in which to store the components that
              were duplicated.

       virtual void Execute()
       virtual void Unexecute()
              DupCmd redefines these operations to let the editor's component interpret it. Execute will set the
              value of the _executed protected member variable to true as a side effect.   Similarly,  Unexecute
              will reset the value to false as a side effect.

MOBILITYCMD PUBLIC OPERATIONS

       MobilityCmd(ControlInfo*, Mobility = Fixed)
       MobilityCmd(Editor* = nil, Mobility = Fixed)
              Create a MobilityCmd instance, optionally specifying the mobility that interpreting components may
              use.

       Mobility GetMobility()
              Return the mobility specified in the constructor.

PASTECMD PUBLIC OPERATIONS

       PasteCmd(ControlInfo*, Clipboard* = nil)
       PasteCmd(Editor* = nil, Clipboard* = nil)
              Create  a  PasteCmd  instance,  optionally specifying a clipboard in which to store the components
              that will be pasted.

       virtual void Execute()
       virtual void Unexecute()
              PasteCmd redefines these operations to let the editor's component interpret it.  Execute will  set
              the  value  of  the  _executed  protected  member  variable  to true as a side effect.  Similarly,
              Unexecute will reset the value to false as a side effect.

       virtual boolean Reversible()
              PasteCmd is reversible if either its clipboard or the global clipboard is non-empty.

REDOCMD PUBLIC OPERATIONS

       RedoCmd(ControlInfo*)
       RedoCmd(Editor* = nil)
              Construct a new RedoCmd.

       virtual boolean Reversible()
              RedoCmd is not reversible.

REPLACECMD PUBLIC OPERATIONS

       ReplaceCmd(ControlInfo*, GraphicComp* replacement = nil)
       ReplaceCmd(Editor* = nil, GraphicComp* replacement = nil)
              Create a new ReplaceCmd, optionally supplying the GraphicComp that will  replace  those  that  are
              selected.

       GraphicComp* GetReplacement()
              Return the replacement GraphicComp supplied in the constructor.

SLCTALLCMD PUBLIC OPERATIONS

       SlctAllCmd(ControlInfo*)
       SlctAllCmd(Editor* = nil)
              Construct a new SlctAllCmd.

       virtual boolean Reversible()
              SlctAllCmd is not reversible.

UNDOCMD PUBLIC OPERATIONS

       UndoCmd(ControlInfo*)
       UndoCmd(Editor* = nil)
              Construct a new UndoCmd.

       virtual boolean Reversible()
              UndoCmd is not reversible.

SEE ALSO

       Catalog(3U), Clipboard(3U), Command(3U), Connector(3U), GraphicComp(3U), globals(3U)

Unidraw                                          24 January 1991                                        edit(3U)