Provided by: ivtools-dev_1.2.11a2-4_amd64 bug


       Editor - base class for top-level windows in an application


       #include <Unidraw/editor.h>


       An  editor  provides a complete user interface for editing a component subject.  It unites
       one or more viewers  with  commands  and  tools  that  act  upon  the  component  and  its
       subcomponents.   Editor is an abstract class derived from MonoScene; the Editor class adds
       the protocol for associating tools, commands,  and  viewers  with  the  component(s)  they
       affect.   A  programmer normally derives one or more application-specific editors from the
       Editor base class and defines their appearance with a composition  of  interactors.   Each
       window  of a Unidraw application is usually an instance of an editor subclass designed for
       the editing domain, and it is these windows that the user recognizes  as  the  application


       virtual ~Editor()
              Editors  should not be deleted explicitly if the Unidraw object is used to open and
              close them.  Moreover, Editor subclasses should not explicitly delete the component
              they  edit.  The Unidraw object will delete the editor's component after the editor
              is closed, provided no other editor references the component (or its relatives) and
              the component is not known to the catalog.

       virtual void Open()
       virtual void Close()
              Open informs the editor that it has just become visible and accessible to the user,
              in case it needs to know, and Close signals the editor that it is no longer  needed
              and  should perform any final housekeeping operations.  For example, the editor may
              display a copyright  message  when  it  is  first  opened,  or  it  make  take  the
              opportunity  when  closed  to  warn  the  user  to save a modified component. These
              operations simply notify the editor of a condition and are not  usually  called  by
              the  application;  instead, the application makes editors appear and disappear with
              the Unidraw object, which calls these operations as appropriate.

       virtual void Handle(Event&)
              Editor redefines Handle to interpret key events as  keyboard  equivalents  via  the
              HandleKey  operation  (described  below).   This  is appropriate in the common case
              where the interactor composition that defines  the  editor's  appearance  does  not
              interpret keyboard events.

       virtual void Update()
              By default, the editor's Update operation calls Update on its viewer(s).

       virtual void SetComponent(Component*)
       virtual void SetViewer(Viewer*, int = 0)
       virtual void SetSelection(Selection*)
       virtual void SetKeyMap(Viewer*, int = 0)
       virtual void SetCurTool(Tool*)

       virtual Component* GetComponent()
       virtual Viewer* GetViewer(int = 0)
       virtual KeyMap* GetKeyMap()
       virtual Selection* GetSelection()
       virtual Tool* GetCurTool()
              Assign  and  return  various  objects  managed by the editor.  These operations are
              undefined by default.

              The component is the object that the user edits through the editor.  The editor can
              have  any number of viewers, identified serially.  An editor can maintain a key map
              for defining keyboard equivalents and a  selection  object  for  keeping  track  of
              selected  components  (typically subcomponents of the component being edited).  The
              editor also has a notion of the tool that is currently engaged, that is,  the  tool
              that  would be used if the user clicked in a viewer.  The SetCurTool and GetCurTool
              operations assign and return this tool, respectively.

       virtual StateVar* GetState(const char*)
              The editor 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  components
              query  the  editor  for  state variables that may affect them without extending the
              editor protocol, potentially allowing  interchange  of  components  from  different
              applications.  This operation returns nil by default.

       virtual void InsertDialog(Interactor*)
       virtual void RemoveDialog(Interactor*)
              Insert  or  remove  an interactor that provides a modal interface, such as a dialog
              box.  By default, these operations insert the dialog into the world as a  transient
              window  centered  atop the editor's canvas.  Subclasses can redefine them to insert
              and remove an interactor (suitably embellished with a border, drop shadow, etc.) as
              needed.   Subclasses should not assume that two InsertDialog operations will always
              be separated by a RemoveDialog  operation;  that  is,  multiple  dialogs  might  be
              visible at once.


              You cannot create instances of the Editor class; rather, you define subclasses that
              suit  your  application.   The  constructor   is   thus   protected   to   disallow

       virtual void HandleKey(Event&)
              Executes  a  command  given a valid keyboard event as defined by the key-to-command
              mapping in the KeyMap object.

       virtual boolean DependsOn(Component*)
              Return whether the editor depends on the given component in any way.   Unidraw  may
              destroy the component if no editor depends on it.

       void SetWindow(ManagedWindow*)
       ManagedWindow* GetWindow()
              Get and set the window associated with the editor.


       Catalog(3U),   Command(3U),   Component(3U),  Interactor(3I),  KeyMap(3U),  MonoScene(3I),
       Selection(3U), StateVar(3U), Tool(3U), Unidraw(3U), Viewer(3U), Window(3I), World(3I)