RFC 192: Some factors which a Network Graphics Protocol must consider

Network Working Group                                          R. Watson
Request for Comments: 192                                        SRI-ARC
NIC: 7137                                                   12 July 1971

      Some Factors which a Network Graphics Protocol must Consider

   After reading some of the RFC's on a network graphics protocol it
   seems that many are not providing general enough mechanisms to handle
   attention handling, picture structure, and other higher level
   processes involved in interactive graphics.

   Therefore for what it is worth I am sending out these rough
   introductory notes which contain ideas that I think any network
   graphics protocol must come to grips with.

   The network graphics protocol should allow one to operate the most
   sophisticated system with more general data structures and concepts
   than those described in these notes and allow very simple systems to
   function also.

Introduction

   It is our contention that, if computer graphics is to be widely
   useful, the graphics terminals must be just another type of terminal
   on a timesharing system with minimal special privileges.  In these
   brief notes we outline the basic features which we feel must be
   available in a graphics support package to allow easy interactive
   graphics application programming.

   If one examines the types of tasks in industry, government and
   universities which can avail themselves of timesharing support from
   graphics consoles, one can estimate that the large majority can
   effectively utilize quite simple terminals such as those employing
   storage tubes.  I would estimate 75% of the required terminals to
   fall in this class.  Another 15-20% of terminals may require higher
   response and some simple realtime picture movement, thus requiring
   simple refresh displays.  The remainder of terminals are needed for
   high payout tasks requiring all the picture processing power one can
   make available.  In this talk we are not considering support for this
   latter class of applications.

MAIN ASSUMPTIONS AND REQUIREMENTS FOR SYSTEM DESIGN

   The main assumptions and requirements underlying the interactive
   graphics are the following:

      1) The user of the graphics terminal should be just another
         timesharing system user.

      2) The graphics software support should interface to existing
         timesharing programs.

      3) The software support should allow technicians, engineers,
         scientist, and business analysts as well as professional
         programmers to easily create applications using a graphic
         terminal.

      4) The software support should easily allow use of new terminals
         and types of terminals as they come on the market.

      5) The software support should be expandable as experience
         indicates new facilities are required.

      6) The software support should be portable from one timesharing
         service to another.

      7) Some form of hardcopy should be available.

MULTILEVEL MODULAR APPROACH TO SYSTEM DESIGN

   If one wants to create as system which is easy to use by
   inexperienced programmers and ultimately non-programmers, one needs
   to provide powerful problem-oriented aids to program writing.  One
   has to start with the primitive machine language used to command the
   graphics system hardware and build upward.  The philosophy of design
   chosen is the one becoming more common in the computer industry,
   which is to design increasingly more powerful levels of programming
   support, each of which interfaces to its surrounding levels and
   builds on the lower levels.  It is important to try to design these
   levels more or less at the same time so that the experience with each
   will feed back on the designs of the others before they are frozen
   and difficult to change.

   One can recognize five basic levels:

      1) The basic system level:

         This level provides facilities for use of the terminal by the
         assembly language programmers.

      2) The problem programming language level:

         This level of support provides powerful facilities for
         interactive graphics programming from the commonly used higher
         level programming languages.

      3) The picture editor or drawing system:

         This level of support allows pictures to be drawn and linkage
         to these pictures and application programs.

      Data management support for interactive programming:

         This level of support is to provide facilities to aid creation
         and manipulation of data structures relating data associated
         with the pictures and the application.

      5) The application program level:

A REVIEW OF TERMINAL HARDWARE CHARACTERISTICS OF CONCERN TO THE USERS

   There are two basic kinds of general purpose cathode ray tube display
   systems available on the present market.  Within each class there are
   alternate forms and techniques of implementation which we do not
   discuss here.  One type is called a "refresh display".  The other
   type is called a "storage tube display".  The refresh display must
   keep repainting the picture on the screen at rates of from 20-60
   times per second.  Commands which instruct the system how to draw the
   picture are stored in a memory.  The storage tube display on the
   other hand, through its internal method of construction can maintain
   on the face of the display a picture for practical purposes,
   indefinitely once drawn.

REFRESHED DISPLAYS

   There are limits to how much information can be drawn on the face of
   refreshed display before the time required to paint it forces the
   refresh rate below a critical value and the picture appears to
   flicker.  This quantity of information is a function of the type of
   phosphor on the tube face, the speed of display system in drawing
   lines and characters, and the ambient light level in the room.
   Refresh display systems range in cost upwards from $10,000 to several
   hundred thousand dollars.  Refresh displays, because the picture can
   be changed every few milliseconds by simply altering its command list
   (often called a display file or display buffer), allow the picture
   parts to be moved on the face of the screen either under operator
   control or computer control.  Objects on the screen can be
   selectively erased without affecting other objects on the screen.

   These characteristics make refreshed displays suitable for a wide
   range of applications.

STORAGE TUBE DISPLAYS

   Storage tube based displays can display a large amount of information
   without a flicker, and generally cost under $20,000.  Present systems
   suffer from some limitations, however.  They cannot be selectively
   erased.  If an object is to be moved or deleted from the screen, the
   entire screen must be erased and then the new picture can be redrawn.
   Because this type of display generally operates over a communication
   line, the speed of the line may seriously restrict the amount of
   interaction if much erasing and redrawing is required.  The graphics
   software concepts to be described can be used with both a storage
   tube and refreshed display, although some features are only
   appropriate to the refreshed type of display.  The important point is
   that new storage tube technologies insure that this class of terminal
   will be with us a long time.

INPUT DEVICES

   It is necessary to allow a console user to communicate with the
   graphics system.  This is done through a keyboard and through
   specialized graphic input devices, the Light Pen, the Tablet, the SRI
   "Mouse", and the "Joy Stick".  These latter devices enable a console
   user to point to vectors and characters displayed on the CRT and to
   input position information to the graphics system.

   Comparison of the Graphics Input Devices -- Analog Comparitors

      The Joy Stick, Mouse, and Tablet are similar in that they both
      generate a two dimensional position address without the aid of the
      display processor, but cannot be directly used to identify
      displayed objects.  The light pen-display processor hardware
      combination and its associated software, on the other hand, can
      easily sense and identify displayed vectors and characters but
      does not generate directly any position data.  A "tracking cross"
      program is used to obtain the position data for the light pen.  To
      obtain the pointing capability for the Joy Stick, Mouse, and
      Tablet, we can use a pair of analog comparitors which generate
      interrupts when the beam is drawn on the CRT lies within a
      rectangular "viewing window" in much the same way that the light

      pen generates interrupts when a beam is drawn under its circular
      viewing area.  These comparitors sense the x and y axis drive
      voltages of the display analog bus.

      A comparator will generate an output signal when the drive voltage
      is between two limits which may be set using special display
      processor commands.  When both comparitors generate a signal
      simultaneously, the output voltages on the analog buss correspond
      to a beam position within the rectangular viewing window.  The
      position of viewing window is set based on the position of the
      pen, Mouse, or Joy Stick.

      We can also use software to simulate the effect of hardware
      comparators.  Hardware comparators cannot be use with storage tube
      displays and, therefore, a software simulation is required.  This
      simulation is discussed later in these notes.

      The light pen can be used only with a refreshed display.  The
      other types of devices can be used with present storage tube
      displays and refreshed displays.  They are used with storage tube
      displays which have hardware which produces on the screen a dot,
      cross or other cursor, indicating the x, y position of the device.
      The reason one can move this cursor around it that the cursor is
      created using special techniques to avoid its storing on the
      screen.

USER SOFTWARE REQUIREMENTS

   The user requirements on a timesharing system based interactive
   graphics system are the following:

      1) The user should have available a language for creating a
         computer representation of the picture to be displayed.  This
         language should allow more complex pictures to be built up from
         simpler structures.

      2) The computer representation of the picture must allow easy
         identification of picture parts when pointed at or "picked" or
         "hit" with graphical input devices such as light pen,
         electronic pen-tablet, Joy Stick, SRI mouse, or other supplying
         x, y information.

      3) The computer representation of the picture must allow linking
         of picture parts with data about these parts appropriate to the
         application using the terminal.  There should be an appropriate
         data management system for use with interactive application
         programming.

      4) There must be some way of communicating events taking place at
         the terminal in real-time, such as picking objects with the
         light pen, with the application program running in the
         timesharing system.

      5) The user should be able to save and restore pictures from one
         console session to the next.

      6) If possible, the user should be able to use the display as a
         stand-alone terminal or in conjunction with a teletype or other
         typewriter terminal.

      7) The user should be able to do some graphic programming by
         drawing directly at the console.

   The choice of an appropriate data structure for picture
   representation simplifies the handling of requirements one to five.
   It is this data structure that we consider now in more detail.

Picture-Related Structures

   If a picture displayed on the console had meaning only in the
   physical position of its lines and characters, the system would be
   little more effective than an easily erased piece of paper.  To
   significantly enhance the capabilities of the system, we must be able
   to express relations between displayed entities.  A line is much more
   than just a line when it represents a boundary or a part of some more
   complex unit.  Such units in turn may be related in a similar way to
   higher level units.  Furthermore, we may wish to create picture
   elements that may be used repeatedly so that a change in the one
   master copy will be reflected in every use of that copy.

   To illustrate the usefulness of this picture-subpicture relationship,
   we shall consider the three houses of Figure 1.  While the two types
   of houses differ in appearance, it is obvious that they have picture
   elements that could be drawn by a designer of prefabricated houses
   and that the designer wished to incorporate a new standard window
   unit into all houses.  The use of conventional pencil and paper
   techniques would require that he redraw or overlay each window on his
   diagram to reflect the changed component.  If the window were,
   instead, drawn by the graphics system within a common subroutine,
   only that one master copy would have to be modified in order to
   change the appearance of every reference to that kind of window on
   the diagram.

Nodes and Branches

   To facilitate the discussion we will introduce the terms "node" and
   "branch".  A node is a form of picture subroutine that may cause the
   display of lines and characters and may also call other nodes.  The
   subroutine call is called a "branch".  Nodes may also be thought of
   as representing PICTURES or SUBPICTURES and the branches to these
   nodes as uses or instances of these subpictures.

Directed Graph Structure

   The nodes and branches form a directed graph.  The branches contain
   positioning information indicating the beam location to be used by
   the called node.  This location is relative to the position of the
   node in which the branch is made.  This use of relative beam
   positions allows the user of the system to create subroutine
   structures that make multiple branches to common nodes.  Branches may
   also set other display parameters such as intensity and character
   size.  A subroutine calling structure appropriate to the requirements
   of our hypothetical designer is shown schematically in Figure 2.
   Nodes are shown as circles and branches are shown as connecting
   lines.  The picture of the house is composed of wall unit and roof
   SUBPICTURES.  The wall unit is in turn composed of subpictures.

Node and Branch Display Parameters

   Branches may contain the setting of parameters which will be in
   effect when the called node is executed.  The parameters which may be
   set are the beam position to be used (relative to the current beam
   position, i.e., a displacement value), intensity, character size,
   line type, visibility, (the display of vectors and characters may be
   suppressed), "hitablility" (whether or not vectors and text may be
   "viewed" by devices such as the light pen), and blinking.

   Coding within nodes may modify only the parameters controlling
   position, intensity, character size, and line type to be used by
   subsequent display coding or branches.  It is not necessary that a
   node or branch specify every parameter.  For those parameters other
   than position, the system allows a "don't care" option; the parameter
   setting in effect when the node or branch is executed will be
   retained and used in this case.

Identification of Graphic Entities with Graphic Input Devices

      Structural Hits

         A console operator or application program may modify, add, or
         delete branches to any of the nodes as well as add new nodes.
         To allow a console operator to manipulate any branch in such a
         structure, we have implemented a "structural hit
         identification" scheme.  To illustrate the following
         discussion, we refer the reader to Figures 1 and 2.

         A viewing device, such as a light pen, can respond only to the
         individual vectors or characters displayed on the screen.  At
         the time a vector is drawn under the viewing area of the light
         pen, an interrupt is generated and, if enabled, will be sent to
         the central computer.  Even though the same node is used to
         display the eight windows in the diagram of Figure 1, we can
         tell which window and house is being pointed to by examining
         the sequence of branches taken to arrive at the window
         displayed at the time of interrupt.  If the console user points
         to the right hand window of the middle house of Figure 1
         (marked with an asterisk *) an examination of the subroutine
         return addresses in the push down stack would show that the
         current "window" node had been arrived at via the dotted line
         path shown on the network of Figure 2.

         There remains the question "Are we pointing at a window, at a
         wall, at the house, or at all three houses?"  The location of
         this structural hit depends on how many branches are counted in
         examination of the return addresses before one stops to
         consider to which branch that return jump points.  This is
         analogous to counting a fixed number of levels from the ends of
         the graph structure.  This number of jumps is set using
         reserved keys on the keyboard, one incrementing and the other
         decrementing the limit.  By manipulating these keys and
         pointing to various displayed objects with the light pen, it is
         possible to point to any branch in the network of subroutine
         calls.

         All information concerning the path in the node-branch network
         taken to arrive at any displayable coding is contained in a
         push down stack.  Return jumps are stored in the stack by the
         subroutine calls to nodes.  These jumps when executed will
         return the processor to the next instruction after the call.

         A greatly simplified version of the display coding used to
         generate the picture and tree of Figures 1 and 2 is shown in
         Figure 3.  The labels a through d on the diagram represent the

         address of the subroutine calls which cause the display of the
         subpicture hit by the viewing device -- in this case the right
         hand window of the second house.  The returns from the called
         subroutines are stored in the push down stack as jumps to the
         location following the calls.  The routine RETURN would merely
         execute POP instructions which ultimately will cause the
         execution of a jump instruction previously placed in the stack
         by the calling branch, thus returning control to the calling
         routine.  The stack is shown in the condition at the time of
         the hit on the right hand window of the middle house.  Note
         that by counting 3 jumps upward (downward in the diagram) in
         the memory containing the stack, we will arrive at the jump
         pointing to a structural hit at (b) in Figure 3, the call to
         model 120.

      Console Operator Feedback

         The console operator must be informed of where he is pointing
         in the network of nodes and branches.  This is accomplished by
         flashing all displayable coding below the structurally hit
         branch when a vector or character is viewed.  This flashing is
         a doubling of the intensity at 2 to 8 cycles per second.  In
         addition, a list of the names of all nodes and branches taken
         to arrive at the vector or character viewed is displayed in a
         corner of the screen.  The name of the branch selected is
         intensified somewhat brighter than the other names.

      Generating an Attention

         After the operator has confirmed the correctness of his choice,
         he need only terminate the view in order to generate an
         attention on the desired branch.  This is done by releasing the
         button on the light pen or lifting the pen from the Tablet.  A
         button on the mouse will perform the same function.  If the
         structural hit is not correct then the operator could move the
         viewing device to a new area.

         A termination of the view on a blank area of the screen will
         result in the generation of a "null" attention.  This attention
         returns only position data; no structural data is generated.
         The significance of this attention is determined by the
         application program.

         The above discussion assumed a refreshed display and use of a
         light pen, but it greatly simplifies interactive graphics
         programming if the above concepts can be implemented no matter
         what type of display or graphical input device is being used.
         This in fact can be accomplished as discussed later.

THE GRAPHICS LANGUAGE

   For the purpose of discussion we assume that the graphics language
   statements are a set of subroutine calls, although a more
   sophisticated syntax could be imbedded in the host programming
   language.  The statements required are:

      1) Subroutine calls for creation and manipulation of the picture-
         subpicture data structure.

      2) Subroutine calls to generate displayed pictures and picture
         parts such as lines and characters.

      3) Subroutine calls to input information about events or
         "attentions" occurring in real time at the console.

      4) Subroutine calls to manipulate picture parameters such as line
         type, (solid, dashed, dotted, etc.), brightness, character
         size, and so forth.

      5) Subroutine calls to perform utility functions such as saving
         and restoring pictures from disk files, initiating the display
         and so forth.

NAMING

   A number of different naming conventions are required to meet system
   and application programmer needs.

      The Display Pointer

         Nodes and branches in the system are named by assigning an
         integer or array location as an argument in the call used to
         create them.  The system places in these variables a number
         which points to the physical location of the branch or node
         position in the picture-subpicture data structure.  We call
         this name the DISPLAY POINTER.  As long as the user does not
         change the contents of these variables he can refer to
         particular nodes or branches in various subroutines by use of
         these integer variables as arguments.  In other words, to the
         user, the name of a picture or subpicture can be thought of as
         the variable used at the time of its creation.  Such a naming
         scheme is clearly required if pictures or subpictures are to be
         manipulated by the programmer.

      The Light Button Code

         Additional identification is useful to the application
         programmer in order to simplify his programming task.  A user
         has no control over the number assigned by the system to a
         Display Pointer.  There are situations in which the user would
         like to associate a particular known number with a branch.  One
         common example is in the use of "light buttons".  A light
         button is a displayed object that the user wants to be able to
         point at in order to command the controlling application
         program to do something.  A light button is commonly a string
         of characters forming an English word or words, but could be
         any picture.  When the user picks or hits the light button,
         information identifying the object must be transmitted to the
         timesharing application program.  The program must then branch
         to an appropriate statement or subroutine to perform the
         operations required to execute the command.  The Display
         Pointer uniquely identifies the object hit, but because its
         value is not under the programmers control, writing the code
         necessary to test it against the various Display Pointers
         considered legitimate to be hit at this point in the program is
         tedious.  If, however, the application programmer knew that at
         this point only objects with identification numbers 20-28 were
         legitimate to be hit, then testing to see that one was in this
         range and branching by use of a computed GOTO simplifies the
         programming of flow of control.  Often one does not need unique
         identification of an object, but wants to perform a certain
         action if any object in a class of objects is hit.

         The above need for identification is satisfied by allowing the
         application programmer the ability to assign a number, not
         necessarily unique, to a branch.  This number is called the
         Light Button Code.  This code can be used in any way the
         programmer desires, but is most commonly used, as its name
         implies, as a code identifying light buttons.  This number is
         sent to the application program along with the Display pointer
         of the object hit on the screen with a graphical input device.

      The Back Pointer

         We indicated earlier that it is required in interactive graphic
         programming to be able to associate application oriented data
         with picture and subpicture objects on the screen.  The data
         may be stored in many kinds of data structures depending on the
         nature of the application, examples being arrays, lists, trees,
         etc.  We meet the need by associating with each branch one word
         which could contain a pointer to the appropriate spot in the
         application data structure containing the data associated with

         the branch.  We call this word the Back Pointer.  The
         application programmer can in fact store any code he desires in
         this word and use it in any way desired, but its common use as
         a pointer back into a data base in the application program
         dictated its name.

         For example, consider an application which would allow a
         chemical engineer to draw a chemical flow sheet on the screen
         and then input this flow sheet into a process calculation
         system.  There will be various symbol-pictures on the screen
         representing basic process units such as heat exchangers,
         mixers, columns, and so forth that can be copied and positioned
         on the screen.  These units will have to be connected together
         by streams.  The units and the streams will have names and data
         associated with them describing their contents and properties.
         Further, the node-branch structure. while visually indicating
         to the user what units are connected together and how, does not
         necessarily have the connecting information in a form easily
         handled by the application program.

         The continuity is best represented by a data structure using
         simple list processing in which each unit and stream has a
         block of cells associated with it containing data for it and
         pointers containing the connectivity information.  When a
         branch is created to position and display a unit, it will
         contain in the Back Pointer a pointer to the block of data
         associated with it.  The block of data will probably contain
         the Display Pointer for the associated branch so that one can
         go from the picture to the data block or from the data block to
         the picture.  For example, one may point at a unit for the
         purpose of deleting it.  Given the Back Pointer of the unit
         hit, one can find its associated block and return that block to
         free space.  One can then follow the appropriate chain of
         pointers to the blocks for the streams connected to the unit.
         In these blocks one has the Display Pointers for the branches
         displaying the stream and can then delete it from the node-
         branch structure, thus making it disappear from the screen.

         An additional form of name is to allow the programmer to store
         an alphanumeric string with each branch or node.  This form of
         name is not required for most applications, but can be useful
         with the picture editor.

         To review, each node and branch has associated with it a unique
         identifier named by the user and called the Display Pointer;
         its value is assigned by the system.  Each branch has two
         additional pieces of information which can be assigned to it by
         the programmer, called the Light Button Code and Back Pointer.

         Given a Display Pointer for a branch, the programmer can obtain
         the Light Button Code or the Back Pointer for the branch.
         Given a Light Button Code or the Back Pointer, the programmer
         can obtain a Display Pointer for a branch with such a code.
         This display pointer may not be unique if several branches have
         the same Light Button Code or Back Pointer.  The above naming
         and identification inventions have proven to be easy to
         understand and yet completely general and easy to use.

COORDINATE SYSTEMS

   We now consider the question of a coordinate system within which to
   describe picture position.  The actual display generation hardware in
   a terminal has a fixed coordinate system (commonly 1024 by 1024 units
   on a fixed size screen with the origin 0,0 in the left hand corner or
   center on the screen).  Ultimately, the user wants to work on a
   virtual screen much larger than the hardware screen and wants to
   consider the hardware screen as a window that he can move around to
   view this virtual screen.  Further, pictures are to be capable of
   being constructed out of subpictures as in the example of Figures 1
   and 2.  To be able to accomplish the latter and allow future
   expansion to allow the former, the following coordinate system
   conventions are used.

   Each node has its own coordinate system.  When a node A is created,
   the picture-drawing CRT beam is assumed by the programmer to be at
   the origin of the node's coordinate system.  When a node is used
   within a node B by use of a branch, the positioning of node A is
   relative to the beam position in the coordinate system of node B.
   All nodes are positioned relative to each other by x, y positioners
   in the corresponding branches.  When a picture is actually to be
   displayed, one node is indicated to the system as the initial or
   Universe Node.  This initial node is positioned absolutely on the
   screen and all other nodes appear relative to this one as specified
   in the branches pointing to them.  This scheme is required to give
   the flexibility and generality required in the picture-subpicture
   tree.

   Logical Completeness of Operation Set

      Throughout the system design one should try to follow the
      philosophy of incorporating a logically complete and consistent
      set of operations.  In particular, for each call that sets a value
      there should be another call to fetch the value.  That is, for
      each operation there is an inverse operation whenever it is
      meaningful to have one.  We see a need for a basic system with the
      calls as primarily primitives.  One can incorporate calls that
      could be created by the programmer from other calls, when it is

      felt that usage would warrant the expansion.  We would expect a
      library of higher level routines in the language.

      It is beyond the scope of these notes to go into all the calls
      required except to indicate a few basic ones.  For structure
      creation, one needs to be able to create a node or branch, delete
      a branch, add a new branch to a node at run time.

      One needs to be able to specify beam movements in nodes and place
      text in nodes with the normal write-format statements of the host
      programming language.  This latter point is very important for
      easy programming.

      One needs to be able to set and test parameters and convert one
      form of name into others.

      We discuss Attention handling in more detail because of its
      importance in making interactive programming easy.

   Attention Handling

      The user sitting at the console is operating in real time while
      the application program is operating in timesharing time.  At any
      point where the user may perform some operation at the console,
      the application program may not be running.  A mechanism must be
      created to communicate between the user and the application
      program.  The design of this mechanism is very important and must
      be carefully considered.  There are many different operations that
      one might want to provide the user at the console.  A basic
      mechanism is discussed which will allow others to be added in the
      future.  When the application program gets to a point where it is
      expecting input from the terminal, it issues a call and passes an
      array as an argument.  The Attention handling mechanism dismisses
      the program until an event is reported from the console.  The
      information passed back to the application is the type of event
      which occurred and other relevant information for that event.

      On refreshed displays a common input device is the light pen.  The
      light pen has a physical field of view of about a 1/8-1/4 inch
      circle.  The most common use of the light pen is to point at an
      object to be hit or picked.  The logical field of view seen by the
      user is a branch in the node-branch structure.  The picture drawn
      by the structure below the branch is blinked to give feedback to
      the user about what object he is going to hit or operate upon.
      The level in the structure at which the logical view is given can
      be set under program control or adjusted by the user from the
      keyboard.  When the user obtains feedback indicating the correct
      object is in view, he then presses a button on the light pen to

      generate an Attention.  He is said to obtain a "structural bit" at
      a branch at the level in the node-branch structure set by the
      application program or by himself.  When the hit occurs,
      appropriate information is then entered into the Attention queue
      as described below.

      The other type of graphical input device commonly in use on both
      refreshed and non-refreshed displays, such as electronic pen-
      tablets, Joy Sticks, SRI Mouse, etc., produce x, y position
      information which is fedback to the screen as some sort of cursor,
      such as a dot or a cross.  It is difficult, if not impossible,
      without special hardware to provide the kind of feedback possible
      with the light pen, but structural hits can be generated by the
      use of special hardware or software.  These devices require the
      application programmer to set the appropriate level for an
      expected hit.

      The level of a structural hit is counted up from the bottom of the
      node-branch structure.  A hit at level 1 is the lowest branch
      presently in view.  A hit at level 0 is a hit on an individual
      vector or group of characters.  Only special programs, such as a
      picture editor, are likely to obtain hits at level 0.

      The Attention type obtained when one gets a structural hit on a
      branch returns the following information:  The information
      returned in the array is that required by the application program,
      the Display Pointer, the Light Button Code, and x, y, information.
      The x, y, information returned is not the absolute x,y pen
      position because this would not be of use on this type of hit.
      The x, y information returned is the physical beam position just
      before execution of the branch which was hit.  If one wants the
      physical location of the node origin to which the hit branch is
      connected, one executes another call to obtain the branch
      positioner and adds these values to the corresponding values
      obtained from the hit.  Given the Display Pointer, one can obtain
      the Back Pointer or other parameter values associated with the
      given branch call.

      The attention type obtained when a hit is generated, but no object
      is in view, is now discussed.  This type of attention is called a
      null attention.  It is used frequently to position objects on the
      screen.  The only information returned in the array is the
      absolute screen coordinates of the position on the screen of the
      graphic input device or cursor.  This information can be converted
      into relative information for placement in a branch positioner or
      for incrementing a branch position when an object is being moved.

      Other calls are required to obtain information about other
      branches which are related to the one hit, and to perform other
      functions.

STRUCTURAL HITS FOR STORAGE TUBE DISPLAYS

   The final topic is to consider how to obtain structural hit
   information using a storage tube display or device which only gives
   absolute x, y screen information.

   The problem is to take an x, y coordinate pair and determine if the
   user is or is not pointing at an object on the screen, and if he is,
   which object.  When a hit is generated with the light pen, the
   display processor halts and the controlling computer can gain access
   to the return addresses in the push down stack and to the instruction
   location which generated the line or character causing the hit.  Use
   of the Joy Stick, Mouse, or tablet is completely asynchronous with
   the display for refresh displays and the hit occurs after the drawing
   has taken place for storage tube systems.

   The brute force approach to the problem would be to simulate
   execution of the Display Buffer and calculate some measure of
   distance between every line and the x, y coordinate of the hit.  This
   approach would be too time consuming and is not feasible.  A second
   approach and one commonly used is to have the programmer define a
   rectangle surrounding each object on the screen.  Then one determines
   which rectangle the cursor was in and that determines the object hit.
   This approach requires extra effort by the programmer, and only works
   well if the node-branch structure is one level deep, there are no
   diagonal lines as nodes, and no objects have overlapping rectangles.
   These severe restrictions eliminates this approach from serious
   consideration.

   A third approach would be to break the screen into small squares or
   rectangles of a size such that it is unlikely a line from more than
   one picture object would pass through the square or rectangle.  Then
   we would record for each square the Display Pointer of the lowest
   level object branch passing through it.  This approach would require
   considerable system space and would take much time to determine what
   rectangles each line passed through.

   The fourth approach and the one we recommend is to split the screen
   into horizontal and vertical strips.  When the call to DISPLAY is
   given, the system makes one pass through the node-branch structure
   and makes a list of the Display Pointers for the lowest branch having
   a node with a line or character passing through or in each horizontal
   or vertical strip.

   This calculation can be made quickly because the system can easily
   obtain the start and end points of a line.  One then can quickly
   determine which strips the end points fall in, as well as the
   intermediate strips crossed.  When a hit is generated, the x, y
   information is converted to horizontal and vertical strip numbers.
   The Display Pointers for each of these strips are intersected to see
   if a common Display Pointer exists.  If yes, this is the Display
   Pointer for the object hit.  If not, then a null hit is generated.
   Choice of strip width decreases the probability of multiple hits
   resulting.

   The above process yields the Display Pointer of the lowest branch in
   the tree in view, but one may want to obtain information about other
   higher branches in view.  This is accomplished by creating, not only
   the strip lists described, but by parsing the node-branch structure
   at the same time into a table containing an abbreviated
   representation of the tree and the screen x, y coordinates existing
   at each branch.  The strip lists do not actually contain Display
   Pointers, but pointers back into the parsed representations which has
   the Display Pointer, x, y coordinates, and the structure level for
   each of the branches.  The parsed representation is a linear list of
   the branches encountered as the program walks through the node-branch
   graph.  Given the hit at the lowest level one can determine all
   branches passed through from the top node to the hit branch by an
   upward search of the graph representation.

   Every time a branch is deleted or a new branch is added, one needs to
   modify the screen, modify the representations and the strip lists.
   For refresh displays, the picture can be changed immediately and the
   strip lists and representations modified at the time of an attention
   call.  For a storage display, erasing and redrawing the picture on
   each deletion can be slow, if many deletions are going on, and may be
   unnecessary.

   There are three approaches to performing these functions in storage
   tube systems:

      1) Erase the screen on each deletion and recompute the picture,
         strip lists and graph representations on each deletion and
         addition.

      2) Keep a list of each Display Buffer change and perform erase if
         necessary and redraw or make an addition when an attention call
         is encountered.  This is a feasible approach because it is only
         at this point that the screen and structural hit information
         need to be up to date.

      3) The third is to allow control of screen changes and other
         updating by special subroutine call.  The recommended approach
         uses a combination of the above.  Adding information to the
         screen should occur at the time of the new branch call.
         Deletions and modifications of the representation and the strip
         lists occur only at the time of an attention call.  Routines
         should also be provided to give the programmer control over
         this redraw mechanism.

         Experience with the above mechanism has shown it to be quite
         fast and not to noticeably degrade response time.  One minor
         difficulty has been encountered when a horizontal or vertical
         line of an object is on the borderline of a strip.  Sometimes
         this results in a null hit being generated if the cursor is on
         the wrong side of the borderline.  A check can be made for this
         condition and audio feedback can be given to the user with the
         bell in the terminal to indicate a correct or erroneous hit.

INTERFACE TO THE TIMESHARING SYSTEM OF A REMOTE MINICOMPUTER DRIVEN
DISPLAY

   Although the graphic system is locally controlled by a minicomputer,
   the user does not have to worry about the mini.  Application programs
   are written for the timesharing computer only.  The graphic system as
   a whole behaves as a terminal of the timesharing computer.  This
   feature is important because no matter how powerful the graphic
   system is, it must be easy to program and use before useful
   applications can be implemented.

   Because no one wants to operate over a communication line, one needs
   to compress the information sent to the remote system.  This is
   accomplished by compiling a central node-branch structure in the
   central computer and only sending minimal character strings to the
   remote computer representing those subroutines calls that need to be
   compiled into a Display Buffer in the remote computer for display
   refresh.  In other words, a smaller remote version of the graphics
   system resides in the remote minicomputer.  Simple schemes for
   coordinating the Display Pointer in the remote and central machine
   have to be devised.

CONCLUSION

   We feel that the above concepts are central to creating an
   interactive graphics support system for use with a timesharing
   system.  The key concepts are those associated with the node-branch
   structure and the structured hit.  The topics of a picture editor,
   data management system, and basic level support are also very
   important, but beyond the scope of this lecture.

   Figures 1, 2. and 3, are available in both .PS and .PDF versions.

          [This RFC was put into machine readable form for entry]
          [into the online RFC archives by Lorrie Shiota, 10/01]