RFC 178
Network graphic attention handling
This one is RFC 178, NETWORK GRAPHIC ATTENTION HANDLING π by Ira W. Cotton from MITRE (NIC 7118), dated June 27, 1971. The header doesn't name a category, and it doesn't say that it obsoletes or updates anything π§
1.0 INTRODUCTION β¨
Okay so, network graphic protocol talk has mostly been about how to describe the graphic data you want to show on screen π RFC 86 proposed a Network Standard Graphic Data Stream (NGDS) to carry graphic images written in the Network Standard Display List (NGDL). RFC 94 expanded on that and pointed out some shortcomings of the original plan π RFC 125 also replied to RFC 86 with comments and extensions, but it also realized that a display protocol on its own just isn't enough for an interactive graphic system. Not enough, bestie π
1.1 TOPICS COVERED
This paper is all about that gap π It briefly walks through how attention handling works, looks at different graphic configurations, surveys input devices to figure out what kinds of data they produce, and then suggests an attention protocol π¦
1.2 VIEWPOINT
Let's be super clear from the start: the discussion is coming from the viewpoint of a graphics user, or a graphic application program serving one or more users πΈ We're only concerned with third-level protocols π«Ά We assume the network can deliver arbitrary bit streams from terminal to graphic application program, but we don't care how it pulls that off π€·ββοΈ
2.0 ATTENTION-HANDLING π₯
To show why we need an attention protocol, we first have to define what "attention" and "attention-handling" actually mean π§ So we're borrowing the definitions from a recent survey of this area (1). Iykyk π
2.1 DEFINITION
Graphic attention handling is the whole set of processes and techniques for servicing human inputs to a computer graphic system π An attention event, or just "attention," is a stimulus to the graphic system, like a keystroke or light pen use, that hands information to the system β¨ Servicing covers accepting or detecting the hardware input, processing it to work out its intended meaning, and then either passing that info to a user routine, or taking some immediate action related to the display and/or its underlying data structure, or both π The emphasis is on "immediate," okay?? π Attention-handling is NOT meant to include any detailed, application-oriented processing that the attention info might say should happen next π So attention handling can be looked at separately from any particular application, which is so iconic π
2.2 INDEPENDENT FROM DISPLAY CONSIDERATIONS
Not only can attention handling be separated from any application, but attention-generating hardware can also be separated from display hardware π¦ It's honestly often just a coincidence that they come in the same package π¦ In some setups, an input can be processed locally (by the terminal) to produce the right response π§ For example, a keystroke may or may not cause a character to show up on a terminal, and the logic doing the display may or may not be local (inside the terminal) πΈ The keystroke might be shown locally right away, like an alphanumeric display terminal that buffers keystrokes and sends messages of many characters at once, or it might get sent to the host computer and "echoed" back for display, like teletype-style terminals π
It doesn't stop at simple input devices like keyboards either β¨ So-called "intelligent terminals," with built-in programmable logic or even complete small computers, can handle more sophisticated attentions locally, and can even change a local distillate of the central (host) data structure without the central side knowing π That creates a real problem: making sure the display and the graphic application program don't get "out of sync," which calls for a more expressive protocol from terminal to host processor π₯
3.0 SYSTEM CONFIGURATIONS π
Now we get into how system configurations for computer graphics have evolved π The idea is to show that just like display generation moved from device-dependent codes to a generalized protocol, attention generation should evolve too π«Ά
3.1 STAND-ALONE CONFIGURATION
Figure 1 shows the stand-alone graphic configuration, which was the first one and is still the most common π Like we've been stressing, input and output are totally independent, so they're drawn as separate devices π¦ In this setup, display code generation and interrupt processing both happen inside the graphic application program on the host processor π§ The graphic application is very device-dependent, so it's giving tightly coupled energy π
Figure 1 Stand-Alone Graphic Configuration
+----------------------------+
| | _______
| +---------+-----------+ | / \
| | |OUTPUT | | / \
| | /-->|PROCESSOR |----|------------>| |
| | / +-----------+ | \ /
| | | | | \_______/
| | | | | OUTPUT DEVICE
| | | +-----------+ | ______
| | \ |INPUT | | | \
| | \---|PROCESSOR |<-- |-------------|_______\
| +---------+-----------+ |
| Graphic Application | INPUT DEVICE
| Program |
+----------------------------+
/SERVING\ HOST
\USING /3.2 STAND-ALONE CONFIGURATION WITH STANDARDIZED FORMATS
The big conceptual shift happens when the input and output processors get pulled out of the graphic application program π The graphic application then produces output and accepts input in a generalized form, as shown in Figure 2 π The important thing to notice is that adding different input and/or output devices only means replacing or changing those input/output processing routines 𫧠Graphic application programs can be designed without caring which processing routine ends up being used π So far as the application is concerned, device-independence has been achieved π₯Ήβ¨
Figure 2 Stand-Alone Configuration with Standardized Input and Output Formats
+-------------------------------------+ ______
| | /---->/ \
| +-----------+ |DEVICE-DEPENDENT/ ___/___ \
| +-----------+ |--|---------------/ / \ |
| STANDARD | OUTPUT | | |DISPLAY LIST / \ /
| +-----+DISPLAY LIST|PROCESSOR |-+ | | |__/
| | ---|----------->| |----|---------------->\ /
| | | | +-----------+ | \_______/
| | | | | OUTPUT DEVICE(S)
| | | | |
| | | | +-----------+ |DEVICE-DEPENDENT ______
| | | | STANDARD +-----------+ |<-|----------------------| \
| | |--|<-----------|INPUT | | |INPUT DATA ___|___ \
| +-----+ ATTENTION |PROCESSOR |-+ | | \____\
| | |<---|------------------| \
| +-----------+ | |_________\
| Graphic Application Program | INPUT DEVICE(S)
| |
+-------------------------------------+
/SERVING\ HOST
\USING /3.3 NETWORK CONFIGURATION
When the stand-alone configuration with standardized formats gets put on a network, you get the setup in Figure 3 π In the network configuration, the graphic application program and the input and output processors can live in different hosts π¦ The standardized formats become network standards, so any using host with input/output processors that follow the standard can access the graphic application program on the serving host π The network is transparent to the graphic configuration π«Ά
3.4 NETWORK CONFIGURATION WITH INTELLIGENT TERMINAL
Figure 4 is the case of an intelligent graphics terminal sitting on the network π§ Here, the input and output processors live inside the terminal itself β¨ The using host only connects the terminal to the network, and if it's a terminal IMP, it's dropped entirely π Any type of intelligent terminal can access any graphic application program as long as its input and output processing routines conform to the network standard π₯ Same as before, the network is transparent to the graphic configuration π
Figure 3 Network Configuration (Omitted due to complexity)
Figure 4 Network Configuration with Intelligent Terminal (Omitted due to complexity)
4.0 INPUT DEVICES π
Next up is a survey of graphic input devices, as suggested in RFC 87 π The survey focuses on the characteristics of the attention information you get when a device is used, rather than stuff like human factors π
We want to stress from the start that we consider all devices equivalent in capability π What we mean is that with the right programming, any device can simulate any other device πͺ Throughout the survey we'll show typical data conversions that might happen, and sometimes talk about how various devices can be simulated π¦
It's convenient to think about the characteristics of classes of devices πΈ Info about particular commercial devices can be found in reference 5 and elsewhere π Table I gives a summary of the device classes π
4.1 PUSHBUTTONS
Perhaps the first and most primitive class of input device is the pushbutton, which sends some unique code to the system when it's pressed π In the simplest case, the code is just the knowledge that the button got pushed, and it might be as basic as a flag π©
Beyond the basic pushbutton, more advanced key devices have been designed in all kinds of ways π For example, each key might be tied to a single bit in a word or to a complex pattern (a character or byte) 𧩠Multiple keys may or may not be able to be struck at the same time, and if they can, their codes get combined in some defined way π
The salient feature of the function key is that it hands two pieces of info to the system: the fact that a keystroke happened (which might be implicit), and some unique code related to it π Two things, bestie, main character energy π
More elaborate keyboards, whether they're teletypes or solid state devices with fancy "overlays," are just special cases of function keys πΉ They present the same info, which is attention source plus a unique code π«Ά Whether that code can be tied to a displayable character is only incidental at this stage π
Since keyboards allow arbitrary codes to be entered, particular sequences of codes can easily be defined to simulate other devices πͺ If local logic allows it, codes can be collected until a complete sequence is entered, and then reformatted into exactly the same format the simulated device would have produced π¦
Pointing devices like light pens and tablets can be simulated by linking particular keys to screen directions (up, down, right, left) and using them to move a pointer around the screen face π§ This works best on terminals with a hardware connection between the keys and the cursor symbol π
4.2 ANALOG DEVICES β¨
okay so the next most basic class of input devices is the analog to digital converters π₯. this group includes simple shaft encoders, mouse, and trackball. they all put out a digital output that's proportional to an analog input, which in this case is the rotation of a shaft π. several of these can be presented together, like the mouse and trackball π.
these devices all present a device identification (which may be implicit, depending on how the hardware takes input π€·ββοΈ) together with a bunch of digital codes, one for each analog device. the length of the code is arbitrary, and it may or may not relate to things like the maximum raster count of the display screen πΊ. no strict rules, just vibes.
analog devices are super popular as pointing devices, since you use the input to move a cursor around the screen face. honestly this is superior to a keyboard, because you can get really smooth and rapid movement π¦π.
4.3 TABLETS π
a tablet is a flat surface where you indicate an (X,Y) position with a stylus βοΈ. if the position changes can be registered fast enough, you can digitize arbitrary curves just by tracing them π.
this class has a whole variety of devices using lots of different techniques π§ͺ. think variable resistance, variable capacitance, and ultrasonics, just to name a few on the market. the surface can be horizontal or vertical, and it can even be layered right on top of the screen itself π₯οΈ. people have used all kinds of styli, including the operator's finger π. there's also the Lincoln Wand, which can be manipulated in space to yield a position in three dimensions (X,Y,Z) π§. main character energy, no cap.
these devices all present a device identification (which may be implicit) and a position value. that's most often a coordinate pair, but it can also be a triple π.
4.4 LIGHT PEN π¦
light pens relate the occurrence of an attention to the time in the refresh cycle when a particular point is illuminated on the screen β±οΈ. the display generators are generally stopped when the attention occurs, so either the display list "P" register or the (X,Y) beam position registers, or both, can be presented as attention data. but ngl that's often not enough π, because what you really want is some value that identifies the image the pen detected. so local hardware and/or software gets used to get that info. it can be as simple as a single identification code or as elaborate as a genealogical push down list π³π.
light pens present a device identification (which may be implicit) and at least one of the following: memory address, (X,Y) position, item identification.
light pens can also simulate keyboards by displaying "light buttons" on the screen that are associated with particular physical buttons. detecting on a light button is logically equivalent to pushing the related key β¨οΈβ¨.
4.5 INTERNAL ATTENTIONS π«£
internal attentions are stimuli that don't come from operator action. they come from stuff inside the terminal, like a screen edge violation (overflow) or a programmed trap π¨. they present info in pretty much the same way as the operator input devices we already covered. this info is an attention source identification (basically the device identification, which again may be implicit) plus the appropriate data. for the two examples given, that data will generally be a memory address π.
programmed traps are often used to allow mode changes (e.g., enable or disable light pen operation) during the execution of the display list π. edge violation might happen when an image is being relocated in response to operator input. we have to provide for describing these attentions, since they can't always be handled locally in the terminal π.
4.6 LOGICAL ATTENTIONS π§
we can generalize the concept of an attention from a physical source to a logically generated stimulus, which comes from some program condition that may or may not cause an interrupt π. (programmed traps were classified as internal attentions because, by definition, they cause an interrupt or set a hardware flag). logical attentions are generally "input" by setting a software flag that some control program can periodically inspect π³οΈ. for example, logical attentions may be designed to detect when a software-defined edge violation occurs (of a region less than full screen) or when a light button is picked. there's no general form for the information they generate, since they're programmable rather than hardware-bound π€ΈββοΈ. the best we can say is that they consist of an identification and appropriate data. honestly, logical attentions most often simulate physical attentions, so each one can be placed in one of the classes we already described π«Ά.
TABLE I
INPUT DEVICE SUMMARY
DEVICE CLASS DEVICE EXAMPLES TYPICAL OUTPUT
Button Teletype 1 Character
Function Key with Overlay 1 Character and
overlay code
Buffered Keyboard n Characters
A/D Converter Shaft Encoder delta a
Mouse (delta a, delta b)
Tablet Rand Tables and (X,Y)
Lincoln Word (X,Y,Z)
Light Pen Light Pen P (memory address)
Light Pen (X,Y)
Light Pen and Local Software Item Name
Light Pen and Local Software Item name stack
Internal Program Trap P (memory address)
Screen Overflow P (memory address)
Logical Attention Any of the above Any of the above5.0 INTELLIGENT TERMINALS π§ π
as has been indicated, things get complicated when "intelligent terminals" enter the chat π€―. an intelligent terminal can modify the data that the input device hardware presents. so in a sense, all of an intelligent terminal's outputs can be considered logical attentions π«. the logical complexity of those attentions can be very great indeed. for example, a terminal might be programmed to do sketching functions, so the net effect of a keystroke and a light pen hit could be deleting part of the picture, plus some coded message about it βοΈ. there's even a technique that lets the light pen operator simulate a shaft encoder by twisting their wrist while holding the pen over a tracking symbol (7) ππ.
some intelligent terminal systems let the terminal operator modify the picture and the local data structure independently (2). so the need for a very expressive protocol from terminal to central computer becomes apparent, so that notice of that local processing can be communicated to the central program π¨π«Ά.
6.0 NETWORK PROTOCOL GUIDELINES π‘
we now suggest a format for a (third level) network protocol from terminal to serving host. it's open-ended enough to let any type of attention get communicated π¦. it's not the intent here to formally propose the protocol all the way down to the level of "this bit means that." when those details get decided, a Network Standard Attention will have been defined π―.
the attention protocol has three basic elements: device identification, data identification, and data π.
6.1 DEVICE IDENTIFICATION
the device identification field must be sufficiently large to permit the unique identification of any TYPE OF DEVICE in the network π. if two or more identical input devices exist at different nodes in the network, you don't have to tell them apart in this field π―. but if a keyboard has keys that are logically different, like typewriter keys and function keys, the distinction should be made in the identification field, instead of making anyone analyze the data π. and if two different devices are logically equivalent, like a physical keyboard and light buttons, they may be treated that way by NOT having identification codes that differ from each other π§Έ.
somewhere in the network (and possibly at each host supporting a graphic application), a table should be kept of the input device types and their characteristics π. it may be convenient to organize the device identification field so that a subfield identifies the device CLASS, as discussed previously ποΈ.
6.2 DATA IDENTIFICATION
the device identification field is meant to hold a description of the data field that follows π·οΈ. the info that might be provided here includes the number of units (bits, words, bytes) of data that follow, a qualitative description of the data (character code, memory address, cartesian coordinates, item name, etc.), and data format information π. for the sake of uniformity, it may be desirable to include this info even when it's kinda redundant π .
6.3 DATA
lastly comes the data itself (perhaps an anticlimax at this point!) π. as should be clear by now, it can be of arbitrary length and organization πβ¨.
BIBLIOGRAPHY π
- Cotton, I. "Languages for Graphic Attention-Handling." Proc. Computer Graphics 70 Symposium, Brunel University, 197.
- Cotton, I. and F. Greatorex "Data Structures and Techniques for Remote Computer Graphics," Proc. FJCC, 1968, pp. 533-544.
- Crocker, S. "Proposal for a Network Standard Format for a Data Stream to Control Graphics Display." ARPA Network Working Group, RFC # 86, 1971.
- Harslem, E. and J. Heafner "Some Thoughts on Network Graphics," ARPA Network Working Group, RFC # 94, 1971.
- Keast, D. "Survey of Graphic Input Devices," MACHINE DESIGN. August 3, 1967, pp. 114-120.
- McConnell, J. "Response to RFC #86," ARPA Network Working Group, RFC #125, 1971.
- Newman, W. "A Graphical Technique for Numerical Input," COMPUTER J., May 1968, pp. 63-64.
- Vezza, A. "Topic for Discussion at the Next Network Working Group Meeting." ARPA Network Working Group, RFC #87, 1971.
[This RFC was put into machine readable form for entry] [into the online RFC archives by Kelly Tardif,ViagοΏ½nie 11/99]
π¦ where this page comes from
- ietf: rfc178 1971-06
- π girlified by claude-haiku-5-5 on : a language model's rewrite of the original, under its terms