There are two ways that Hemlock displays information on the screen; one is normal buffer display, in which the text being edited is shown on the screen, and the other is a pop-up window. [annotate]
Some commands print out information that is of little permanent value, and these commands use a pop-up window to display the information. It is known as a pop-up window because it temporarily appears on the screen overlaying text already displayed. Most commands of this nature can generate their output quickly, but in case there is a lot of output, or the user wants to repeatedly refer to the same output while editing, Hemlock saves the output in a buffer. Different commands may use different buffers to save their output, and we refer to these as random typeout buffers. [annotate]
If the amount of output exceeds the size of the pop-up window, Hemlock displays the message "--More--" after each window full. The following are valid responses to this prompt: [annotate]
Any other input causes the system to abort using the key-event to determine the next command to execute. [annotate]
When the output is complete, Hemlock displays the string "--Flush--" in the pop-up window's modeline, indicating that the user may flush the temporary display. Typing any of the key-events described above removes the pop-up window, but typing k still produces a window suitable for normal editing. Any other input also flushes the display, but Hemlock uses the key-event to determine the next command to invoke. [annotate]
This command makes the most recently used random typeout buffer the current buffer in the current window. [annotate] |
Random typeout buffers are always in Fundamental mode. [annotate]
If a line of text is too long to fit within the screen width it is wrapped, with Hemlock displaying consecutive pieces of the text line on as many screen lines as needed to hold the text. Hemlock indicates a wrapped line by placing a line-wrap character in the last column of each screen line. Currently, the line-wrap character is an exclamation point (!). It is possible for a line to wrap off the bottom of the screen or on to the top. [annotate]
Hemlock wraps screen lines when the line is completely full regardless of the line-wrap character. Most editors insert the line-wrap character and wrap a single character when a screen line would be full if the editor had avoided wrapping the line. In this situation, Hemlock would leave the screen line full. This means there are always at least two characters on the next screen line if Hemlock wraps a line of display. When the cursor is at the end of a line which is the full width of the screen, it is displayed in the last column, since it cannot be displayed off the edge. [annotate]
Hemlock displays most characters as themselves, but it treats some specially: [annotate]
Since a character may be displayed using more than one printing character, there are some positions on the screen which are in the middle of a character. When the cursor is on a character with a multiple-character representation, Hemlock always displays the cursor on the first character. [annotate]
When redisplaying the current window, Hemlock makes sure the current point is visible. This is the behavior you see when you are entering text near the bottom of the window, and suddenly redisplay shifts your position to the window's center. [annotate]
Some buffers receive input from streams and other processes, and you might have windows displaying these. However, if those windows are not the current window, the output will run off the bottom of the windows, and you won't be able to see the output as it appears in the buffers. You can change to a window in which you want to track output and invoke the following command to remedy this situation. [annotate]
This command makes the current window track the buffer's point. This means that each time Hemlock redisplays, it will make sure the buffer's point is visible in the window. This is useful for windows that are not current and that display buffer's that receive output from streams coming from other processes. [annotate] |
A modeline is the line displayed at the bottom of each window where Hemlock shows information about the buffer displayed in that window. Here is a typical modeline: Hemlock USER: (Fundamental Fill) /usr/slisp/hemlock/user.mss This tells us that the file associated with this buffer is "/usr/slisp/hemlock/user.mss", and the Current Package for Lisp interaction commands is the "USER" package. The modes currently present are Fundamental and Fill; the major mode is always displayed first, followed by any minor modes. If the buffer has no associated file, then the buffer name will be present instead: Hemlock PLAY: (Lisp) Silly: In this case, the buffer is named Silly and is in Lisp mode. The user has set Current Package for this buffer to "PLAY". [annotate]
This variable controls how much of a pathname Hemlock displays in a modeline. Some distributed file systems can have very long pathnames which leads to the more particular information in a pathname running off the end of a modeline. When set, the system chops off leading directories until the name is less than the integer value of this variable. Three dots, ..., indicate a truncated name. The user can establish this variable buffer locally with the Defhvar command. [annotate] |
If the user has modified the buffer since the last time it was read from or save to a file, then the modeline contains an asterisk (*) between the modes list and the file or buffer name: Hemlock USER: (Fundamental Fill) * /usr/slisp/hemlock/user.mss This serves as a reminder that the buffer should be saved eventually. [annotate]
There is a special modeline known as the status line which appears as the Echo Area's modeline. Hemlock and user code use this area to display general information not particular to a buffer -- recursive edits, whether you just received mail, etc. [annotate]